sexp_grammar 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# 0.0.1 / FIX ME
+
+* Enhancements
+
+  * Birthday!

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem "epath", "~> 0.0.1"
+  gem "rake", "~> 0.9.2"
+  gem "rspec", "~> 2.8.0"
+  gem "wlang", "~> 0.10.2"
+end

data/Gemfile.lock

@@ -0,0 +1,25 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    epath (0.0.1)
+    rake (0.9.2.2)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    wlang (0.10.2)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  epath (~> 0.0.1)
+  rake (~> 0.9.2)
+  rspec (~> 2.8.0)
+  wlang (~> 0.10.2)

data/LICENCE.md

@@ -0,0 +1,22 @@
+# The MIT Licence
+
+    Copyright (c) 2012 - Bernard Lambeau
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,15 @@
+sexp_grammar.gemspec
+sexp_grammar.noespec
+.gemtest
+CHANGELOG.md
+Gemfile
+Gemfile.lock
+bin/**/*
+lib/**/*
+LICENCE.md
+Manifest.txt
+Rakefile
+README.md
+spec/**/*
+tasks/**/*
+test/**/*

data/README.md

@@ -0,0 +1,46 @@
+# SexpGrammar
+
+A helper to manipulate sexp grammars.
+
+## Example
+
+    grammar = SexpGrammar.load(<<-YAML)
+
+      # alternative rule
+      bool_expr:
+        - bool_and
+        - bool_or
+        - bool_not
+        - var_ref
+        - literal
+
+      # non-terminal
+      bool_and:
+        - [ bool_expr, bool_expr ]
+      bool_or:
+        - [ bool_expr, bool_expr ]
+      bool_not:
+        - [ bool_expr ]
+      literal:
+        - [ truth_value ]
+      var_ref:
+        - [ var_name ]
+
+      # terminals
+      var_name:
+        !ruby/regexp /^[a-z]+$/
+      truth_value:
+        - true
+        - false
+
+    YAML
+
+    grammar === [:bool_and, [:bool_not, [:var_ref, "x"]], [:literal, true]]
+    # => true
+
+    grammar === [:bool_and, [:literal, "true"]]
+    # => false (second term is missing)
+
+## Links
+
+https://github.com/blambeau/sexp_grammar

data/Rakefile

@@ -0,0 +1,23 @@
+begin
+  gem "bundler", "~> 1.0"
+  require "bundler/setup"
+rescue LoadError => ex
+  puts ex.message
+  abort "Bundler failed to load, (did you run 'gem install bundler' ?)"
+end
+
+# Dynamically load the gem spec
+$gemspec_file = File.expand_path('../sexp_grammar.gemspec', __FILE__)
+$gemspec      = Kernel.eval(File.read($gemspec_file))
+
+# We run tests by default
+task :default => :test
+
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end

data/lib/sexp_grammar.rb

@@ -0,0 +1,31 @@
+require_relative "sexp_grammar/version"
+require_relative "sexp_grammar/loader"
+#
+# A helper to manipulate sexp grammars
+#
+module SexpGrammar
+
+  def self.load(input)
+    case input
+    when lambda{|x| x.respond_to?(:to_path)}
+      require 'yaml'
+      load(YAML.load_file input.to_path)
+    when String
+      require 'yaml'
+      load(YAML.load input)
+    when Hash
+      Grammar.new(input)
+    else
+      raise ArgumentError, "Invalid argument for SexpGrammar::Grammar: #{input}"
+    end
+  end
+
+end # module SexpGrammar
+require_relative "sexp_grammar/grammar"
+require_relative "sexp_grammar/element"
+require_relative "sexp_grammar/alternative"
+require_relative "sexp_grammar/many"
+require_relative "sexp_grammar/reference"
+require_relative "sexp_grammar/rule"
+require_relative "sexp_grammar/sequence"
+require_relative "sexp_grammar/terminal"

data/lib/sexp_grammar/alternative.rb

@@ -0,0 +1,28 @@
+module SexpGrammar
+  class Alternative
+    include Element
+
+    attr_reader :terms
+
+    def initialize(terms)
+      @terms = terms
+    end
+
+    def match?(sexp)
+      terms.any?{|t| t.match?(sexp)}
+    end
+
+    def eat(sexp)
+      @terms.each do |alt|
+        res = alt.eat(sexp)
+        return res if res
+      end
+      nil
+    end
+
+    def inspect
+      "(alt #{terms.inspect})"
+    end
+
+  end # class Alternative
+end # module SexpGrammar

data/lib/sexp_grammar/element.rb

@@ -0,0 +1,9 @@
+module SexpGrammar
+  module Element
+
+    def ===(sexp)
+      match?(sexp)
+    end
+
+  end # module SexpGrammar
+end # module SexpGrammar

data/lib/sexp_grammar/grammar.rb

@@ -0,0 +1,57 @@
+module SexpGrammar
+  class Grammar
+
+    attr_reader :rules
+
+    def initialize(rules = {}, root = rules.keys.first)
+      @rules = compile_rules(rules)
+      @root  = root && self[root.to_sym]
+    end
+
+    def [](rule_name)
+      @rules[rule_name]
+    end
+
+    def match?(sexp)
+      @root.match?(sexp)
+    end
+    alias :=== :match?
+
+    private
+
+    def compile_rules(rules)
+      Hash[rules.map{|k,v|
+        [k.to_sym, compile_rule(k.to_sym, v)]
+      }]
+    end
+
+    def compile_rule(name, defn)
+      case rule = compile_rule_defn(defn)
+      when Terminal, Alternative
+        rule
+      else
+        Rule.new(name, rule)
+      end
+    end
+
+    def compile_rule_defn(arg)
+      case arg
+      when Element
+        arg
+      when Regexp, TrueClass, FalseClass, NilClass
+        Terminal.new arg
+      when lambda{|x| x.is_a?(Array) && x.size == 1 && x.first.is_a?(Array)}
+        Sequence.new arg.first.map{|s| compile_rule_defn(s) }
+      when Array
+        Alternative.new arg.map{|s| compile_rule_defn(s)}
+      when /([\?\+\*])$/
+        Many.new compile_rule_defn($`), $1
+      when /^[a-z][a-z_]+$/
+        Reference.new arg.to_sym, self
+      else
+        raise ArgumentError, "Invalid rule definition: #{arg.inspect}", caller
+      end
+    end
+
+  end # class Grammar
+end # module SexpGrammar

data/lib/sexp_grammar/loader.rb

@@ -0,0 +1 @@
+

data/lib/sexp_grammar/many.rb

@@ -0,0 +1,52 @@
+module SexpGrammar
+  class Many
+    include Element
+
+    attr_reader :term, :min, :max
+
+    def initialize(term, min, max = nil)
+      @term       = term
+      @min, @max  = minmax(min, max)
+    end
+
+    def match?(sexp)
+      return nil unless sexp.is_a?(Array)
+      eat = eat(sexp)
+      eat && eat.empty?
+    end
+
+    def eat(sexp)
+      i, last = 0, sexp
+      while sexp && (@max.nil? || i < @max)
+        if res = @term.eat(sexp)
+          last = res
+          i += 1
+        end
+        sexp = res
+      end
+      i >= @min ? last : nil
+    end
+
+    def inspect
+      "(many #{term.inspect}, #{min}, #{max})"
+    end
+
+    private
+
+    def minmax(min, max)
+      case min
+      when Integer
+        [min, max]
+      when '?'
+        [0, 1]
+      when '+'
+        [1, nil]
+      when '*'
+        [0, nil]
+      else
+        raise ArgumentError, "Invalid multiplicity: #{min}"
+      end
+    end
+
+  end # class Sequence
+end # module SexpGrammar

data/lib/sexp_grammar/reference.rb

@@ -0,0 +1,30 @@
+module SexpGrammar
+  class Reference
+    include Element
+
+    attr_reader :rule_name
+    attr_reader :grammar
+
+    def initialize(rule_name, grammar)
+      @rule_name = rule_name
+      @grammar   = grammar
+    end
+
+    def rule
+      @rule ||= @grammar[@rule_name]
+    end
+
+    def match?(sexp)
+      rule && rule.match?(sexp)
+    end
+
+    def eat(sexp)
+      rule && rule.eat(sexp)
+    end
+
+    def inspect
+      "(ref #{rule_name}, #{rule.inspect})"
+    end
+
+  end # class Reference
+end # module SexpGrammar

data/lib/sexp_grammar/rule.rb

@@ -0,0 +1,29 @@
+module SexpGrammar
+  class Rule
+    include Element
+
+    attr_reader :name
+    attr_reader :defn
+
+    def initialize(name, defn)
+      @name = name
+      @defn = defn
+    end
+
+    def match?(sexp)
+      return nil unless sexp.is_a?(Array)
+      return false unless sexp.first && (sexp.first == name)
+      defn.match?(sexp[1..-1])
+    end
+
+    def eat(sexp)
+      return nil unless match?(sexp.first)
+      sexp[1..-1]
+    end
+
+    def inspect
+      "(rule #{name}, #{defn.inspect})"
+    end
+
+  end # class Rule
+end # module SexpGrammar

data/lib/sexp_grammar/sequence.rb

@@ -0,0 +1,28 @@
+module SexpGrammar
+  class Sequence
+    include Element
+
+    attr_reader :terms
+
+    def initialize(terms)
+      @terms = terms
+    end
+
+    def match?(sexp)
+      return nil unless sexp.is_a?(Array)
+      eat = eat(sexp)
+      eat && eat.empty?
+    end
+
+    def eat(sexp)
+      @terms.inject sexp do |rest,rule|
+        rest && rule.eat(rest)
+      end
+    end
+
+    def inspect
+      "(seq #{terms.inspect})"
+    end
+
+  end # class Sequence
+end # module SexpGrammar

data/lib/sexp_grammar/terminal.rb

@@ -0,0 +1,35 @@
+module SexpGrammar
+  class Terminal
+    include Element
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def inspect
+      "(terminal #{value.inspect})"
+    end
+
+    def match?(sexp)
+      terminal_match?(sexp)
+    end
+
+    def eat(sexp)
+      match?(sexp.first) ? sexp[1..-1] : nil
+    end
+
+    private
+
+    def terminal_match?(term)
+      case @value
+      when Regexp
+        @value === term rescue false
+      when TrueClass, FalseClass, NilClass
+        @value == term
+      end
+    end
+
+  end # class Terminal
+end # module SexpGrammar