sbyc 0.1.0

data/lib/sbyc/codetree/proc_parser.rb

@@ -0,0 +1,91 @@
+module CodeTree
+  class ProcParser
+    class Expr
+      
+      # Methods that we keep
+      KEPT_METHODS = [ "__send__", "__id__", "instance_eval", "initialize", "object_id", 
+                       "singleton_method_added", "singleton_method_undefined", "method_missing",
+                       "__evaluate__", "coerce"]
+
+      class << self
+        def __clean_scope__
+          # Removes all methods that are not needed to the class
+          (instance_methods + private_instance_methods).each do |m|
+            m_to_s = m.to_s
+            undef_method(m_to_s.to_sym) unless ('__' == m_to_s[0..1]) or KEPT_METHODS.include?(m_to_s)
+          end
+        end
+      end
+    
+      # Creates an expression instance
+      def initialize(name = nil, children = nil)
+        class << self; __clean_scope__; end
+        @name, @children = name, children
+      end
+      
+      # Returns the associated functional code
+      def __to_functional_code
+        children = @children.collect{|c|
+          c.kind_of?(Expr) ? c.__to_functional_code : AstNode.coerce(c)
+        }
+        CodeTree::AstNode.coerce([@name, children])
+      end
+      alias :inspect :__to_functional_code
+      
+      # Called when a method is missing
+      def method_missing(name, *args)
+        if @name.nil?
+          if name == :[]
+            Expr.new(:'?', args)
+          elsif args.empty?
+            Expr.new(:'?', [name])
+          else
+            Expr.new(name, args)
+          end
+        else
+          args.unshift(self)
+          Expr.new(name, args)
+        end
+      end
+      
+      def coerce(other)
+        [self, other]
+      end
+
+    end # class Expr
+    
+    # Parses a Proc object
+    def self.parse_proc(block)
+      e = case block.arity
+        when -1, 0
+          Expr.new.instance_eval(&block)
+        when 1
+          block.call(Expr.new)
+        else
+          raise ArgumentError, "Unexpected block arity #{block.arity}"
+      end
+      case e
+        when Expr
+          e.__to_functional_code
+        else
+          CodeTree::AstNode.coerce(e)
+      end
+    end
+    
+    # Parses a block
+    def self.parse(code = nil, &block)
+      block = code || block
+      case block
+        when Proc
+          parse_proc(block)
+        when AstNode
+          block
+        when String
+          parse(Kernel.eval("proc{ #{block} }"))
+        else
+          raise ArgumentError, "Unable to parse #{block}"
+      end
+    end
+    
+  end # class ProcParser
+end # module CodeTree

data/lib/sbyc/codetree/producing.rb

@@ -0,0 +1 @@
+require 'sbyc/codetree/producing/producer'

data/lib/sbyc/codetree/producing/producer.rb

@@ -0,0 +1,68 @@
+module CodeTree
+  module Producing
+    class Producer
+      
+      # Rules kepts by node function
+      attr_reader :rules
+      
+      # Creates a producer instance
+      def initialize(default_rules = true)
+        @rules = {}
+        if default_rules
+          rule(:_) {|r,node| node.literal}
+          rule("*"){|r,node| r.apply(node.children)}
+        end
+        yield(self) if block_given?
+      end
+      
+      # Adds a rule
+      def rule(function_name, &block)
+        rules[function_name] = block
+      end
+      
+      # Applies on some arguments
+      def apply(*args)
+        case args = apply_args_conventions(*args)
+          when CodeTree::AstNode
+            apply_on_node(args)
+          when Array
+            args.collect{|c| apply(c)}
+          else
+            args
+        end
+      end
+      
+      # Applies on a given node
+      def apply_on_node(node)
+        func = node.function
+        if rules.key?(func)
+          @rules[func].call(self, node)
+        elsif rules.key?("*")
+          @rules["*"].call(self, node)
+        else
+          nil
+        end
+      end
+      
+      # Applies arument conventions allowed by _apply_
+      def apply_args_conventions(*args)
+        if args.size == 1 and args[0].kind_of?(CodeTree::AstNode)
+          args[0]
+        elsif args.size > 1 and args[0].kind_of?(Symbol)
+          function = args.shift
+          children = args.collect{|c| apply_args_conventions(c)}.flatten
+          CodeTree::AstNode.coerce([function, children])
+        elsif args.all?{|a| a.kind_of?(CodeTree::AstNode)}
+          args
+        elsif args.size == 1
+          args[0]
+        else
+          raise ArgumentError, "Unable to apply on #{args.inspect} (#{args.size})", caller
+        end
+      end
+      
+      private :apply_on_node
+      private :apply_args_conventions
+    end # class Producer
+  end # module Producing
+end # module CodeTree

data/lib/sbyc/codetree/rewriting.rb

@@ -0,0 +1,4 @@
+require 'sbyc/codetree/rewriting/match'
+require 'sbyc/codetree/rewriting/compiler'
+require 'sbyc/codetree/rewriting/instance_methods'
+require 'sbyc/codetree/rewriting/class_methods'

data/lib/sbyc/codetree/rewriting/class_methods.rb

@@ -0,0 +1,15 @@
+module CodeTree
+  module Rewriting
+    class Rewriter
+      module ClassMethods
+    
+        # Compiles a rewriter
+        def compile(code = nil, &block)
+          Rewriter::Compiler::compile(code || block)
+        end
+    
+      end # module ClassMethods
+      extend ClassMethods
+    end # class Rewriter
+  end # module Rewriting
+end # module CodeTree

data/lib/sbyc/codetree/rewriting/compiler.rb

@@ -0,0 +1,28 @@
+module CodeTree
+  module Rewriting
+    class Rewriter
+      module Compiler
+    
+        # Compiles an Ast to a Rewriter instance
+        def compile(ast)
+          compiled = Rewriter.new
+          Rewriter.new{|r|
+            r.rule(:rewrite){|r, node, *children| 
+              r.apply(children)
+            }
+            r.rule(:upon){|r, upon, upon_match, upon_rule|
+              matcher = CodeTree::matcher(upon_match)
+              upon_expr = CodeTree::expr(upon_rule)
+              r.scope.rule(matcher){|compiled, matched, *matched_children| 
+                upon_expr.apply(compiled, (matcher =~ matched))
+              }
+            }
+          }.rewrite(ast, compiled)
+          compiled
+        end
+        module_function :compile
+    
+      end # module Compiler
+    end # class Rewriter
+  end # module Rewriting
+end # module CodeTree

data/lib/sbyc/codetree/rewriting/instance_methods.rb

@@ -0,0 +1,92 @@
+module CodeTree
+  module Rewriting
+    class Rewriter
+      module InstanceMethods
+    
+        # Installed rules
+        attr_reader :rules
+    
+        # The scope
+        attr_reader :scope
+    
+        # Creates a Rewriter instance
+        def initialize
+          @rules = []
+          yield(self) if block_given?
+        end
+    
+        def ANY()    Rewriter::Match::ANY;    end
+        def BRANCH() Rewriter::Match::BRANCH; end
+        def LEAF()   Rewriter::Match::LEAF;   end
+
+        # Adds a rule to the engine
+        def rule(match, &block)
+          @rules << Rewriter::Match.coerce(match, block)
+        end
+    
+        # Rewrites some code
+        def rewrite(code = nil, scope = nil, &block)
+          @stack = []
+          @scope = block ? code : scope
+          apply(CodeTree.coerce(block || code))
+        ensure 
+          @stack = nil
+          @scope = nil
+        end
+    
+        # Returns the current context node, being the top node on the stack
+        def context_node 
+          @stack.last
+        end
+    
+        # Applies rules on a node      
+        def apply(*args)
+          case node = apply_args_conventions(*args)
+            when CodeTree::AstNode
+              apply_on_node(node)
+            when Array
+              node.collect{|c| c.kind_of?(CodeTree::AstNode) ? apply_on_node(c) : c}
+            else
+              node
+          end
+        end
+    
+        # Applies on a single node
+        def apply_on_node(node)
+          raise ArgumentError, "Node expected, #{node.inspect} received" unless node.kind_of?(CodeTree::AstNode)
+          @stack.push(node)
+          rule = @rules.find{|r| r === node}
+          result = (rule ? rule.apply(self, node) : nil)
+          @stack.pop
+          result
+        end
+    
+        # Produces a node by copying another one
+        def node(function, *children)
+          CodeTree::AstNode.coerce([function, children.flatten])
+        end
+    
+        # 
+        # Applies conventions announced by the _apply_ method.
+        #
+        def apply_args_conventions(*args)
+          if args.size == 1 and args[0].kind_of?(CodeTree::AstNode)
+            args[0]
+          elsif args.size > 1 and args[0].kind_of?(Symbol)
+            function = args.shift
+            children = args.collect{|c| apply_args_conventions(c)}.flatten
+            CodeTree::AstNode.coerce([function, children])
+          elsif args.all?{|a| a.kind_of?(CodeTree::AstNode)}
+            args
+          elsif args.size == 1
+            args[0]
+          else
+            raise ArgumentError, "Unable to apply on #{args.inspect} (#{args.size})", caller
+          end
+        end
+    
+      end # module InstanceMethods
+      include InstanceMethods
+    end # class Rewriter
+  end # module Rewriting
+end # module CodeTree

data/lib/sbyc/codetree/rewriting/match.rb

@@ -0,0 +1,59 @@
+module CodeTree
+  module Rewriting
+    class Rewriter
+      class Match
+    
+        # Matches any node
+        ANY = lambda{|ast_node| true}
+  
+        # Matches a branch node
+        BRANCH = lambda{|ast_node| ast_node.kind_of?(CodeTree::AstNode) and ast_node.branch?}
+  
+        # Matches a leaf node
+        LEAF = lambda{|ast_node| ast_node.kind_of?(CodeTree::AstNode) and ast_node.leaf?}
+  
+        # Coerce argument to a Match instance
+        def self.coerce(arg, block)
+          case arg
+            when Proc
+              Match.new(arg, block)
+            when Symbol
+              Match.new(lambda{|node| node.kind_of?(CodeTree::AstNode) and node.name == arg}, block)
+            when CodeTree::Matcher
+              Match.new(arg, block)
+            when "."
+              Match.new(Match::ANY, block)
+            when "*"
+              Match.new(Match::BRANCH, block)
+            when "@*", "_"
+              Match.new(Match::LEAF, block)
+            else
+              raise "Unexpected rule #{arg.class} #{arg.inspect}"
+          end
+        end
+    
+        # Creates a match instance
+        def initialize(predicate, block)
+          @predicate, @block = predicate, block
+        end
+    
+        # Does this match 
+        def matches?(ast_node)
+          @predicate.call(ast_node)
+        end
+        alias :=== :matches?
+    
+        # Applies this match
+        def apply(rewriter, ast_node)
+          case ast_node
+            when CodeTree::AstNode
+              @block.call(rewriter, ast_node, *ast_node.children)
+            else
+              ast_node
+          end
+        end
+    
+      end # class Match
+    end # class Rewriter
+  end # module Rewriting
+end # module CodeTree

data/test/spec/documentation/codetree/production.spec

@@ -0,0 +1,59 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Gh-Pages documentation: codetree/production.redcloth" do
+
+  describe "What is said about the visit method" do
+    subject {
+      CodeTree::parse{ z * (x + y).to_s }.visit do |node, collected|
+        if node.function == :'?'
+          node.literal
+        else
+          collected.flatten
+        end
+      end
+    }
+    it { should == [:z, :x, :y] }
+  end
+  
+  describe "What is said about the visit method (second example)" do
+    subject {
+      values = {:x => 3, :y => 6, :z => 2}
+      CodeTree::parse{ z * (x + y) }.visit do |node, collected|
+        case node.function
+          when :'?'
+            values[node.literal]
+          when :'+'
+            collected[0] + collected[1]
+          when :'*'
+            collected[0] * collected[1]
+        end
+      end
+    }
+    it { should == 18 }
+  end
+  
+  describe "What is said about the engine (first example)" do
+    let(:producer) {
+      ::CodeTree::producer{|p|
+        
+        # This rule matches leaf nodes (literals)
+        p.rule(:'_') do |engine, node|
+          "On: #{node.literal.inspect}"
+        end
+        
+        # This rule matches everything else
+        p.rule("*") do |engine, node| 
+          "Before: #{node.inspect}"
+          engine.apply(node.children)
+          "After: #{node.inspect}"
+          nil
+        end
+        
+      }
+    }
+    let(:expr) { CodeTree::parse{ (concat "hello ", who) } }
+    subject { producer.apply(expr) }
+    it { should be_nil }
+  end
+  
+end

data/test/spec/documentation/readme/assumptions.spec

@@ -0,0 +1,33 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "README # assumptions section" do
+  
+  [
+    [ proc{ x + 12 + 17   }, "(+ (+ x, 12), 17)" ],
+    [ proc{ x + (12 + 17) }, "(+ x, 29)"         ],
+    [ proc{ (x + 12) + 17 }, "(+ (+ x, 12), 17)" ],
+    [ proc{ if x then 0 else 1 end }, "0"],
+    [ proc{ x and z }, "z"],
+    [ proc{ x && z }, "z"],
+    [ proc{ x or z }, "x"],
+    [ proc{ x || z }, "x"],
+  ].each{|test|
+    specify { CodeTree::parse(test[0]).to_s.should == test[1] }  
+  }
+  
+  if RUBY_VERSION < "1.9.0" 
+    [ [ proc{ !(x) }, "false"],
+      [ proc{ not(x) }, "false"]
+    ].each{|test|
+      specify { CodeTree::parse(test[0]).to_s.should == test[1] }  
+    }
+  else
+    [ [ proc{ !(x) }, "(! x)"],
+      [ proc{ not(x) }, "(! x)"]
+    ].each{|test|
+      specify { CodeTree::parse(test[0]).to_s.should == test[1] }  
+    }
+  end
+  
+
+end