sbyc 0.1.3 → 0.1.4

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

@@ -1,15 +1,17 @@
-module CodeTree
-  module Rewriting
-    class Rewriter
-      module ClassMethods
+module SByC
+  module CodeTree
+    module Rewriting
+      class Rewriter
+        module ClassMethods
     
-        # Compiles a rewriter
-        def compile(code = nil, &block)
-          Rewriter::Compiler::compile(code || block)
-        end
+          # 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
+        end # module ClassMethods
+        extend ClassMethods
+      end # class Rewriter
+    end # module Rewriting
+  end # module CodeTree
+end # module SByC

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

@@ -1,28 +1,30 @@
-module CodeTree
-  module Rewriting
-    class Rewriter
-      module Compiler
+module SByC
+  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))
+          # 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)
               }
-            }
-          }.rewrite(ast, compiled)
-          compiled
-        end
-        module_function :compile
+              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
+        end # module Compiler
+      end # class Rewriter
+    end # module Rewriting
+  end # module CodeTree
+end # module SByC

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

@@ -1,92 +1,94 @@
-module CodeTree
-  module Rewriting
-    class Rewriter
-      module InstanceMethods
+module SByC
+  module CodeTree
+    module Rewriting
+      class Rewriter
+        module InstanceMethods
     
-        # Installed rules
-        attr_reader :rules
+          # Installed rules
+          attr_reader :rules
     
-        # The scope
-        attr_reader :scope
+          # The scope
+          attr_reader :scope
     
-        # Creates a Rewriter instance
-        def initialize
-          @rules = []
-          yield(self) if block_given?
-        end
+          # 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
+          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
+          # 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
+          # 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
+          # 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
+          # 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
-        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
+          # 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
+          # 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
+          # 
+          # 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
     
-      end # module InstanceMethods
-      include InstanceMethods
-    end # class Rewriter
-  end # module Rewriting
-end # module CodeTree
+        end # module InstanceMethods
+        include InstanceMethods
+      end # class Rewriter
+    end # module Rewriting
+  end # module CodeTree
+end # module SByC

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

@@ -1,59 +1,61 @@
-module CodeTree
-  module Rewriting
-    class Rewriter
-      class Match
+module SByC
+  module CodeTree
+    module Rewriting
+      class Rewriter
+        class Match
     
-        # Matches any node
-        ANY = lambda{|ast_node| true}
+          # 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 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?}
+          # 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}"
+          # 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
-        end
     
-        # Creates a match instance
-        def initialize(predicate, block)
-          @predicate, @block = predicate, block
-        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?
+          # 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
+          # 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
     
-      end # class Match
-    end # class Rewriter
-  end # module Rewriting
-end # module CodeTree
+        end # class Match
+      end # class Rewriter
+    end # module Rewriting
+  end # module CodeTree
+end # module SByC

data/lib/sbyc/shortspaces.rb

@@ -0,0 +1,3 @@
+require 'sbyc'
+CodeTree   = SByC::CodeTree
+TypeSystem = SByC::TypeSystem

data/lib/sbyc/type_system.rb

@@ -1,8 +1,10 @@
 #
 # Implements a type system abstraction.
 #
-module TypeSystem
-end # module TypeSystem
+module SByC
+  module TypeSystem
+  end # module TypeSystem
+end # module SByC
 require 'sbyc/type_system/contract'
 require 'sbyc/type_system/errors'
 require 'sbyc/type_system/ruby'

data/lib/sbyc/type_system/contract.rb

@@ -1,42 +1,44 @@
-module TypeSystem
-  #
-  # Defines the abstract contract that a TypeSystem should implement.
-  #
-  module Contract
-    
+module SByC
+  module TypeSystem
     #
-    # Returns the type of a value
+    # Defines the abstract contract that a TypeSystem should implement.
     #
-    def type_of(value)
-    end
+    module Contract
     
-    #
-    # Converts _value_ to a literal and returns it.
-    #
-    # This method should always be such that:
-    #   v == parse_literal(to_literal(v))
-    #
-    # @raise NoSuchLiteralError if value cannot be expressed as a literal
-    #
-    def to_literal(value)
-    end
+      #
+      # Returns the type of a value
+      #
+      def type_of(value)
+      end
     
-    #
-    # Parse _str_ value literal and returns real value.
-    #
-    # @raise InvalidValueLiteralError if str does not look like a valid 
-    #        value literal
-    #
-    def parse_literal(str)
-    end
+      #
+      # Converts _value_ to a literal and returns it.
+      #
+      # This method should always be such that:
+      #   v == parse_literal(to_literal(v))
+      #
+      # @raise NoSuchLiteralError if value cannot be expressed as a literal
+      #
+      def to_literal(value)
+      end
     
-    #
-    # Coerces a string to a given class.
-    #
-    # @raise CoercionError if something goes wrong
-    #
-    def coerce(str, clazz)
-    end
+      #
+      # Parse _str_ value literal and returns real value.
+      #
+      # @raise InvalidValueLiteralError if str does not look like a valid 
+      #        value literal
+      #
+      def parse_literal(str)
+      end
+    
+      #
+      # Coerces a string to a given class.
+      #
+      # @raise CoercionError if something goes wrong
+      #
+      def coerce(str, clazz)
+      end
     
-  end # module Contract
-end # module TypeSystem
+    end # module Contract
+  end # module TypeSystem
+end # module SByC