melbourne 1.0.0

data/lib/melbourne/ast/definitions.rb

@@ -0,0 +1,561 @@
+module Melbourne
+
+  module AST
+
+    # An +alias+ statement as in:
+    #
+    #   alias x y
+    #
+    class Alias < Node
+
+      # The element that is aliased
+      #
+      attr_accessor :to
+
+      # The alias that is defined for the element
+      #
+      attr_accessor :from
+
+      def initialize(line, to, from) #:nodoc:
+        @line = line
+        @to = to
+        @from = from
+      end
+
+    end
+
+    # TODO: document!
+    class VAlias < Alias #:nodoc:
+
+    end
+
+    # An +undef+ statement as in:
+    #
+    #   undef :x
+    #
+    class Undef < Node
+
+      # The name of the +undef+'d element
+      #
+      attr_accessor :name
+
+      def initialize(line, sym) #:nodoc:
+        @line = line
+        @name = sym
+      end
+
+    end
+
+    # A code block as in:
+    #
+    #   begin
+    #   end
+    #
+    # but also as in (implicit block):
+    #
+    #   a = 1; b = 2
+    #
+    class Block < Node
+
+      # The statements inside of the block
+      #
+      attr_accessor :array
+
+      def initialize(line, array) #:nodoc:
+        @line = line
+        @array = array
+      end
+
+      # TODO: document!
+      def strip_arguments #:nodoc:
+        if @array.first.kind_of? FormalArguments
+          node = @array.shift
+          if @array.first.kind_of? BlockArgument
+            node.block_arg = @array.shift
+          end
+          return node
+        end
+      end
+
+    end
+
+    # TODO: document!
+    class ClosedScope < Node #:nodoc:
+
+      attr_accessor :body
+
+    end
+
+    # A method definition as in:
+    #
+    #   def method
+    #   end
+    #
+    class Define < ClosedScope
+
+      # The name of the defined method
+      #
+      attr_accessor :name
+
+      # The arguments of the defined method
+      #
+      attr_accessor :arguments
+
+      def initialize(line, name, block) #:nodoc:
+        @line = line
+        @name = name
+        @arguments = block.strip_arguments
+        block.array << Nil.new(line) if block.array.empty?
+        @body = block
+      end
+
+    end
+
+    # A singleton method definition as in:
+    #
+    #   def object.method
+    #   end
+    #
+    class DefineSingleton < Node
+
+      # The receiver of the definition
+      #
+      attr_accessor :name
+
+      # The body of the defined method
+      #
+      attr_accessor :body
+
+      def initialize(line, receiver, name, block) #:nodoc:
+        @line = line
+        @receiver = receiver
+        @body = DefineSingletonScope.new line, name, block
+      end
+
+    end
+
+    # The scope a singletion method definition opens. This is the actual body of +Melbourne::AST::DefineSingleton+s
+    #
+    class DefineSingletonScope < Define
+
+      def initialize(line, name, block) #:nodoc:
+        super line, name, block
+      end
+
+    end
+
+    # The formal arguments of a method definition as in:
+    #
+    #   def method(x) # x is a formal argument of the method
+    #   end
+    #
+    class FormalArguments < Node
+
+      # The names of the arguments
+      #
+      attr_accessor :names
+
+      # The names of the required arguments
+      #
+      attr_accessor :required
+
+      # The names of the optional arguments
+      #
+      attr_accessor :optional
+
+      # The arguments of the method that have default values
+      #
+      attr_accessor :defaults
+
+      # The splat (<tt>*some</tt>) arguments of the method
+      #
+      attr_accessor :splat
+
+      # The block argument if there is one
+      #
+      attr_accessor :block_arg
+
+      def initialize(line, args, defaults, splat) #:nodoc:
+        @line = line
+        @defaults = nil
+        @block_arg = nil
+
+        if defaults
+          defaults = DefaultArguments.new line, defaults
+          @defaults = defaults
+          @optional = defaults.names
+
+          stop = defaults.names.first
+          last = args.each_with_index { |a, i| break i if a == stop }
+          @required = args[0, last]
+        else
+          @required = args.dup
+          @optional = []
+        end
+
+        if splat.kind_of? Symbol
+          args << splat
+        elsif splat
+          splat = :@unnamed_splat
+          args << splat
+        end
+        @names = args
+        @splat = splat
+      end
+
+      def block_arg=(node) #:nodoc:
+        @names << node.name
+        @block_arg = node
+      end
+
+      # Gets the arity of the method. The arity is the number of required arguments the method defines.
+      #
+      # === Example
+      #
+      #   def method(a, b = 1) # arity is 1 as the second argument is optional
+      #   end
+      #
+      def arity
+        @required.size
+      end
+
+      # Gets the number of required arguments the method defines.
+      #
+      def required_args
+        @required.size
+      end
+
+      # Gets the total number of all arguments the method defines.
+      #
+      def total_args
+        @required.size + @optional.size
+      end
+
+      # TODO: document!
+      def splat_index #:nodoc:
+        if @splat
+          index = @names.size
+          index -= 1 if @block_arg
+          index -= 1 if @splat.kind_of? Symbol
+          index
+        end
+      end
+
+    end
+
+    # Defaults arguments of a method. This of node also contains the actual statements that define the defaults.
+    #
+    class DefaultArguments < Node
+
+      # The statements that define the defaults (these are usually Melbourne::AST::LocalVariableAssignment nodes)
+      #
+      attr_accessor :arguments
+
+      # The names of the arguments
+      #
+      attr_accessor :names
+
+      def initialize(line, block) #:nodoc:
+        @line = line
+        array = block.array
+        @names = array.map { |a| a.name }
+        @arguments = array
+      end
+
+    end
+
+    module LocalVariable #:nodoc:
+
+      attr_accessor :variable
+
+    end
+
+    # A block argument as in:
+    #
+    #   def method(&block)
+    #   end
+    #
+    class BlockArgument < Node
+
+      include LocalVariable
+
+      # The name of the block argument
+      #
+      attr_accessor :name
+
+      def initialize(line, name) #:nodoc:
+        @line = line
+        @name = name
+      end
+
+    end
+
+    # A class as in:
+    #
+    #   class X; end
+    #
+    class Class < Node
+
+      # The name of the +class+
+      #
+      attr_accessor :name
+
+      # The superclass of the +class+
+      #
+      attr_accessor :superclass
+
+      # The body of the +class+
+      #
+      attr_accessor :body
+
+      def initialize(line, name, superclass, body) #:nodoc:
+        @line = line
+
+        @superclass = superclass ? superclass : Nil.new(line)
+
+        if name.kind_of? Symbol
+          @name = ClassName.new line, name, @superclass
+        else
+          @name = ScopedClassName.new line, name, @superclass
+        end
+
+        if body
+          @body = ClassScope.new line, @name, body
+        else
+          @body = EmptyBody.new line
+        end
+      end
+
+    end
+
+    # The scope a class definition opens. This is the actual body of +Melbourne::AST::Class+es
+    #
+    class ClassScope < ClosedScope
+
+      def initialize(line, name, body) #:nodoc:
+        @line = line
+        @name = name.name
+        @body = body
+      end
+
+    end
+
+    # A class name as in:
+    #
+    #   class X; end
+    #
+    class ClassName < Node
+
+      # The actual name of the class
+      #
+      attr_accessor :name
+
+      # TODO: document!
+      attr_accessor :superclass #:nodoc:
+
+      def initialize(line, name, superclass) #:nodoc:
+        @line = line
+        @name = name
+        @superclass = superclass
+      end
+
+    end
+
+    # A scoped class name as in:
+    #
+    #   class X::Y; end
+    #
+    class ScopedClassName < ClassName
+
+      # The parent of the scoped class name; for a class <tt>class X::Y; end</tt> the scoped class name is +Y+ and the parent is +X+
+      #
+      attr_accessor :parent
+
+      def initialize(line, parent, superclass) #:nodoc:
+        @line = line
+        @name = parent.name
+        @parent = parent.parent
+        @superclass = superclass
+      end
+
+    end
+
+    # A module as in:
+    #
+    #   module M; end
+    #
+    class Module < Node
+
+      # The name of the module
+      #
+      attr_accessor :name
+
+      # The body of the module
+      #
+      attr_accessor :body
+
+      def initialize(line, name, body) #:nodoc:
+        @line = line
+
+        if name.kind_of? Symbol
+          @name = ModuleName.new line, name
+        else
+          @name = ScopedModuleName.new line, name
+        end
+
+        if body
+          @body = ModuleScope.new line, @name, body
+        else
+          @body = EmptyBody.new line
+        end
+      end
+
+    end
+
+    # The body of a class that has no body as in:
+    #
+    #   class X; end
+    #
+    class EmptyBody < Node
+
+    end
+
+    # The name of a module
+    #
+    class ModuleName < Node
+
+      # The actual name of the module
+      #
+      attr_accessor :name
+
+      def initialize(line, name) #:nodoc:
+        @line = line
+        @name = name
+      end
+
+    end
+
+    # A scoped module name as in:
+    #
+    #   module X::M; end
+    #
+    class ScopedModuleName < ModuleName
+
+      # The parent of the scoped module name; for a module <tt>module X::M; end</tt> the scoped module name is +Y+ and the parent is +X+
+      #
+      attr_accessor :parent
+
+      def initialize(line, parent) #:nodoc:
+        @line = line
+        @name = parent.name
+        @parent = parent.parent
+      end
+
+    end
+
+    # The scope a module definition opens. This is the actual body of +Melbourne::AST::Module+s
+    #
+    class ModuleScope < ClosedScope
+
+      def initialize(line, name, body) #:nodoc:
+        @line = line
+        @name = name.name
+        @body = body
+      end
+
+    end
+
+    # A singleton class as in:
+    #
+    #   class X
+    #     class << self
+    #     end
+    #   end
+    #
+    class SClass < Node
+
+      # The receiver (for <tt>class << self</tt>, +self+ is the receiver)
+      #
+      attr_accessor :receiver
+
+      def initialize(line, receiver, body) #:nodoc:
+        @line = line
+        @receiver = receiver
+        @body = SClassScope.new line, body
+      end
+
+    end
+
+    # The scope a singleton class definition opens. This is the actual body of +Melbourne::AST::SClass+s
+    #
+    class SClassScope < ClosedScope
+
+      def initialize(line, body) #:nodoc:
+        @line = line
+        @body = body
+        @name = nil
+      end
+
+    end
+
+    # TODO: document!
+    class Container < ClosedScope #:nodoc:
+
+      attr_accessor :file, :name, :variable_scope
+
+      def initialize(body)
+        @body = body || Nil.new(1)
+      end
+
+    end
+
+    # TODO: document!
+    class EvalExpression < Container #:nodoc:
+
+      def initialize(body)
+        super body
+        @name = :__eval_script__
+      end
+
+    end
+
+    # TODO: document!
+    class Snippit < Container #:nodoc:
+
+      def initialize(body)
+        super body
+        @name = :__snippit__
+      end
+
+    end
+
+    # TODO: document!
+    class Script < Container #:nodoc:
+
+      def initialize(body)
+        super body
+        @name = :__script__
+      end
+
+    end
+
+    # A <tt>defined?</tt> statement as in:
+    #
+    #   defined? a
+    #
+    class Defined < Node
+
+      # The expression passed to <tt>defined?</tt>
+      #
+      attr_accessor :expression
+
+      def initialize(line, expr) #:nodoc:
+        @line = line
+        @expression = expr
+      end
+
+    end
+
+  end
+
+end

data/lib/melbourne/ast/exceptions.rb

@@ -0,0 +1,182 @@
+module Melbourne
+
+  module AST
+
+    # A +begin+ statement as in:
+    #
+    #   begin
+    #     do
+    #   rescue
+    #     puts 'error'
+    #   end
+    #
+    class Begin < Node
+
+      # The +rescue+ statement to the +begin+ statement id there is any
+      #
+      attr_accessor :rescue
+
+      def initialize(line, body) #:nodoc:
+        @line = line
+        @rescue = body
+      end
+
+    end
+
+    EnsureType = 1
+
+    # An +ensure+ statement as in:
+    #
+    #   begin
+    #     do
+    #   rescue
+    #     puts 'error'
+    #   ensure
+    #     clean
+    #   end
+    #
+    class Ensure < Node
+
+      # The body of the +ensure+ statement
+      #
+      attr_accessor :body
+
+      # A literal if one is defined as the only statement in the +ensure+ statement
+      #
+      attr_accessor :ensure
+
+      def initialize(line, body, ensr) #:nodoc:
+        @line = line
+        @body = body || Nil.new(line)
+        @ensure = ensr
+      end
+
+    end
+
+    RescueType = 0
+
+    # A +rescue+ statement as in:
+    #
+    #   begin
+    #     do
+    #   rescue
+    #     puts 'error'
+    #   end
+    #
+    class Rescue < Node
+
+      # The body of the +rescue+ block
+      #
+      attr_accessor :body
+
+      # The exception or other element that is rescued from
+      #
+      attr_accessor :rescue
+
+      # The +else+ block of the +rescue+ block (+else+ is an alias for +ensure+ here)
+      #
+      attr_accessor :else
+
+      def initialize(line, body, rescue_body, else_body) #:nodoc:
+        @line = line
+        @body = body
+        @rescue = rescue_body
+        @else = else_body
+      end
+
+    end
+
+    # A +rescue+ condition as in:
+    #
+    #   begin
+    #     do
+    #   rescue RuntimeError => e
+    #     puts 'error'
+    #   end
+    #
+    class RescueCondition < Node
+
+      # The actual conditions of rescue condition
+      #
+      attr_accessor :conditions
+
+      # Assignments in the rescue condition (e.g. <tt>RuntimeError => e</tt>, where +e+ is assigned)
+      #
+      attr_accessor :assignment
+
+      # The body os the +rescue+ block
+      #
+      attr_accessor :body
+
+      # TODO: document!
+      attr_accessor :next #:nodoc:
+
+      # TODO: document!
+      attr_accessor :splat #:nodoc:
+
+      def initialize(line, conditions, body, nxt) #:nodoc:
+        @line = line
+        @next = nxt
+        @splat = nil
+        @assignment = nil
+
+        case conditions
+        when ArrayLiteral
+          @conditions = conditions
+        when ConcatArgs
+          @conditions = conditions.array
+          @splat = RescueSplat.new line, conditions.rest
+        when SplatValue
+          @splat = RescueSplat.new line, conditions.value
+        when nil
+          condition = ConstFind.new line, :StandardError
+          @conditions = ArrayLiteral.new line, [condition]
+        end
+
+        case body
+        when Block
+          @assignment = body.array.shift if assignment? body.array.first
+          @body = body
+        when nil
+          @body = Nil.new line
+        else
+          if assignment? body
+            @assignment = body
+            @body = Nil.new line
+          else
+            @body = body
+          end
+        end
+      end
+
+      # TODO: document!
+      def assignment?(node) #:nodoc:
+        case node
+        when VariableAssignment
+          value = node.value
+        when AttributeAssignment
+          value = node.arguments.array.last
+        else
+          return false
+        end
+
+        return true if value.kind_of? GlobalVariableAccess and value.name == :$!
+      end
+
+    end
+
+    # TODO: document!
+    class RescueSplat < Node #:nodoc:
+
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+    end
+
+  end
+
+end