fop_lang 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5f19a543b81c0046dc63fcc1c0769989628017d2c1d1da74ef0db9866a0f2f7
-  data.tar.gz: 03b6597f9cab97c95ccda8396693bb43d9da729137cb916cc74f7fbecc314b32
+  metadata.gz: 8ed95bb4708820a186e6485cc29dbb47286b0f309a1caf91af7778d768b0efb3
+  data.tar.gz: 85d41728ddae13f3667f0a2d55a5c4dcbc26e8217d4f31466e6ed92038859881
 SHA512:
-  metadata.gz: 3a17c82a561e20cbc5cb8abbad5be4f94f02110d60b6130e3e1e9489672c5c134befc6b1daca2f590f083a67934e600fb5d6fa0ea5433181ba3014514c558232
-  data.tar.gz: 790250c8a79dcf04b381f2dd33cbaa048fd070688ab45446ff87652dcb18844c2d6139d0ead060fa338a57b8590eee0167ea2c25abd84e1d71571f33c49bcbda
+  metadata.gz: e650bdf66d8d0b5dcb603eae494f38d4969a19647053b4e81e0612705f5b16a5755d007e4ce01fad9b487224d66eff462738f1e37b011ba2a4bf4a45b0203bb3
+  data.tar.gz: 99b31736236785cecc85b9bb23ccc3e366713cd23dd04c992a8fff6676a316d5741bfe5058e17cd0812c43d8bf1979aa7546184386018c1f92ed2462a85eb5fb

data/README.md

@@ -29,7 +29,7 @@ The above expression contains the only two parts of Fop (except for the wildcard
 
 **Text Literals**
 
-A text literal works how it sounds: the input must match it exactly. The only exception is the `*` (wildcard) character, which matches 0 or more of anything. Wildcards can be used anywhere except inside `{...}` (operations).
+A text literal works how it sounds: the input must match it exactly. If it matches it passes through unchanged. The only exception is the `*` (wildcard) character, which matches 0 or more of anything. Wildcards can be used anywhere except inside `{...}` (operations).
 
 If `\` (escape) is used before the special characters `*`, `{` or `}`, then that character is treated like a text literal. It's recommended to use single-quoted Ruby strings with Fop expressions that so you don't need to double-escape.
 
@@ -42,9 +42,11 @@ Operations are the interesting part of Fop, and are specified between `{` and `}
   * `A` is the alpha class and will match one or more letters (lower or upper case).
   * `W` is the word class and matches alphanumeric chars and underscores.
   * `*` is the wildcard class and greedily matches everything after it.
-  * `/.../` matches on the supplied regex between the `/`'s. If you're regex contains a `/`, it must be escaped.
+  * `/.../` matches on the supplied regex between the `/`'s. If you're regex contains a `/`, it must be escaped. Capture groups may be referenced in the operator argument as `$1`, `$2`, etc.
 3. Operator (optional): What to do to the matching characters.
-  * `=` Replace the matching character(s) with the given argument. If no argument is given, drop the matching chars. Note that any `/` chars must be escaped, so as not to be mistaken for a regex.
+  * `=` Replace the matching character(s) with the given argument. If no argument is given, drop the matching chars.
+  * `>` Append the following chars to the matching value.
+  * `<` Prepend the following chars to the matching value.
   * `+` Perform addition on the matching number and the argument (`N` only).
   * `-` Subtract the argument from the matching number (`N` only).
 5. Operator argument (required for some operators): meaning varies by operator.

data/lib/fop/nodes.rb

@@ -12,11 +12,15 @@ module Fop
       end
     end
 
-    Op = Struct.new(:wildcard, :match, :regex_match, :regex, :operator, :operator_arg, :expression) do
+    Op = Struct.new(:wildcard, :match, :regex_match, :regex, :operator, :operator_arg, :operator_arg_w_caps, :expression) do
       def consume!(input)
-        if (val = input.slice!(regex))
-          found_val = regex_match || val != Parser::BLANK
-          expression && found_val ? expression.call(val) : val
+        if (match = regex.match(input))
+          val = match.to_s
+          blank = val == Parser::BLANK
+          input.sub!(val, Parser::BLANK) unless blank
+          found_val = regex_match || !blank
+          arg = operator_arg_w_caps ? sub_caps(operator_arg_w_caps, match.captures) : operator_arg
+          expression && found_val ? expression.call(val, operator, arg) : val
         end
       end
 
@@ -26,6 +30,18 @@ module Fop
         s << " #{operator} #{operator_arg}" if operator
         s
       end
+
+      private
+
+      def sub_caps(tokens, caps)
+        tokens.map { |t|
+          case t
+          when String then t
+          when Parser::CaptureGroup then caps[t.index].to_s
+          else raise Parser::Error, "Unexpected #{t} in capture group"
+          end
+        }.join("")
+      end
     end
   end
 end

data/lib/fop/parser.rb

@@ -3,6 +3,7 @@ require_relative 'nodes'
 module Fop
   module Parser
     Error = Class.new(StandardError)
+    CaptureGroup = Struct.new(:index)
 
     MATCH_NUM = "N".freeze
     MATCH_WORD = "W".freeze
@@ -10,10 +11,19 @@ module Fop
     MATCH_WILD = "*".freeze
     BLANK = "".freeze
     OP_REPLACE = "=".freeze
+    OP_APPEND = ">".freeze
+    OP_PREPEND = "<".freeze
     OP_ADD = "+".freeze
     OP_SUB = "-".freeze
     OP_MUL = "*".freeze
     OP_DIV = "/".freeze
+    VAR = "$".freeze
+    CAP_NUM = /^[1-9]$/
+
+    EXP_REPLACE = ->(_val, _op, arg) { arg || BLANK }
+    EXP_MATH = ->(val, op, arg) { val.to_i.send(op, arg.to_i) }
+    EXP_APPEND = ->(val, _op, arg) { val + arg }
+    EXP_PREPEND = ->(val, _op, arg) { arg + val }
 
     def self.parse!(tokens)
       nodes = []
@@ -45,7 +55,7 @@ module Fop
       when Nodes::Text, Nodes::Op
         nodes << curr_node
       else
-        raise "Unexpected end node #{curr_node}"
+        raise Error, "Unexpected end node #{curr_node}"
       end
 
       nodes
@@ -59,7 +69,7 @@ module Fop
         Nodes::Text.new(wildcard, token.char.clone)
       when Tokenizer::Op
         op = Nodes::Op.new(wildcard)
-        parse_op! op, token.tokens
+        parse_op! op, token
         op
       when :wildcard
         :wildcard
@@ -85,52 +95,87 @@ module Fop
       end
     end
 
-    def self.parse_op!(node, tokens)
-      t = tokens[0] || raise(Error, "Empty operation")
+    def self.parse_op!(node, token)
       # parse the matching type
       node.regex =
-        case t
+        case token.match
         when Tokenizer::Char
-          node.match = t.char
+          node.match = token.match.char
           node.regex_match = false
-          case t.char
+          case node.match
           when MATCH_NUM then Regexp.new((node.wildcard ? ".*?" : "^") + "[0-9]+")
           when MATCH_WORD then Regexp.new((node.wildcard ? ".*?" : "^") + "\\w+")
           when MATCH_ALPHA then Regexp.new((node.wildcard ? ".*?" : "^") + "[a-zA-Z]+")
           when MATCH_WILD then /.*/
-          else raise Error, "Unknown match type '#{t.char}'"
+          else raise Error, "Unknown match type '#{node.match}'"
           end 
         when Tokenizer::Regex
-          node.match = "/#{t.src}/"
+          node.match = "/#{token.match.src}/"
           node.regex_match = true
-          Regexp.new((node.wildcard ? ".*?" : "^") + t.src)
+          Regexp.new((node.wildcard ? ".*?" : "^") + token.match.src)
+        when nil
+          raise Error, "Empty operation"
         else
-          raise Error, "Unexpected token #{t}"
+          raise Error, "Unexpected #{token.match}"
         end
 
       # parse the operator (if any)
-      if (op = tokens[1])
-        raise Error, "Unexpected #{op}" unless op.is_a? Tokenizer::Char
-        node.operator = op.char
-
-        arg = tokens[2..-1].reduce("") { |acc, t|
-          raise Error, "Unexpected #{t}" unless t.is_a? Tokenizer::Char
-          acc + t.char
-        }
-        node.operator_arg = arg == BLANK ? nil : arg
-
+      if token.operator
+        raise Error, "Unexpected #{token.operator} for operator" unless token.operator.is_a? Tokenizer::Char
+        node.operator = token.operator.char
+        node.operator_arg = token.arg if token.arg and token.arg != BLANK
+        node.operator_arg_w_caps = parse_captures! node.operator_arg if node.operator_arg and node.regex_match
         node.expression =
           case node.operator
           when OP_REPLACE
-            ->(_) { node.operator_arg || BLANK }
+            EXP_REPLACE
           when OP_ADD, OP_SUB, OP_MUL, OP_DIV
             raise Error, "Operator #{node.operator} is only available for numeric matches" unless node.match == MATCH_NUM
             raise Error, "Operator #{node.operator} expects an argument" if node.operator_arg.nil?
-            ->(x) { x.to_i.send(node.operator, node.operator_arg.to_i) }
+            EXP_MATH
+          when OP_APPEND
+            raise Error, "Operator #{node.operator} expects an argument" if node.operator_arg.nil?
+            EXP_APPEND
+          when OP_PREPEND
+            raise Error, "Operator #{node.operator} expects an argument" if node.operator_arg.nil?
+            EXP_PREPEND
           else
-            raise(Error, "Unknown operator #{node.operator}")
+            raise Error, "Unknown operator #{node.operator}"
           end
       end
     end
+
+    def self.parse_captures!(arg)
+      i = 0
+      iend = arg.size - 1
+      escape = false
+      nodes = []
+
+      until i > iend
+        char = arg[i]
+        i += 1
+
+        if escape
+          nodes << char
+          escape = false
+          next
+        end
+
+        case char
+        when Tokenizer::ESCAPE
+          escape = true
+        when VAR
+          num = arg[i].to_s
+          raise Error, "Capture group number must be between 1 and 9; found '#{num}'" unless num =~ CAP_NUM
+          nodes << CaptureGroup.new(num.to_i - 1)
+          i += 1
+        else
+          nodes << char
+        end
+      end
+
+      raise Error, "Trailing escape" if escape
+      nodes
+    end
   end
 end

data/lib/fop/tokenizer.rb

@@ -1,7 +1,7 @@
 module Fop
   class Tokenizer
     Char = Struct.new(:char)
-    Op = Struct.new(:tokens)
+    Op = Struct.new(:match, :operator, :arg)
     Regex = Struct.new(:src)
     Error = Class.new(StandardError)
 
@@ -22,28 +22,26 @@ module Fop
       i = 0
       until i > @end do
         char = @src[i]
+        i += 1
+
         if escape
           tokens << Char.new(char)
           escape = false
-          i += 1
           next
         end
 
         case char
         when ESCAPE
           escape = true
-          i += 1
         when OP_OPEN
-          i, op = operation! i + 1
+          i, op = operation! i
           tokens << op
         when OP_CLOSE
           raise "Unexpected #{OP_CLOSE}"
         when WILDCARD
           tokens << :wildcard
-          i += 1
         else
           tokens << Char.new(char)
-          i += 1
         end
       end
 
@@ -54,40 +52,63 @@ module Fop
     private
 
     def operation!(i)
-      escape = false
       found_close = false
-      tokens = []
+      op = Op.new(nil, nil, "")
 
+      # Find matcher
+      until found_close or op.match or i > @end do
+        char = @src[i]
+        i += 1
+        case char
+        when OP_CLOSE
+          found_close = true
+        when REGEX_MARKER
+          i, reg = regex! i
+          op.match = reg
+        else
+          op.match = Char.new(char)
+        end
+      end
+
+      # Find operator
+      until found_close or op.operator or i > @end do
+        char = @src[i]
+        i += 1
+        case char
+        when OP_CLOSE
+          found_close = true
+        else
+          op.operator = Char.new(char)
+        end
+      end
+
+      # Find operator arg
+      escape = false
       until found_close or i > @end do
         char = @src[i]
+        i += 1
+
         if escape
-          tokens << Char.new(char)
+          op.arg << char
           escape = false
-          i += 1
           next
         end
 
         case char
         when ESCAPE
           escape = true
-          i += 1
         when OP_OPEN
           raise "Unexpected #{OP_OPEN}"
         when OP_CLOSE
           found_close = true
-          i += 1
-        when REGEX_MARKER
-          i, reg = regex! i + 1
-          tokens << reg
         else
-          tokens << Char.new(char)
-          i += 1
+          op.arg << char
         end
       end
 
       raise Error, "Unclosed operation" if !found_close
       raise Error, "Trailing escape" if escape
-      return i, Op.new(tokens)
+      return i, op
     end
 
     def regex!(i)

data/lib/fop/version.rb

@@ -1,3 +1,3 @@
 module Fop
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fop_lang
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jordan Hollinger