sexpr 0.3.0 → 0.4.0

data/lib/sexpr/parser.rb

@@ -17,10 +17,10 @@ module Sexpr
         }
       end
 
-      def factor(external_parser, options = {})
+      def factor(external_parser)
         return external_parser if Parser===external_parser
         if cl = find_parser_class(external_parser)
-          cl.new(external_parser, options)
+          cl.new(external_parser)
         else
           raise UnrecognizedParserError, "Parser not recognized: #{external_parser}"
         end

data/lib/sexpr/parser/citrus.rb

@@ -21,15 +21,9 @@ module Sexpr
 
       end # class << self
 
-      attr_reader :options
-
-      def initialize(parser, options = {})
-        @parser  = parser
-        @options = default_options.merge(options)
-      end
-
-      def default_options
-        {:from_match_to_sexpr => lambda{|match| match.value}}
+      def initialize(parser)
+        require_relative 'ext'
+        @parser = parser
       end
 
       def parser
@@ -47,18 +41,13 @@ module Sexpr
       end
 
       def parse(input, options = {})
+        return input if input.is_a?(::Citrus::Match)
         input = input_text(input)
         parser.parse(input, options)
       end
 
-      def sexpr(input, parse_options = {})
-        from_match_to_sexpr parse(input, parse_options)
-      end
-
-      private
-
-      def from_match_to_sexpr(match)
-        options[:from_match_to_sexpr].call(match)
+      def to_sexpr(parsed)
+         parsed.sexpr
       end
 
       Sexpr::Parser.register self

data/lib/sexpr/parser/ext.rb

@@ -0,0 +1,9 @@
+module Citrus
+  class Match
+
+    def sexpr
+      Sexpr.sexpr(value, {:citrus_match => self})
+    end
+
+  end
+end

data/lib/sexpr/processor.rb

@@ -0,0 +1,61 @@
+require_relative 'processor/helper'
+require_relative 'processor/null_helper'
+require_relative 'processor/sexpr_coercions'
+module Sexpr
+  class Processor
+
+    ### class methods
+
+    def self.helpers
+      @helpers ||= superclass.helpers.dup rescue [ ]
+    end
+
+    def self.helper(helper_class)
+      methods = helper_class.const_get(:Methods) rescue nil
+      module_eval{ include methods } if methods
+      helpers << helper_class
+    end
+
+    def self.build_helper_chain(helpers = self.helpers)
+      return NullHelper.new if helpers.empty?
+      helpers[0...-1].reverse.inject(helpers.last.new) do |chain, h_class|
+        prepended = h_class.new
+        prepended.next_in_chain = chain
+        prepended
+      end
+    end
+
+    ### instance methods
+
+    attr_reader :main_processor
+
+    def initialize(options = {})
+      @main_processor = options.delete(:main_processor) || self
+    end
+
+    def call(sexpr)
+      help(sexpr) do |n|
+        meth = :"on_#{n.first}"
+        meth = :"on_missing" unless respond_to?(meth)
+        send(meth, n)
+      end
+    end
+
+    def on_missing(sexpr)
+      raise UnexpectedSexprError, "Unexpected sexpr: #{sexpr.inspect}"
+    end
+
+    private
+
+    def helper_chain
+      @helper_chain ||= self.class.build_helper_chain
+    end
+
+    def help(sexpr)
+      helper_chain.call(self, sexpr) do |_,n|
+        yield(n)
+      end
+    end
+
+  end # class Processor
+end # module Sexpr

data/lib/sexpr/processor/helper.rb

@@ -0,0 +1,31 @@
+module Sexpr
+  class Processor
+    class Helper
+
+      attr_accessor :next_in_chain
+
+      def call(processor, sexpr, &bl)
+        meth = :"on_#{sexpr.first}"
+        meth = :"on_missing" unless respond_to?(meth)
+        send(meth, processor, sexpr) do |r,n|
+          next_call(r, n, bl)
+        end
+      end
+
+      def on_missing(processor, sexpr)
+        yield(processor, sexpr)
+      end
+
+      private
+
+      def next_call(processor, sexpr, toplevel)
+        if nic = next_in_chain
+          nic.call(processor, sexpr, &toplevel)
+        else
+          toplevel.call(processor, sexpr)
+        end
+      end
+
+    end # class Helper
+  end # module Processor
+end # module Sexpr

data/lib/sexpr/processor/null_helper.rb

@@ -0,0 +1,11 @@
+module Sexpr
+  class Processor
+    class NullHelper
+
+      def call(processor, sexpr, &bl)
+        bl.call(processor, sexpr)
+      end
+
+    end # class NullHelper
+  end # class Processor
+end # module Sexpr

data/lib/sexpr/processor/sexpr_coercions.rb

@@ -0,0 +1,44 @@
+module Sexpr
+  class Processor
+    class SexprCoercions < Helper
+
+      module Methods
+
+        def parse(*args)
+          sexpr_grammar.parse(*args)
+        end
+
+        def sexpr(*args)
+          sexpr_grammar.sexpr(*args)
+        end
+
+      end
+
+      def call(processor, sexpr, &bl)
+        # input coercion
+        sexpr = grammar(processor).sexpr(sexpr)
+
+        # recursive call
+        sexpr = next_call(processor, sexpr, bl)
+
+        # output coercion
+        if sexpr.is_a?(Array) and sexpr.first.is_a?(Symbol)
+          grammar(processor).sexpr(sexpr)
+        else
+          sexpr
+        end
+      end
+
+      private
+
+      def grammar(processor)
+        if processor.respond_to?(:sexpr_grammar)
+          processor.sexpr_grammar
+        else
+          Sexpr
+        end
+      end
+
+    end # class SexprCoercions
+  end  # class Processor
+end # module Sexpr

data/lib/sexpr/rewriter.rb

@@ -0,0 +1,20 @@
+module Sexpr
+  class Rewriter < Processor
+    helper SexprCoercions
+
+    def self.grammar(sexpr_grammar)
+      @sexpr_grammar = sexpr_grammar
+    end
+
+    def sexpr_grammar
+      (self.class.instance_variable_get(:"@sexpr_grammar") || super) rescue Sexpr
+    end
+
+    def copy_and_apply(sexpr)
+      sexpr.sexpr_copy do |copy, child|
+        copy << (Sexpr===child ? call(child) : child)
+      end
+    end
+
+  end # class Rewriter
+end # module Sexpr

data/lib/sexpr/version.rb

@@ -2,7 +2,7 @@ module Sexpr
   module Version
 
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     TINY  = 0
 
     def self.to_s

data/sexpr.noespec

@@ -9,7 +9,7 @@ variables:
   upper:
     Sexpr
   version:
-    0.3.0
+    0.4.0
   summary: |-
     A compilation framework around s-expressions
   description: |-

data/spec/grammar/test_parse.rb

@@ -3,7 +3,11 @@ module Sexpr
   describe Grammar, "parse" do
 
     def grammar
-      Sexpr.load(:parser => parser)
+      Sexpr.load(:parser => parser).extend Module.new{
+        def default_parse_options
+          {:root => :root_rule, :hello => "world"}
+        end
+      }
     end
 
     context 'when no parser is set' do
@@ -22,17 +26,17 @@ module Sexpr
         Object.new.extend Module.new{
           include Parser
           def parse(s, options = {})
-            [options[:root] || :parsed, input_text(s)]
+            [options[:root], "#{s} #{options[:hello]}"]
           end
         }
       }
 
-      it 'delegates the call to the parser' do
-        grammar.parse("Hello world").should eq([:parsed, "Hello world"])
+      it 'uses default options when no options are passed' do
+        grammar.parse("Hello").should eq([:root_rule, "Hello world"])
       end
 
-      it 'passes options' do
-        grammar.parse("world", :root => :hello).should eq([:hello, "world"])
+      it 'merge passed options with default ones' do
+        grammar.parse("Hello", :root => :another_rule).should eq([:another_rule, "Hello world"])
       end
 
     end # when a parser is set

data/spec/grammar/test_sexpr.rb

@@ -2,21 +2,47 @@ require 'spec_helper'
 module Sexpr
   describe Grammar, "sexpr" do
 
-    def sexpr(expr, opts = {})
-      @sexpr = Sexpr.load(:parser => parser).sexpr(expr, opts)
+    def sexpr(expr, markers = nil)
+      @sexpr = Sexpr.load(:parser => parser).sexpr(expr, markers)
     end
 
     after{
       @sexpr.should be_a(Sexpr) if @sexpr
     }
 
-    context 'when no parser is set' do
+    context 'on an array' do
       let(:parser){ nil }
 
-      it 'silently returns a sexpr array' do
+      it 'returns the sexpr array' do
         sexpr([:sexpr, "world"]).should eq([:sexpr, "world"])
       end
 
+      it 'extends it with the Sexpr module' do
+        sexpr([:sexpr, "world"]).should be_a(Sexpr)
+      end
+
+      it 'sets the markers if any' do
+        markers = {:hello => "world"}
+        sexpr([:sexpr, "world"], markers).tracking_markers.should eq(markers)
+      end
+
+    end # on an array
+
+    context 'on a Sexpr' do
+      let(:parser){ nil }
+
+      it 'merges the markers if provided' do
+        sexpr = sexpr([:sexpr, "world"], :hello => true, :who => "world")
+        sexpr.tracking_markers.should eq(:hello => true, :who => "world")
+        sexpr = sexpr(sexpr, :who => "WORLD")
+        sexpr.tracking_markers.should eq(:hello => true, :who => "WORLD")
+      end
+
+    end
+
+    context 'when no parser is set and a String' do
+      let(:parser){ nil }
+
       it 'raises an error when parser is needed' do
         lambda{
           sexpr("Hello world")
@@ -25,26 +51,34 @@ module Sexpr
 
     end
 
-    context 'when a parser is set' do
+    context 'when a parser is set and a String' do
       let(:parser){
         Object.new.extend Module.new{
           include Parser
-          def sexpr(s, options = {})
-            [options[:root] || :parsed, s]
+          def parse(s, options)
+            s.upcase
+          end
+          def to_sexpr(s)
+            Sexpr.sexpr([:parsed, s], {:hello => "world"})
           end
         }
       }
 
-      it 'silently returns a sexpr array' do
-        sexpr([:sexpr, "world"]).should eq([:sexpr, "world"])
+      it 'delegates the call to the parser' do
+        sexpr("Hello world").should eq([:parsed, "HELLO WORLD"])
       end
 
-      it 'delegates the call to the parser' do
-        sexpr("Hello world").should eq([:parsed, "Hello world"])
+      it 'extends it with the Sexpr module' do
+        sexpr("Hello world").should be_a(Sexpr)
+      end
+
+      it 'sets the markers through recursive application' do
+        sexpr("Hello world").tracking_markers.should eq({:hello => "world"})
       end
 
-      it 'passes options' do
-        sexpr("world", :root => :hello).should eq([:hello, "world"])
+      it 'merge the provided markers' do
+        expected = {:hello => "world", :who => "world"}
+        sexpr("Hello world", {:who => "world"}).tracking_markers.should eq(expected)
       end
 
     end # when a parser is set

data/spec/node/test_sexpr_copy.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Sexpr
+  describe Node, "sexpr_copy" do
+
+    let(:markers){
+      {:hello => 'world'}
+    }
+    let(:array){
+      [:bool_not, [:bool_lit, true]]
+    }
+    let(:the_sexpr){
+      sexpr(array, markers)
+    }
+
+    it 'degenerates to a tag preserving dup without a block' do
+      [the_sexpr.sexpr_copy, the_sexpr.dup].each do |copy|
+        copy.object_id.should_not eq(the_sexpr.object_id)
+        copy.should eq(array)
+        copy.should be_a(Sexpr)
+        copy.tracking_markers.should eq(markers)
+      end
+    end
+
+    it 'works ala inject with a block' do
+      copy = the_sexpr.sexpr_copy do |base, child|
+        base << [:bool_lit, false]
+      end
+      copy.object_id.should_not eq(the_sexpr.object_id)
+      copy.should eq([:bool_not, [:bool_lit, false]])
+      copy.should be_a(Sexpr)
+      copy.tracking_markers.should eq(markers)
+    end
+
+  end
+end

data/spec/node/test_tracking_markers.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Sexpr
+  describe Node, "tracking_markers" do
+
+    it 'defaults to {}' do
+      sexpr([:lit, true]).tracking_markers.should eq({})
+    end
+
+    it 'can be installed through a private writer' do
+      sexpr, markers = sexpr([:lit, true]), {:hello => "world"}
+      sexpr.tracking_markers = markers
+      sexpr.tracking_markers.should eq(markers)
+    end
+
+    it 'are installed through the second argument of sexpr' do
+      markers = {:hello => "World"}
+      sexpr([:lit, true], markers).tracking_markers.should eq(markers)
+    end
+
+  end
+end