fop_lang 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 62ded9f974ca670a6eca5d4b293f98195af25ab476e9b3571e7def5299499fa9
+  data.tar.gz: b53b6e276ee31f122571a096dd534ed5c1407d27384fab78d216886322751fcb
+SHA512:
+  metadata.gz: 45509b09122e4f76f1f8219d8c0f094bc5ac77231dec25f6e0e9818932b68186d74c71dd74db80638dcfc9bae210892b563e660004cfd32c25f439c761c3edc2
+  data.tar.gz: 49c6153cf728e909e60bc8fa1f1214dcdd8f9532703c8bc3455999aac1aa421c629370e1c7669bc9a846b5886fa2f10b7f5b698426cae2830e73ca9623a32a4a

data/README.md

@@ -0,0 +1,44 @@
+# fop_lang
+
+Fop is a tiny expression language implemented in Ruby for text filtering and modification.
+
+## Examples
+
+```ruby
+  f = Fop("release-{N}.{N+1}.{N=0}")
+
+  puts f.apply("release-5.99.1")
+  =>           "release-5.100.0"
+
+  puts f.apply("release-5")
+  => nil
+  # doesn't match the pattern
+```
+
+```ruby
+  f = Fop("release-{N=5}.{N+1}.{N=0}")
+
+  puts f.apply("release-4.99.1")
+  =>           "release-5.100.0"
+```
+
+```ruby
+  f = Fop("release-*{N=5}.{N+100}.{N=0}")
+
+  puts f.apply("release-foo-4.100.1")
+  =>           "release-foo-5.200.0"
+```
+
+```ruby
+  f = Fop("release-{N=5}.{N+1}.{N=0}{*=}")
+
+  puts f.apply("release-4.100.1.foo.bar")
+  =>           "release-5.101.0"
+```
+
+```ruby
+  f = Fop("{W=version}-{N=5}.{N+1}.{N=0}")
+
+  puts f.apply("release-4.100.1")
+  =>           "version-5.101.0"
+```

data/lib/fop/nodes.rb

@@ -0,0 +1,69 @@
+module Fop
+  module Nodes
+    Text = Struct.new(:wildcard, :str) do
+      def consume!(input)
+        @regex ||= Regexp.new((wildcard ? ".*" : "^") + Regexp.escape(str))
+        input.slice!(@regex)
+      end
+
+      def to_s
+        w = wildcard ? "*" : nil
+        "Text #{w}#{str}"
+      end
+    end
+
+    Match = Struct.new(:wildcard, :tokens) do
+      NUM = "N".freeze
+      WORD = "W".freeze
+      WILD = "*".freeze
+      BLANK = "".freeze
+
+      def consume!(input)
+        if (val = input.slice!(@regex))
+          @expression && val != BLANK ? @expression.call(val) : val
+        end
+      end
+
+      def to_s
+        w = wildcard ? "*" : nil
+        @op ? "#{w}#{@match} #{@op} #{@arg}" : "#{w}#{@match}"
+      end
+
+      def parse!
+        match = tokens.shift || raise(ParserError, "Empty match")
+        raise ParserError, "Unexpected #{match}" unless match.is_a? Tokenizer::Char
+
+        @match = match.char
+        @regex =
+          case @match
+          when NUM then Regexp.new((wildcard ? ".*?" : "^") + "[0-9]+")
+          when WORD then Regexp.new((wildcard ? ".*?" : "^") + "[a-zA-Z]+")
+          when WILD then /.*/
+          else raise ParserError, "Unknown match type '#{@match}'"
+          end
+
+        if (op = tokens.shift)
+          raise ParserError, "Unexpected #{op}" unless op.is_a? Tokenizer::Char
+          arg = tokens.reduce("") { |acc, t|
+            raise ParserError, "Unexpected #{t}" unless t.is_a? Tokenizer::Char
+            acc + t.char
+          }
+
+          @op = op.char
+          @arg = arg == BLANK ? nil : arg
+          @expression =
+            case @op
+            when "=" then ->(_) { @arg || BLANK }
+            when "+", "-", "*", "/"
+              raise ParserError, "Operator #{@op} is only available for numeric matches" unless @match == NUM
+              raise ParserError, "Operator #{@op} expects an argument" if @arg.nil?
+              ->(x) { x.to_i.send(@op, @arg.to_i) }
+            else raise ParserError, "Unknown operator #{@op}"
+            end
+        else
+          @op, @arg, @expression = nil, nil, nil
+        end
+      end
+    end
+  end
+end

data/lib/fop/parser.rb

@@ -0,0 +1,93 @@
+require_relative 'nodes'
+
+module Fop
+  module Parser
+    Error = Class.new(StandardError)
+
+    def self.parse!(tokens)
+      stack = []
+      current_el = nil
+
+      tokens.each { |token|
+        case current_el
+        when nil
+          current_el = new_element token
+        when :wildcard
+          current_el = new_element token, true
+          raise Error, "Unexpected * after wildcard" if current_el == :wildcard
+        when Nodes::Text
+          current_el = parse_text stack, current_el, token
+        when Nodes::Match
+          current_el = parse_match stack, current_el, token
+        else
+          raise Error, "Unexpected token #{token} in #{current_el}"
+        end
+      }
+
+      case current_el
+      when nil
+        # noop
+      when :wildcard
+        stack << Nodes::Text.new(true, "")
+      when Nodes::Text
+        stack << current_el
+      when Nodes::Match
+        raise Error, "Unclosed match"
+      end
+
+      stack
+    end
+
+    private
+
+    def self.new_element(token, wildcard = false)
+      case token
+      when Tokenizer::Char
+        Nodes::Text.new(wildcard, token.char.clone)
+      when :match_open
+        Nodes::Match.new(wildcard, [])
+      when :match_close
+        raise ParserError, "Unmatched }"
+      when :wildcard
+        :wildcard
+      else
+        raise ParserError, "Unexpected #{token}"
+      end
+    end
+
+    def self.parse_text(stack, text_el, token)
+      case token
+      when :match_open
+        stack << text_el
+        Nodes::Match.new(false, [])
+      when :match_close
+        raise ParserError.new, "Unexpected }"
+      when Tokenizer::Char
+        text_el.str << token.char
+        text_el
+      when :wildcard
+        stack << text_el
+        :wildcard
+      else
+        raise ParserError, "Unexpected #{token}"
+      end
+    end
+
+    def self.parse_match(stack, match_el, token)
+      case token
+      when Tokenizer::Char
+        match_el.tokens << token
+        match_el
+      when :wildcard
+        match_el.tokens << Tokenizer::Char.new("*").freeze
+        match_el
+      when :match_close
+        match_el.parse!
+        stack << match_el
+        nil
+      else
+        raise ParserError, "Unexpected #{token}"
+      end
+    end
+  end
+end

data/lib/fop/program.rb

@@ -0,0 +1,24 @@
+require_relative 'tokenizer'
+require_relative 'parser'
+
+module Fop
+  class Program
+    attr_reader :nodes
+
+    def initialize(src)
+      tokens = Tokenizer.tokenize! src
+      @nodes = Parser.parse! tokens
+    end
+
+    def apply(input)
+      input = input.clone
+      output =
+        @nodes.reduce("") { |acc, token|
+          section = token.consume!(input)
+          return nil if section.nil?
+          acc + section.to_s
+        }
+      input.empty? ? output : nil
+    end
+  end
+end

data/lib/fop/tokenizer.rb

@@ -0,0 +1,34 @@
+module Fop
+  module Tokenizer
+    Char = Struct.new(:char)
+    Error = Class.new(StandardError)
+
+    def self.tokenize!(src)
+      tokens = []
+      escape = false
+      src.each_char { |char|
+        if escape
+          tokens << Char.new(char)
+          escape = false
+          next
+        end
+
+        case char
+        when "\\".freeze
+          escape = true
+        when "{".freeze
+          tokens << :match_open
+        when "}".freeze
+          tokens << :match_close
+        when "*".freeze
+          tokens << :wildcard
+        else
+          tokens << Char.new(char)
+        end
+      }
+
+      raise Error, "Trailing escape" if escape
+      tokens
+    end
+  end
+end

data/lib/fop/version.rb

@@ -0,0 +1,3 @@
+module Fop
+  VERSION = "0.1.0"
+end

data/lib/fop_lang.rb

@@ -0,0 +1,12 @@
+require_relative 'fop/version'
+require_relative 'fop/program'
+
+def Fop(src)
+  ::Fop::Program.new(src)
+end
+
+module Fop
+  def self.compile(src)
+    Program.new(src)
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: fop_lang
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jordan Hollinger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-08-15 00:00:00.000000000 Z
+dependencies: []
+description: A micro expression language for Filter and OPerations on text
+email: jordan.hollinger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/fop/nodes.rb
+- lib/fop/parser.rb
+- lib/fop/program.rb
+- lib/fop/tokenizer.rb
+- lib/fop/version.rb
+- lib/fop_lang.rb
+homepage: https://jhollinger.github.io/fop-lang-rb/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A micro expression language
+test_files: []