sexpr 0.2.0 → 0.3.0

data/lib/sexpr/grammar/matching.rb

@@ -0,0 +1,56 @@
+module Sexpr
+  module Grammar
+    module Matching
+
+      def root_rule
+        rules[root]
+      end
+
+      def [](rule_name)
+        rules[rule_name]
+      end
+
+      def match?(sexp)
+        root_rule.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 Matcher::Terminal, Matcher::Alternative
+          rule
+        else
+          Matcher::Rule.new(name, rule)
+        end
+      end
+
+      def compile_rule_defn(arg, grammar = self)
+        case arg
+        when Matcher
+          arg
+        when Regexp, TrueClass, FalseClass, NilClass
+          Matcher::Terminal.new arg
+        when lambda{|x| x.is_a?(Array) && x.size == 1 && x.first.is_a?(Array)}
+          Matcher::Sequence.new arg.first.map{|s| compile_rule_defn(s) }
+        when Array
+          Matcher::Alternative.new arg.map{|s| compile_rule_defn(s)}
+        when /([\?\+\*])$/
+          Matcher::Many.new compile_rule_defn($`), $1
+        when /^[a-z][a-z_]+$/
+          Matcher::Reference.new arg.to_sym, grammar
+        else
+          raise ArgumentError, "Invalid rule definition: #{arg.inspect}", caller
+        end
+      end
+
+    end # module Matching
+  end # module Grammar
+end # module Sexpr

data/lib/sexpr/grammar/options.rb

@@ -0,0 +1,53 @@
+module Sexpr
+  module Grammar
+    module Options
+
+      attr_reader :options
+      attr_reader :path
+      attr_reader :rules
+      attr_reader :root
+      attr_reader :parser
+
+      def install_options(options)
+        @options = options
+        install_path
+        install_rules
+        install_root
+        install_parser
+        yield self if block_given?
+      end
+
+      def option(key)
+        @options[key.to_sym] || @options[key.to_s]
+      end
+
+      def install_path
+        @path = option(:path)
+      end
+
+      def install_rules
+        @rules = option(:rules) || {}
+        @rules = compile_rules(@rules)
+      end
+
+      def install_root
+        @root = option(:root)
+        @root = rules.keys.first unless @root
+        @root = root.to_sym if @root
+      end
+
+      def install_parser
+        @parser = option(:parser)
+        if @parser.is_a?(String) && !File.exists?(@parser)
+          @parser = File.join(File.dirname(path), @parser)
+        end
+        @parser = Parser.factor(@parser) if @parser
+      end
+
+      def compile_rules(rules)
+        @rules = rules
+      end
+
+    end # module Options
+  end # module Grammar
+end # module Sexpr

data/lib/sexpr/grammar/parsing.rb

@@ -0,0 +1,20 @@
+module Sexpr
+  module Grammar
+    module Parsing
+
+      def parse(input, options = {})
+        parser!.parse(input, options)
+      end
+
+      private
+
+      def parser!
+        unless p = parser
+          raise NoParserError, "No parser set.", caller
+        end
+        p
+      end
+
+    end # module Parsing
+  end # module Grammar
+end # module Sexpr

data/lib/sexpr/grammar/tagging.rb

@@ -0,0 +1,49 @@
+module Sexpr
+  module Grammar
+    module Tagging
+
+      def rule2modname(rule)
+        rule.to_s.gsub(/(^|_)([a-z])/){|x| $2.capitalize}.to_sym
+      end
+
+      def mod2rulename(mod)
+        mod = mod.name.to_s.split('::').last.to_sym if mod.is_a?(Module)
+        mod.to_s.gsub(/[A-Z]/){|x| "_#{x.downcase}"}[1..-1].to_sym
+      end
+
+      def sexpr(input, options = {})
+        case input
+        when Array
+          tag_sexpr input
+        else
+          tag_sexpr parser!.sexpr(input, options)
+        end
+      end
+
+      private
+
+      def tag_sexpr(sexpr, reference = self)
+        if looks_a_sexpr?(sexpr)
+          sexpr = tag_sexpr_with_user_module(sexpr, reference)
+          sexpr[1..-1].each do |child|
+            tag_sexpr(child, reference)
+          end
+        end
+        sexpr
+      end
+
+      def tag_sexpr_with_user_module(sexpr, reference)
+        sexpr.extend(Sexpr)
+        rulename = sexpr.first
+        modname  = rule2modname(rulename)
+        mod      = reference.const_get(modname) rescue nil
+        mod ? sexpr.extend(mod) : sexpr
+      end
+
+      def looks_a_sexpr?(arg)
+        arg.is_a?(Array) and arg.first.is_a?(Symbol)
+      end
+
+    end # module Tagging
+  end # module Grammar
+end # module Sexpr

data/lib/sexpr/loader.rb

@@ -1 +0,0 @@
-

data/lib/sexpr/matcher.rb

@@ -0,0 +1,15 @@
+module Sexpr
+  module Matcher
+
+    def ===(sexp)
+      match?(sexp)
+    end
+
+  end # module Matcher
+end # module Sexpr
+require_relative "matcher/alternative"
+require_relative "matcher/many"
+require_relative "matcher/reference"
+require_relative "matcher/rule"
+require_relative "matcher/sequence"
+require_relative "matcher/terminal"

data/lib/sexpr/matcher/alternative.rb

@@ -0,0 +1,30 @@
+module Sexpr
+  module Matcher
+    class Alternative
+      include Matcher
+
+      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 Matcher
+end # module Sexpr

data/lib/sexpr/matcher/many.rb

@@ -0,0 +1,54 @@
+module Sexpr
+  module Matcher
+    class Many
+      include Matcher
+
+      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 Matcher
+end # module Sexpr

data/lib/sexpr/matcher/reference.rb

@@ -0,0 +1,32 @@
+module Sexpr
+  module Matcher
+    class Reference
+      include Matcher
+
+      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 Matcher
+end # module Sexpr

data/lib/sexpr/matcher/rule.rb

@@ -0,0 +1,31 @@
+module Sexpr
+  module Matcher
+    class Rule
+      include Matcher
+
+      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 Matcher
+end # module Sexpr

data/lib/sexpr/matcher/sequence.rb

@@ -0,0 +1,30 @@
+module Sexpr
+  module Matcher
+    class Sequence
+      include Matcher
+
+      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 Matcher
+end # module Sexpr

data/lib/sexpr/matcher/terminal.rb

@@ -0,0 +1,37 @@
+module Sexpr
+  module Matcher
+    class Terminal
+      include Matcher
+
+      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 Matcher
+end # module Sexpr

data/lib/sexpr/node.rb

@@ -0,0 +1,16 @@
+module Sexpr
+  module Node
+
+    def sexpr_type
+      first
+    end
+    alias :sexp_type :sexpr_type
+
+    def sexpr_body
+      self[1..-1]
+    end
+    alias :sexp_body :sexpr_body
+
+  end # module Node
+  include Node
+end # module Sexpr

data/lib/sexpr/parser.rb

@@ -0,0 +1,48 @@
+module Sexpr
+  module Parser
+
+    class << self
+
+      def registered_parser_classes
+        @registered_parser_classes ||= []
+      end
+
+      def register(parser_class)
+        registered_parser_classes << parser_class
+      end
+
+      def find_parser_class(external_parser)
+        registered_parser_classes.find{|cl|
+          cl.recognizes?(external_parser)
+        }
+      end
+
+      def factor(external_parser, options = {})
+        return external_parser if Parser===external_parser
+        if cl = find_parser_class(external_parser)
+          cl.new(external_parser, options)
+        else
+          raise UnrecognizedParserError, "Parser not recognized: #{external_parser}"
+        end
+      end
+
+    end # class methods
+
+    private
+
+    def input_text(input)
+      case input
+      when lambda{|x| x.respond_to?(:to_path)}
+        input_text File.read(input.to_path)
+      when IO
+        input_text input.read
+      when String
+        input
+      else
+        raise InvalidParseSourceError, "Invalid parse source: #{input}"
+      end
+    end
+
+  end # module Parser
+end # module Sexpr
+require_relative "parser/citrus"