sbyc 0.1.0 → 0.1.1

data/lib/sbyc.rb

@@ -1,7 +1,7 @@
 module SByC
 
   # Version
-  VERSION = "0.1.0".freeze
+  VERSION = "0.1.1".freeze
   
   # Provides tools around functional source code trees.
   module CodeTree

data/lib/sbyc/codetree.rb

@@ -2,6 +2,7 @@ module CodeTree
   
   # Operator names
   OPERATOR_NAMES = {
+    :'?' => :varref,
     :[]  => :get,
     :[]= => :set,
     :**  => :exponentiation,
@@ -17,8 +18,8 @@ module CodeTree
     :%   => :modulo,
     :=~  => :match,
     :=== => :matches?,
-    :&   => :bool_and,
-    :|   => :bool_or,
+    :&   => :and,
+    :|   => :or,
     :>   => :gt,
     :>=  => :gte,
     :<=  => :lte,
@@ -31,14 +32,15 @@ module CodeTree
   REVERSE_OPERATOR_NAMES = Hash[*OPERATOR_NAMES.to_a.collect{|c| c.reverse}.flatten]
   
   # Parses some code or block
-  def parse(code = nil, &block)
-    ProcParser::parse(code, &block)
+  def parse(code = nil, options = nil, &block)
+    code, options = nil, code if code.kind_of?(Hash) and options.nil?
+    ProcParser::parse(code, options || {}, &block)
   end
   module_function :parse
   
   # Alias for _parse_
-  def expr(code = nil, &block)
-    ProcParser::parse(code, &block)
+  def expr(code = nil, options = nil, &block)
+    parse(code, options || {}, &block)
   end
   module_function :expr
   
@@ -80,3 +82,4 @@ require 'sbyc/codetree/eval'
 require 'sbyc/codetree/producing'
 require 'sbyc/codetree/matching'
 require 'sbyc/codetree/rewriting'
+require 'sbyc/codetree/name2x'

data/lib/sbyc/codetree/ast_node.rb

@@ -1,9 +1,8 @@
 module CodeTree
   class AstNode
-    include Enumerable
     
     # Name of the method call
-    attr_reader :name
+    attr_accessor :name
     alias :function :name
 
     # Children nodes
@@ -45,9 +44,44 @@ module CodeTree
     
     # Makes a depth-first-search visit of the AST
     def visit(&block)
-      yield(self, leaf? ? children : children.collect{|c| c.visit(&block)})
+      yield(self, leaf? ? children : children.collect{|c| c.respond_to?(:visit) ? c.visit(&block) : c})
+    end
+    
+    # Renames some nodes, given a name2name map.
+    def rename!(map = nil, &block)
+      map = CodeTree::Name2X::Delegate.coerce(map || block)
+      visit{|node, collected|
+        newname = map.name2name(node.name)
+        node.send(:name=, newname) if newname
+        nil
+      }
+      self
+    end
+    
+    # Inject code through module mapped to function names
+    def code_inject!(map = nil, &block)
+      map = CodeTree::Name2X::Delegate.coerce(map || block)
+      visit{|node, collected| 
+        ext = map.name2module(node.function)
+        node.extend(ext) if ext
+        nil
+      }
+      self
+    end
+    
+    # Create class instances
+    def digest(map = nil, &block)
+      map = CodeTree::Name2X::Delegate.coerce(map || block)
+      visit{|node, collected| 
+        if node.leaf?
+          node.literal
+        else
+          ext = map.name2class(node.function)
+          raise "Unexpected node function: #{node.function}" unless ext
+          ext.new(*collected)
+        end
+      }
     end
-    alias :produce :visit
     
     # Inspection
     def inspect
@@ -97,5 +131,6 @@ module CodeTree
       end
     end
     
+    private :name=
   end # module AstNode
 end # module CodeTree

data/lib/sbyc/codetree/eval/functional_eval.rb

@@ -3,7 +3,7 @@ module CodeTree
     
     # Generates code for a functional evaluation
     def functional_compile(ast, receiver_object = "receiver", scope_object = "scope", scope_method = :[])
-      ast.produce{|node, collected|
+      ast.visit{|node, collected|
         case func = node.function
           when :_
             collected.first.inspect

data/lib/sbyc/codetree/eval/object_eval.rb

@@ -3,7 +3,7 @@ module CodeTree
     
     # Generates code for an object evaluation
     def object_compile(ast, scope_object = "scope", scope_method = :[])
-      ast.produce{|node, collected|
+      ast.visit{|node, collected|
         case func = node.function
           when :'_'
             collected.first.inspect

data/lib/sbyc/codetree/name2x.rb

@@ -0,0 +1,2 @@
+require "sbyc/codetree/name2x/delegate"
+require "sbyc/codetree/name2x/module_delegate"

data/lib/sbyc/codetree/name2x/delegate.rb

@@ -0,0 +1,57 @@
+module CodeTree
+  module Name2X
+    class Delegate
+      
+      # Hash delegate
+      attr_reader :delegate
+      
+      # Creates FromHash instance
+      def initialize(delegate)
+        @delegate = delegate
+      end
+      
+      # Converts an argument to a sub-class of this
+      # delegate implementation
+      def self.coerce(arg)
+        case arg
+          when Delegate
+            arg
+          when Hash, Proc
+            Delegate.new(arg)
+          when Module
+            ModuleDelegate.new(arg)
+          else
+            if arg.respond_to?(:[])
+              Delegate.new(arg)
+            else
+              raise ArgumentError, "Unable to convert #{arg} to a Name2X::Delegate", caller
+            end
+        end
+      end
+      
+      # Make a fetch on from_hash
+      def fetch(name)
+        delegate[name]
+      end
+      
+      # Convert a name to a module
+      def name2module(name)
+        result = fetch(name)
+        result.kind_of?(Module) ? result : nil
+      end
+      
+      # Convert a name to a class
+      def name2class(name)
+        result = fetch(name)
+        result.kind_of?(Class) ? result : nil
+      end
+      
+      # Convert a name to another name
+      def name2name(name)
+        result = fetch(name)
+        result.kind_of?(Symbol) ? result : nil
+      end
+      
+    end # class FromHash
+  end # module Name2X
+end # module CodeTree

data/lib/sbyc/codetree/name2x/module_delegate.rb

@@ -0,0 +1,25 @@
+module CodeTree
+  module Name2X
+    class ModuleDelegate < Delegate
+      
+      # Overrides the default behavior to use const_get instead.
+      def fetch(name)
+        name = name2name(name)
+        delegate.const_defined?(name) ? delegate.const_get(name) : nil
+      rescue NameError
+        nil
+      end
+      
+      # Capitalize a name
+      def name2name(name)
+        src = name.to_s
+        src.gsub!(/[^a-zA-Z\s]/," ")
+        src = " " + src.split.join(" ")
+        src.gsub!(/ (.)/) { $1.upcase }    
+        src.to_sym
+      end
+      
+    end # class ModuleDelegate
+  end # module Name2X
+end # module CodeTree
+  

data/lib/sbyc/codetree/proc_parser.rb

@@ -1,11 +1,38 @@
 module CodeTree
   class ProcParser
+    #
+    # Collector when :multiline option is set to true.
+    #
+    class Collector
+
+      # Which nodes are kept?
+      attr_reader :kept
+
+      # Creates a collector instance
+      def initialize
+        @kept = []
+      end
+
+      # Callback when a new Expr is created
+      def built(who, children)
+        @kept << who
+        children.each{|c| @kept.delete_if{|k| k.__id__ == c.__id__}}
+      end
+      
+      # Returns expressions as an array of AstNodes
+      def to_a
+        kept.collect{|c| c.__to_functional_code}
+      end
+
+    end # class Collector
+    
+    # An expression
     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"]
+                       "__evaluate__", "coerce", "kind_of?"]
 
       class << self
         def __clean_scope__
@@ -18,14 +45,17 @@ module CodeTree
       end
     
       # Creates an expression instance
-      def initialize(name = nil, children = nil)
+      def initialize(name, children, collector)
         class << self; __clean_scope__; end
-        @name, @children = name, children
+        @name, @children, @collector = name, children, collector
+        if @collector and @name
+          @collector.built(self, children)
+        end
       end
       
       # Returns the associated functional code
       def __to_functional_code
-        children = @children.collect{|c|
+        children = (@children || []).collect{|c|
           c.kind_of?(Expr) ? c.__to_functional_code : AstNode.coerce(c)
         }
         CodeTree::AstNode.coerce([@name, children])
@@ -36,15 +66,15 @@ module CodeTree
       def method_missing(name, *args)
         if @name.nil?
           if name == :[]
-            Expr.new(:'?', args)
+            Expr.new(:'?', args, @collector)
           elsif args.empty?
-            Expr.new(:'?', [name])
+            Expr.new(:'?', [name], @collector)
           else
-            Expr.new(name, args)
+            Expr.new(name, args, @collector)
           end
         else
           args.unshift(self)
-          Expr.new(name, args)
+          Expr.new(name, args, @collector)
         end
       end
       
@@ -55,15 +85,17 @@ module CodeTree
     end # class Expr
     
     # Parses a Proc object
-    def self.parse_proc(block)
+    def self.parse_proc(block, options = {})
+      collector = options[:multiline] ? Collector.new : nil
       e = case block.arity
         when -1, 0
-          Expr.new.instance_eval(&block)
+          Expr.new(nil, nil, collector).instance_eval(&block)
         when 1
-          block.call(Expr.new)
+          block.call(Expr.new(nil, nil, collector))
         else
           raise ArgumentError, "Unexpected block arity #{block.arity}"
       end
+      return collector.to_a if collector
       case e
         when Expr
           e.__to_functional_code
@@ -73,15 +105,15 @@ module CodeTree
     end
     
     # Parses a block
-    def self.parse(code = nil, &block)
+    def self.parse(code = nil, options = {}, &block)
       block = code || block
       case block
         when Proc
-          parse_proc(block)
+          parse_proc(block, options)
         when AstNode
           block
         when String
-          parse(Kernel.eval("proc{ #{block} }"))
+          parse(Kernel.eval("proc{ #{block} }"), options)
         else
           raise ArgumentError, "Unable to parse #{block}"
       end

data/lib/sbyc/codetree/producing.rb

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

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

@@ -5,9 +5,13 @@ module CodeTree
       # Rules kepts by node function
       attr_reader :rules
       
+      # Extension options.
+      attr_reader :extension_options
+      
       # Creates a producer instance
       def initialize(default_rules = true)
         @rules = {}
+        @extension_options = {}
         if default_rules
           rule(:_) {|r,node| node.literal}
           rule("*"){|r,node| r.apply(node.children)}
@@ -15,6 +19,14 @@ module CodeTree
         yield(self) if block_given?
       end
       
+      # Adds an extension module
+      def add_extension(mod, options = {})
+        self.extend(mod)
+        options = mod.send(:prepare_options, options || {}) if mod.respond_to?(:prepare_options)
+        extension_options[mod] = options
+        self
+      end
+      
       # Adds a rule
       def rule(function_name, &block)
         rules[function_name] = block

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

@@ -0,0 +1,77 @@
+module CodeTree
+  module Producing
+    module TracingMethods
+      
+      # Returns the default options
+      def self.default_options
+        {:indent_support  => true,
+         :indent_string   => "  ",
+         :newline_support => true,
+         :io              => STDOUT}
+      end
+      
+      # Merge the default options and the options
+      def self.prepare_options(options)
+        default_options.merge(options)
+      end
+      
+      # Returns tracing extension options
+      def tracing_options
+        extension_options[TracingMethods] ||= {}
+      end
+      
+      # Is indentation support installed?
+      def tracing_indent_support?
+        !!tracing_options[:indent_support]
+      end
+      
+      # Is new line support installed?
+      def tracing_newline_support?
+        !!tracing_options[:newline_support]
+      end
+      
+      # Returns the string to use for indentation
+      def tracing_indent_string
+        tracing_options[:indent_string] ||= "  "
+      end
+      
+      # Returns the current indentation level
+      def tracing_indent_level
+        tracing_options[:indent_level] ||= 0
+      end
+      
+      # Returns the IO object (actually, any object supporting the << operator)
+      # that must be used for tracing the Producer.
+      def tracing_io
+        tracing_options[:io] ||= STDOUT
+      end
+      
+      # Logs a message on the IO object, without any other side effect (no
+      # depth increment, for instance).
+      def trace(message)
+        message = (tracing_indent_string*tracing_indent_level + message.to_s) if tracing_indent_support? and tracing_indent_level>0 
+        message = "#{message}\n" if tracing_newline_support?
+        if tracing_io.kind_of?(IO)
+          tracing_io << message
+        else
+          tracing_io << message
+        end
+      end
+      
+      # Logs that a rule has been entered and increment the depth
+      # level
+      def trace_rule_entered(message)
+        trace(message)
+        tracing_options[:indent_level] = tracing_indent_level+1
+      end
+      
+      # Logs that a rule has been exited and decrements the depth 
+      # level
+      def trace_rule_exited(message)
+        tracing_options[:indent_level] = tracing_indent_level-1
+        trace(message)
+      end
+      
+    end # module TracingMethods
+  end # module Producing
+end # module CodeTree