Merge pull request #4 from gebv/bug-#2

internal refactoring, bug fixes #2

Author: gebv

strparam.go pattern.gostrparam.go renamed to pattern.go

@@ -1,53 +1,73 @@
 package strparam
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 	"unicode/utf8"
 )
 
+// ParseWithName analyzes the pattern, split it into tokens. Saves the schema name.
+//
+// Iterate over the UTF-8 characters (with correct offset of bytes).
+func ParseWithName(name, exp string) (*Pattern, error) {
+	return parse(name, exp)
+}
+
 // Parse analyzes the pattern, split it into tokens.
 //
 // Iterate over the UTF-8 characters (with correct offset of bytes).
-func Parse(in string) (*PatternSchema, error) {
+func Parse(exp string) (*Pattern, error) {
+	return parse("", exp)
+}
+
+func parse(patternName, exp string) (*Pattern, error) {
+	if exp == "" {
+		return nil, errors.New("expression should not is empty")
+	}
+
 	tokens := getlistTokens()
 	defer putlistTokens(tokens)
 
 	// end and start of parameter positions in bytes
 	var start, end int = 0, 0
-	// current mode
-	var mode TokenMode
+	// current mode (initial as Pattern)
+	var mode TokenMode = CONST
 	// is flag of start char of input string
 	var EOF bool
 	// number of parameters
 	var numParams int
 
-	// end of input string
+	// start of input string
 	tokens = append(tokens, Token{
-		Mode: BEGINLINE,
+		Mode: START,
 	})
 
 	// current UTF-8 character in a word
 	var char rune
 
 	// w - character width in bytes
-	for i, w := 0, 0; i < len(in); i += w {
-		char, w = utf8.DecodeRuneInString(in[i:])
-		EOF = i == len(in)-1
+	for i, w := 0, 0; i < len(exp); i += w {
+		char, w = utf8.DecodeRuneInString(exp[i:])
+		EOF = i == len(exp)-1
 
 		switch char {
 		case DefaultStartParam:
 
 			// invalid input string if after end border of parameter got new parameter
-			if i-end == 0 {
+			if i > 0 && i-end == 0 {
 				return nil, fmt.Errorf("should be a pattern between the parameters, pos %d", i)
 			}
 
-			tokens = append(tokens, Token{
-				Mode: PATTERN,
-				Len:  i - end,
-				Raw:  in[end:i],
-			})
+			if i-end > 0 {
+				// skip empty pattern
+				// - at beginning of the input string the parameter
+				tokens = append(tokens, Token{
+					Mode: CONST,
+					Len:  i - end,
+					Raw:  exp[end:i],
+				})
+			}
 
 			mode = PARAMETER
 			start = i // sets start position of parameter
@@ -64,10 +84,10 @@ func Parse(in string) (*PatternSchema, error) {
 
 			tokens = append(tokens, Token{
 				Mode: PARAMETER,
-				Raw:  in[start : i+1],
+				Raw:  exp[start : i+1],
 			})
 
-			mode = PATTERN
+			mode = CONST
 			end, start = i+1, i+1 // zeroing positions
 			numParams++
 		}
@@ -78,36 +98,47 @@ func Parse(in string) (*PatternSchema, error) {
 				return nil, fmt.Errorf("parameter was not closed, pos %d", i)
 			}
 
-			if mode == PATTERN {
+			if mode == CONST {
 				// if exists chars after closed parameter
 				if i+1-end > 0 {
 					tokens = append(tokens, Token{
-						Mode: PATTERN,
+						Mode: CONST,
 						Len:  i + 1 - end,
-						Raw:  in[end : i+1],
+						Raw:  exp[end : i+1],
 					})
 				}
 			}
 		}
 	}
 
-	// start of input string
+	// end of input string
 	tokens = append(tokens, Token{
-		Mode: ENDLINE,
+		Mode: END,
+		Raw:  patternName,
 	})
 
-	return &PatternSchema{
-		Pattern:   in,
+	return &Pattern{
 		Tokens:    tokens,
 		NumParams: numParams,
 	}, nil
 }
 
 // Lookup returns list params if input string matched to schema.
-func (s *PatternSchema) Lookup(in string) (bool, Params) {
+//
+// NOTE: nothing (empty list of tokens) not matches to anything.
+func (s *Pattern) Lookup(in string) (bool, Params) {
+	if s == nil {
+		return false, nil
+	}
+
 	params := getListParams()
 	defer putListParams(params)
 
+	if len(s.Tokens) == 0 {
+		// nothing not matches to anything
+		return false, nil
+	}
+
 	// this is the sum of the lengths of the patterns and found value of parameters
 	var offset int
 
@@ -117,12 +148,9 @@ func (s *PatternSchema) Lookup(in string) (bool, Params) {
 		}
 
 		switch t.Mode {
-		case BEGINLINE:
-		case ENDLINE:
-			if offset < len(in) {
-				// have tail without pattern
-				return false, nil
-			}
+		case START:
+		case END:
+			goto exitloop
 		case PARAMETER_PARSED:
 			params = append(params, Param{
 				Name:  t.ParamName(),
@@ -132,13 +160,13 @@ func (s *PatternSchema) Lookup(in string) (bool, Params) {
 		case PARAMETER:
 			_next := s.Tokens[num+1]
 			switch _next.Mode {
-			case ENDLINE:
+			case END:
 				params = append(params, Param{
 					Name:  t.ParamName(),
 					Value: in[offset:],
 				})
 				offset += len(in) - offset
-			case PATTERN:
+			case CONST:
 				if found := strings.Index(in[offset:], _next.Raw); found > -1 {
 					params = append(params, Param{
 						Name:  t.ParamName(),
@@ -152,28 +180,57 @@ func (s *PatternSchema) Lookup(in string) (bool, Params) {
 			default:
 				return false, nil
 			}
-		case PATTERN:
+		case CONST:
 			if in[offset:offset+t.Len] == t.Raw {
 				// add the length of the pattern
 				offset += t.Len
 			} else {
+				// forced return because pattern is not matched
 				return false, nil
 			}
 		}
 	}
 
+exitloop:
+
+	// offset did not seeking to end of by input value
+	if len(in) != offset {
+		return false, nil
+	}
+
+	// received an unexpected number of parameters
 	if len(params) != s.NumParams {
 		return false, nil
 	}
+
 	return true, params
 }
 
-type PatternSchema struct {
-	Pattern   string
-	Tokens    []Token
+type Pattern struct {
+	Tokens    Tokens
 	NumParams int
 }
 
+// String returns schema of pattern.
+func (s Pattern) String() string {
+	return s.Tokens.String()
+}
+
+// Name returns name of pattern (by end token if sets).
+func (s Pattern) Name() string {
+	if s.Tokens == nil {
+		return ""
+	}
+	if len(s.Tokens) <= 1 {
+		return ""
+	}
+	endToken := s.Tokens[len(s.Tokens)-1]
+	if endToken.Mode != END {
+		return ""
+	}
+	return endToken.Raw
+}
+
 type Param struct {
 	Name  string
 	Value string