meta_parse 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35a61cdea68ccbca473d11440d4f21a6c0b19569
+  data.tar.gz: b13deef76ec7cbfe70b7177616b9326d9a51ebd8
+SHA512:
+  metadata.gz: 991234302ec3a0309825a005feb0328e968324363d5881082e3188c5288b68c056ff857f53d1c08b28fc98bb86919e1a3045c28a37d914d8f67ead924b369c44
+  data.tar.gz: 123ec7e2bfde4e868fda6d93c3692b45dd449e37da1aa2cadf46269a89b132e4b0ab28dce160890846737fe0cc456929cd18cb4ee318016907d73264ae402da9

data/lib/meta_parse.rb

@@ -0,0 +1,337 @@
+require 'strscan'
+
+module MetaParse
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  ### Begin Interface
+
+  def parse_with_method(method_name, string)    
+    self.send(method_name, string.meta(self), self)
+  end
+
+  module ClassMethods    
+    # Defined a method which takes a scanner.
+    # The block passed should return a Matcher or Matcher spec, which is compiled to a Matcher if necessary.
+    # The result of calling the defined method is the same as calling match? on the resulting Matcher.
+    def match_method(name, &block)
+      match_spec = yield
+      matcher = MetaParse::Matcher.compile(match_spec)
+      
+      define_matcher_method(name, matcher)
+    end
+    
+    def define_matcher_method(name, matcher)
+      self.send(:define_method, name) do |scanner, context=nil|
+        matcher.match scanner, context
+      end
+    end
+        
+    def rep(*args, &block)
+      Matcher.compile([:*, *args])
+    end
+    
+    # Return a sequential matcher.  If block is supplied, it defines a function which will be passed an array
+    # of all matched values and which should return a non-nil result for the match as a whole.
+    def seq(*args, &block)
+      if block_given?
+        wrapped = lambda { |scanner, context|
+          result = block.call context.matches
+          context.matches = []
+          result
+        }
+        args << wrapped
+      end
+      Matcher.compile([:and, *args])
+    end
+    
+    def alt(*args)
+      Matcher.compile([:or, *args])
+    end
+    
+    def comp(spec)
+      Matcher.compile(spec)
+    end
+    
+  end
+  ### End Interface
+
+  class MetaScanner < StringScanner
+    attr_accessor :parser
+
+    def initialize(string, parser=nil)
+      super string
+      @parser = parser
+    end
+
+    # This is a special case and could actually be handled by match_string if necessary.
+    def match_char(char)
+      c = peek(1)
+      if c == char
+        self.pos += 1
+        c
+      end
+    end
+
+    def match_string(str, position2=0)
+      if (string.equal_at(pos, str, position2))
+        self.pos += str.length
+        str
+      end
+    end
+
+    def scan(spec)
+      case spec
+      when Regexp
+        result = super spec
+        matched
+      when String
+        if spec.length > 0
+          match_string(spec)
+        else
+          match_char(spec)
+        end
+      end
+    end
+  end
+
+  class Matcher
+    attr_accessor :spec
+
+    def self.compile(spec)
+      case spec
+      when Matcher
+        spec
+      when String, Regexp
+        Matcher.new spec
+      when Array
+        case spec[0]
+        when :or
+            compiled_body = spec[1..-1].map { |x| self.compile x }
+          AlternativeMatcher.new(compiled_body)
+        when :and
+            compiled_body = spec[1..-1].map { |x| self.compile x }
+          SequentialMatcher.new(compiled_body)
+        when :*, :+, :'?'
+          compiled_body = self.compile(spec[1])
+          case spec[0]
+          when :'?'
+            min = 0
+            max = 1
+          when :+
+            min = 1
+          end
+          RepetitionMatcher.new(compiled_body, min, max, *spec[4..-1])
+        end
+      when Proc, Symbol
+        FunctionMatcher.new spec
+      end
+    end
+
+    def initialize(data)
+      @spec = data
+    end
+
+    def show
+        spec.inspect
+    end
+
+    def inspect
+      "<match #{show}>"
+    end
+
+    def match?(scanner, context=nil)
+      case scanner
+      when MetaScanner
+        result = scanner.scan spec
+        result
+      else
+        raise "match? requires scanner"
+        # FIXME: Why doesn't the coercion below work?
+      # when String
+      #   match?(MetaParse::MetaScanner.new(scanner), context)
+      #   (MetaScanner.new(scanner)).scan spec
+      end
+    end
+
+    def match(scanner, context=nil)
+      (stateful ? clone : self).match? scanner, context
+    end
+
+    def stateful
+      false
+    end
+
+    def m?(string)
+      match? MetaScanner.new(string)
+    end
+
+    def m(string)
+      match MetaScanner.new(string)
+    end
+
+  end
+
+  class RepetitionMatcher < Matcher
+    attr_accessor :min, :max, :reducer
+    
+    def initialize(sub_match, min=0, max=nil, reducer=nil, initial_value=[])
+      @spec, @min, @max, @reducer, @initial_value = sub_match, min, max, reducer, initial_value
+    end
+
+    def stateful
+      true
+    end
+
+    def match?(scanner, context=nil)
+      matches = []
+      while (!max || (matches.count < max)) && (match = spec.match(scanner))
+        matches << match
+      end
+      
+      unless min && (matches.count < min)
+        case finalizer
+        when Proc
+          finalizer.call(matches, *finalizer_args)
+        when Symbol
+          send(finalizer, matches, *finalizer_args)
+        when nil 
+          matches
+        end
+      end
+    end
+    
+    def match?(scanner, context=nil)
+      # Need to copy the initial value since it is potentially destructively modified (if an array, for example).
+      acc = begin @initial_value.dup
+            rescue TypeError
+              @initial_value
+            end
+      match_count = 0
+
+      while (!max || (match_count < max)) && (one_match = spec.match(scanner))
+        match_count += 1
+        if reducer
+          acc = reducer.call(acc, one_match)
+        else
+          acc << one_match
+        end
+      end
+      unless min && (match_count < min)
+        acc
+      end
+    end
+
+    def show
+      "[#{min}, #{max}] #{ spec.show }"
+    end
+  end
+
+  class AlternativeMatcher < Matcher
+    def match?(scanner, context=nil)
+      spec.each do |alternative|
+        result = alternative.match(scanner)
+        return result if result
+      end
+      return nil
+    end
+ 
+    def show
+      "first of: (#{ (spec.map &:show).join ', ' })"
+    end
+  end
+
+  class SequentialMatcher < Matcher
+    attr_accessor :matches
+    
+    def stateful
+      true
+    end
+
+    def match?(scanner, context = nil)
+      @matches = []
+      initial_position = scanner.pos
+      last_match = nil
+
+      spec.each do |element|
+        last_match = element.match(scanner, self)
+        unless last_match
+          scanner.pos = initial_position
+          return nil
+        end
+        @matches << last_match
+      end
+      return last_match
+    end
+
+    def pop
+      @matches.pop
+    end
+
+    def push(value)
+      @matches.push(value)
+    end
+
+    def clear
+      @matches = []
+    end
+
+    def show
+      "sequentially: (#{ (spec.map &:show).join ', ' })"
+    end
+  end  
+
+  # Arbitrary predicate, particularly useful for generating final return value from SequentialMatchers.
+  # Context is the containing matcher, and in the case of SequentialMatcher includes access to accumulated matches.
+  class FunctionMatcher < Matcher
+    include MetaParse
+
+    def match?(scanner, context=nil)
+      case spec
+      when Proc
+        spec.call(scanner, context)
+      when Symbol
+        scanner.parser.send spec, scanner, context
+      end
+    end
+  end
+
+  def all_matches(scanner, context)
+    matches_so_far = context.matches
+    context.matches = []
+    matches_so_far
+  end
+
+  def all_matches_joined(scanner, context)
+    all_matches(scanner,context).join
+  end
+
+  def join_strings(array, *args)
+    array.join(*args)
+  end
+
+  def collapse(&block)
+    lambda { |scanner, context|
+      stack = context.matches
+      result = block.call(stack)
+      context.clear
+      result
+    }
+  end
+end
+
+class String
+  def equal_at(position, string, position2=0)
+    for i in position2..(position2 + string.length - 1) do
+      return nil unless self[position] == string[i] 
+      position += 1
+    end
+    return true
+  end
+
+  def meta(parser=nil)
+    MetaParse::MetaScanner.new(self, parser)
+  end
+end

data/lib/util.rb

@@ -0,0 +1,112 @@
+# require 'util'
+
+module Util
+  def mgsub(string, substitution_hash)
+    Util::mgsub(string, substitution_hash)
+  end
+
+  # We can't use a closure (for now) because JRuby (as of 1.7.14) doesn't handle return correctly in lambdas.
+  # It returns from the containing function. Here we depend on an early return from the actual function only.
+  def self.make_substitution_function(regexp_hash)
+    ->(matched_string) {
+      result = nil # Poor man's early return because of JRuby bug.
+      
+      regexp_hash.each do |regexp, substitution|
+        if !result && matched_string.match(regexp)
+          match_data = Regexp.last_match
+          result = case substitution
+                   when String
+                     substitution
+                   else
+                     substitution.call(match_data)
+                   end
+        end
+      end
+
+      result
+    }
+  end
+
+  # mgsub == multiple, global substitution.
+  def self.mgsub(string, substitution_hash)
+    all_regexps = []
+    regexp_hash = {}
+
+    substitution_hash.each do |key, substitution|
+      regexp = to_regexp(key)
+      all_regexps << regexp 
+      regexp_hash[regexp] = substitution
+    end
+
+    # puts "all_regexps: #{all_regexps.inspect}"
+    combined_regexp = Regexp.union(*all_regexps)
+    
+    substitution_function = make_substitution_function(regexp_hash)
+
+    string.gsub(combined_regexp, &substitution_function)
+  end
+
+  def self.to_regexp(spec)
+    case spec
+    when Regexp
+      spec
+    when String
+      Regexp.escape(spec)
+    end
+  end
+end
+
+module Util
+  class Maybe < BasicObject
+    def initialize(object, default = nil)
+      @object = object
+      @default = default
+      @block = block
+    end
+
+
+    def send(method, *args, &block)
+      if @object.respond_to?(method)
+        @object.send(method, *args, &block) 
+      else
+        @default
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      send(method, *args, &block)
+    end
+  end
+end
+
+class Object
+  def self
+    self
+  end
+
+  def maybe(default = nil)
+    Util::Maybe.new(self, default)
+  end
+    
+  def perhaps(default = self)
+    maybe(default)
+  end
+
+class String < Object
+  def mgsub(substitution_hash)
+    Util::mgsub(self, substitution_hash)
+  end
+end
+  
+=begin
+
+Perhaps is intended especially for type coercions, like:
+
+def whatever(input)
+  input = input.perhaps.to_path
+  input = input.to_s
+end
+
+=end
+
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: meta_parse
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Chhi'mèd Künzang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Functional recursive descent parsing.
+email: clkunzang@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/meta_parse.rb
+- lib/util.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.2
+signing_key: 
+specification_version: 4
+summary: Parse by recursive descent.
+test_files: []