melbourne 1.0.0

data/lib/melbourne/ast/file.rb

@@ -0,0 +1,15 @@
+module Melbourne
+
+  module AST
+
+    # The file macro as in:
+    #
+    #   __FILE__
+    #
+    class File < Node
+
+    end
+
+  end
+
+end

data/lib/melbourne/ast/grapher.rb

@@ -0,0 +1,75 @@
+module Melbourne
+  module AST
+    class AsciiGrapher
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def print
+        graph_node @ast
+      end
+
+      def indented_print(level, value)
+        puts "#{" " * level}#{value}"
+      end
+
+      def print_node(node, level)
+        name = node.class.to_s.split("::").last
+        indented_print level, name
+      end
+
+      def graph_node(node, level=0)
+        print_node node, level
+        level += 2
+
+        nodes = []
+        node.instance_variables.each do |v|
+          next if v == "@compiler"
+
+          value = node.instance_variable_get v
+
+          # lame, yes. remove when Node doesn't have @body by default
+          next if v == "@body" and value.nil? and not v.respond_to? :body=
+
+          if value.kind_of? Node
+            nodes << [v, value]
+          else
+            graph_value v, value, level
+          end
+        end
+
+        nodes.each do |name, node|
+          puts "#{" " * level}#{name}: \\"
+          graph_node node, level
+        end
+      end
+
+      def graph_simple(name, value, level)
+        puts "#{" " * level}#{name}: #{value}"
+      end
+
+      def graph_value(name, value, level)
+        case value
+        when NilClass, String
+          graph_simple name, value.inspect, level
+        when TrueClass, FalseClass, Symbol, Fixnum
+          graph_simple name, value, level
+        when Array
+          puts "#{" " * level}#{name}: \\"
+          nodes = []
+          value.each do |v|
+            if v.kind_of? Node
+              nodes << v
+            else
+              graph_value "-", v, level + 2
+            end
+          end
+
+          nodes.each { |n| graph_node n, level + 2 }
+        else
+          graph_simple name, value.class, level
+        end
+      end
+    end
+  end
+end

data/lib/melbourne/ast/literals.rb

@@ -0,0 +1,268 @@
+module Melbourne
+
+  module AST
+
+    # An array literal as in:
+    #
+    #   [1, 2]
+    #
+    class ArrayLiteral < Node
+
+      # The body os the array literal (the actual values contained in the array)
+      #
+      attr_accessor :body
+
+      def initialize(line, array) #:nodoc:
+        @line = line
+        @body = array
+      end
+
+    end
+
+    # An empty array literal as in:
+    #
+    #   []
+    #
+    class EmptyArray < Node
+
+    end
+
+    # False as in:
+    #
+    #   false
+    #
+    class False < Node
+
+    end
+
+    # True as in:
+    #
+    #   true
+    #
+    class True < Node
+
+    end
+
+    # A float literal as in:
+    #
+    #   1.2
+    #
+    class Float < Node
+
+      # The actual value of the float literal
+      #
+      attr_accessor :value
+
+      def initialize(line, str) #:nodoc:
+        @line = line
+        @value = str.to_f
+      end
+
+    end
+
+    # An hash literal as in:
+    #
+    #   { :a => :b }
+    #
+    class HashLiteral < Node
+
+      # The actual values in the hash literal
+      #
+      attr_accessor :array
+
+      def initialize(line, array) #:nodoc:
+        @line = line
+        @array = array
+      end
+
+    end
+
+    # A symbol literal as in:
+    #
+    #   :x
+    #
+    class SymbolLiteral < Node
+
+      # The value of the symbol literal
+      #
+      attr_accessor :value
+
+      def initialize(line, sym) #:nodoc:
+        @line = line
+        @value = sym
+      end
+
+    end
+
+    # Nil as in:
+    #
+    #   nil
+    #
+    class Nil < Node
+
+    end
+
+    class NumberLiteral < Node #:nodoc:
+
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+    end
+
+    # A FixNum literal as in:
+    #
+    #   1
+    #
+    class FixnumLiteral < NumberLiteral
+
+      def initialize(line, value) #:nodoc:
+        @line = line
+        @value = value
+      end
+
+    end
+
+    # A range literal as in:
+    #
+    #   1..3
+    #
+    class Range < Node
+
+      # The start of the range
+      #
+      attr_accessor :start
+
+      # The finish of the range
+      #
+      attr_accessor :finish
+
+      def initialize(line, start, finish) #:nodoc:
+        @line = line
+        @start = start
+        @finish = finish
+      end
+
+    end
+
+    # A range literal that excludes the end as in:
+    #
+    #   1...3
+    #
+    class RangeExclude < Range
+
+      def initialize(line, start, finish) #:nodoc:
+        @line = line
+        @start = start
+        @finish = finish
+      end
+
+    end
+
+    # A regular expression literal as in:
+    #
+    #   /.*/
+    #
+    class RegexLiteral < Node
+
+      # The source of the regular expression literal
+      #
+      attr_accessor :source
+
+      # Options defined for the regular expression literal (e.g. +n+ or +o+)
+      #
+      attr_accessor :options
+
+      def initialize(line, str, flags) #:nodoc:
+        @line = line
+        @source = str
+        @options = flags
+      end
+
+    end
+
+    # A string literal as in:
+    #
+    #   'some'
+    #
+    class StringLiteral < Node
+
+      # The actual string of the string literal
+      #
+      attr_accessor :string
+
+      def initialize(line, str) #:nodoc:
+        @line = line
+        @string = str
+      end
+
+    end
+
+    # A dynamic string literal as in:
+    #
+    #   "some #{a}"
+    #
+    class DynamicString < StringLiteral
+
+      # The parts of the dynamic string literal
+      #
+      attr_accessor :array
+
+      attr_accessor :options #:nodoc:
+
+      def initialize(line, str, array) #:nodoc:
+        @line = line
+        @string = str
+        @array = array
+      end
+
+    end
+
+    # A dynamic symbol literal as in:
+    #
+    #   :"some#{a}"
+    #
+    class DynamicSymbol < DynamicString
+
+    end
+
+    # A dynamic execute string literal as in:
+    #
+    #   `touch #{path}`
+    #
+    class DynamicExecuteString < DynamicString
+
+    end
+
+    # A dynamic regular expression literal as in:
+    #
+    #   /.*#{a}/
+    #
+    class DynamicRegex < DynamicString
+
+      def initialize(line, str, array, flags) #:nodoc:
+        super line, str, array
+        @options = flags || 0
+      end
+
+    end
+
+    # TODO: document!
+    class DynamicOnceRegex < DynamicRegex #:nodoc:
+
+    end
+
+    # An execute string literal as in:
+    #
+    #   `touch tmp/restart.txt`
+    #
+    class ExecuteString < StringLiteral
+
+    end
+
+  end
+
+end

data/lib/melbourne/ast/node.rb

@@ -0,0 +1,21 @@
+module Melbourne
+
+  module AST
+
+    class Node #:nodoc:
+
+      attr_accessor :line
+
+      def initialize(line)
+        @line = line
+      end
+
+      def ascii_graph
+        AsciiGrapher.new(self).print
+      end
+
+    end
+
+  end
+
+end

data/lib/melbourne/ast/operators.rb

@@ -0,0 +1,117 @@
+module Melbourne
+
+  module AST
+
+    # The +and+ operator as in:
+    #
+    #   a and b
+    #
+    class And < Node
+
+      # The left-side expression of the +and+ operator
+      #
+      attr_accessor :left
+
+      # The right-side expression of the +and+ operator
+      #
+      attr_accessor :right
+
+      def initialize(line, left, right) #:nodoc:
+        @line = line
+        @left = left
+        @right = right
+      end
+
+    end
+
+    # The +or+ operator as in:
+    #
+    #   a or b
+    #
+    class Or < And
+
+    end
+
+    # The +not+ operator as in:
+    #
+    #   (not true)
+    #
+    class Not < Node
+
+      # The value that is negated
+      #
+      attr_accessor :value
+
+      def initialize(line, value) #:nodoc:
+        @line = line
+        @value = value
+      end
+
+    end
+
+    # TODO: document!
+    class OpAssign1 < Node #:nodoc:
+
+      attr_accessor :receiver
+
+      attr_accessor :op
+
+      attr_accessor :index
+
+      attr_accessor :value
+
+      def initialize(line, receiver, index, op, value)
+        @line = line
+        @receiver = receiver
+        @op = op
+        @index = index.body
+        @value = value
+      end
+
+    end
+
+    # TODO: document!
+    class OpAssign2 < Node #:nodoc:
+
+      attr_accessor :receiver
+
+      attr_accessor :op
+
+      attr_accessor :name
+
+      attr_accessor :assign
+
+      attr_accessor :value
+
+      def initialize(line, receiver, name, op, value)
+        @line = line
+        @receiver = receiver
+        @name = name
+        @op = op
+        @value = value
+        @assign = name.to_s[-1] == ?= ? name : :"#{name}="
+      end
+
+    end
+
+    # TODO: document!
+    class OpAssignAnd < Node #:nodoc:
+
+      attr_accessor :left, :right
+
+      def initialize(line, left, right)
+        @line = line
+        @left = left
+        @right = right
+      end
+
+    end
+
+    # TODO: document!
+    class OpAssignOr < OpAssignAnd #:nodoc:
+
+    end
+
+  end
+
+end

data/lib/melbourne/ast/self.rb

@@ -0,0 +1,17 @@
+module Melbourne
+
+  module AST
+
+    # +self+ as in:
+    #
+    #   def me
+    #     self
+    #   end
+    #
+    class Self < Node
+
+    end
+
+  end
+
+end