sbyc 0.1.3 → 0.1.4

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

@@ -1,25 +1,26 @@
-module CodeTree
-  module Name2X
-    class ModuleDelegate < Delegate
+module SByC
+  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
+        # 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
+        # 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
-  
+      end # class ModuleDelegate
+    end # module Name2X
+  end # module CodeTree
+end # module SByC

data/lib/sbyc/codetree/proc_parser.rb

@@ -1,124 +1,126 @@
-module CodeTree
-  class ProcParser
-    #
-    # Collector when :multiline option is set to true.
-    #
-    class Collector
+module SByC
+  module CodeTree
+    class ProcParser
+      #
+      # Collector when :multiline option is set to true.
+      #
+      class Collector
 
-      # Which nodes are kept?
-      attr_reader :kept
+        # Which nodes are kept?
+        attr_reader :kept
 
-      # Creates a collector instance
-      def initialize
-        @kept = []
-      end
+        # 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
+        # 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
+        # Returns expressions as an array of AstNodes
+        def to_a
+          kept.collect{|c| c.__to_functional_code}
+        end
 
-    end # class Collector
+      end # class Collector
     
-    # An expression
-    class Expr
+      # 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", "kind_of?"]
+        # Methods that we keep
+        KEPT_METHODS = [ "__send__", "__id__", "instance_eval", "initialize", "object_id", 
+                         "singleton_method_added", "singleton_method_undefined", "method_missing",
+                         "__evaluate__", "coerce", "kind_of?"]
 
-      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)
+        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
-      end
     
-      # Creates an expression instance
-      def initialize(name, children, collector)
-        class << self; __clean_scope__; end
-        @name, @children, @collector = name, children, collector
-        if @collector and @name
-          @collector.built(self, children)
+        # Creates an expression instance
+        def initialize(name, children, collector)
+          class << self; __clean_scope__; end
+          @name, @children, @collector = name, children, collector
+          if @collector and @name
+            @collector.built(self, children)
+          end
         end
-      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
+        # 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, @collector)
-          elsif args.empty?
-            Expr.new(:'?', [name], @collector)
+        # Called when a method is missing
+        def method_missing(name, *args)
+          if @name.nil?
+            if name == :[]
+              Expr.new(:'?', args, @collector)
+            elsif args.empty?
+              Expr.new(:'?', [name], @collector)
+            else
+              Expr.new(name, args, @collector)
+            end
           else
+            args.unshift(self)
             Expr.new(name, args, @collector)
           end
-        else
-          args.unshift(self)
-          Expr.new(name, args, @collector)
         end
-      end
       
-      def coerce(other)
-        [self, other]
-      end
+        def coerce(other)
+          [self, other]
+        end
 
-    end # class Expr
+      end # class Expr
     
-    # Parses a Proc object
-    def self.parse_proc(block, options = {})
-      collector = options[:multiline] ? Collector.new : nil
-      e = case block.arity
-        when -1, 0
-          expr = Expr.new(nil, nil, collector)
-          expr.instance_eval(&block)
-        when 1
-          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
-        else
-          CodeTree::AstNode.coerce(e)
+      # Parses a Proc object
+      def self.parse_proc(block, options = {})
+        collector = options[:multiline] ? Collector.new : nil
+        e = case block.arity
+          when -1, 0
+            expr = Expr.new(nil, nil, collector)
+            expr.instance_eval(&block)
+          when 1
+            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
+          else
+            CodeTree::AstNode.coerce(e)
+        end
       end
-    end
     
-    # Parses a block
-    def self.parse(code = nil, options = {}, &block)
-      block = code || block
-      case block
-        when Proc
-          parse_proc(block, options)
-        when AstNode
-          block
-        when String
-          parse(Kernel.eval("proc{ #{block} }"), options)
-        else
-          raise ArgumentError, "Unable to parse #{block}"
+      # Parses a block
+      def self.parse(code = nil, options = {}, &block)
+        block = code || block
+        case block
+          when Proc
+            parse_proc(block, options)
+          when AstNode
+            block
+          when String
+            parse(Kernel.eval("proc{ #{block} }"), options)
+          else
+            raise ArgumentError, "Unable to parse #{block}"
+        end
       end
-    end
     
-  end # class ProcParser
-end # module CodeTree
+    end # class ProcParser
+  end # module CodeTree
+end # module SByC

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

@@ -1,80 +1,82 @@
-module CodeTree
-  module Producing
-    class Producer
+module SByC
+  module CodeTree
+    module Producing
+      class Producer
       
-      # Rules kepts by node function
-      attr_reader :rules
+        # Rules kepts by node function
+        attr_reader :rules
       
-      # Extension options.
-      attr_reader :extension_options
+        # 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)}
+        # 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)}
+          end
+          yield(self) if block_given?
         end
-        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 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
-      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
+        # 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
-      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
+        # 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
-      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
+        # 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
-      end
       
-      private :apply_on_node
-      private :apply_args_conventions
-    end # class Producer
-  end # module Producing
-end # module CodeTree
+        private :apply_on_node
+        private :apply_args_conventions
+      end # class Producer
+    end # module Producing
+  end # module CodeTree
+end # module SByC

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

@@ -1,77 +1,79 @@
-module CodeTree
-  module Producing
-    module TracingMethods
+module SByC
+  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
+        # 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
+        # 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
+        # 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 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
+        # 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 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 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
+        # 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
+        # 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
-      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 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
+        # 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
+      end # module TracingMethods
+    end # module Producing
+  end # module CodeTree
+end # module SByC