maroon 0.6.5 → 0.7.0

data/lib/ImmutableQueue.rb

@@ -1,50 +1,44 @@
 class ImmutableQueue
-       
-def push(element)
+  def push(element)
     b = (back or ImmutableStack.empty)
-ImmutableQueue.new(front, b.push(element))
+    ImmutableQueue.new(front, b.push(element))
+  end
 
- end
- 
-def pop()
+  def pop()
     f, b = front, back
-if (f == ImmutableStack.empty) then
-  until (b == ImmutableStack.empty) do
-    (e, b = b.pop
-    f = f.push(e))
+    if (f == ImmutableStack.empty) then
+      until (b == ImmutableStack.empty) do
+        (e, b = b.pop
+        f = f.push(e))
+      end
+    end
+    head, f = f.pop
+    if (f == b) then
+      [head, ImmutableQueue.empty]
+    else
+      [head, ImmutableQueue.new(f, b)]
+    end
   end
-end
-head, f = f.pop
-if (f == b) then
-  [head, ImmutableQueue.empty]
-else
-  [head, ImmutableQueue.new(f, b)]
-end
 
- end
- 
-def self.empty()
+  def self.empty()
     @@empty ||= ImmutableQueue.new(ImmutableStack.empty, ImmutableStack.empty)
- end
- 
-def push_array(arr)
-    q = self
-arr.each { |i| q = q.push(i) } if arr
-q
+  end
 
- end
+  def push_array(arr)
+    q = self
+    arr.each { |i| q = q.push(i) } if arr
+    q
+  end
 
- private
- 
-def initialize(front,back)
+  private
+  def initialize(front, back)
     @front = (front or ImmutableStack.empty)
-@back = (back or ImmutableStack.empty)
-self.freeze
+    @back = (back or ImmutableStack.empty)
+    self.freeze
+  end
+
+  attr_reader :front
+  attr_reader :back
+
 
- end
-attr_reader :front
-      attr_reader :back
-      
-    
-    
-      end
+end

data/lib/ImmutableStack.rb

@@ -1,38 +1,34 @@
 class ImmutableStack
-       
-def pop()
+  def pop()
     [@head, @tail]
- end
- 
-def push(element)
+  end
+
+  def push(element)
     ImmutableStack.new(element, self)
- end
- 
-def self.empty()
+  end
+
+  def self.empty()
     @@empty ||= self.new(nil, nil)
- end
- 
-def each()
+  end
+
+  def each()
     yield(head)
-t = tail
-while t.!=(ImmutableStack.empty) do
-  h, t = t.pop
-  yield(h)
-end
+    t = tail
+    while t.!=(ImmutableStack.empty) do
+      h, t = t.pop
+      yield(h)
+    end
+  end
 
- end
- 
-def initialize(h,t)
+  def initialize(h, t)
     @head = h
-@tail = t
-self.freeze
+    @tail = t
+    self.freeze
+  end
+
+  private
+  attr_reader :head
+  attr_reader :tail
 
- end
 
- private
-attr_reader :head
-      attr_reader :tail
-      
-    
-    
-      end
+end

data/lib/MethodInfo.rb

@@ -1,78 +1,66 @@
 class MethodInfo
-       
-def initialize(on_self,block_source,is_private)
-    raise("Must be S-Expressions") unless block_source.instance_of?(Sexp)
-if on_self.instance_of?(Hash) then
-  @block = on_self[:block]
-  @on_self = on_self[:self]
-else
-  @on_self = on_self
-end
-@block_source = block_source
-@private = is_private
-self.freeze
+  def initialize(ast, defining_role, is_private)
+    raise("Must be S-Expressions") unless ast.instance_of?(Sexp)
+    @defining_role = defining_role
+    @private = is_private
+    @definition = ast
+    self.freeze
+  end
 
- end
- 
-def is_private()
+  def is_private()
     @private
- end
- 
-def build_as_context_method(context_method_name,interpretation_context)
-    MethodDefinition.new(self_block_source_body, interpretation_context).transform
-body = Ruby2Ruby.new.process(self_block_source_body)
-args = if self_block_source_arguments then
-  (("(" + self_block_source_arguments) + ")")
-else
-  ""
-end
-on = on_self ? ("self.") : ("")
-(((((("\ndef " + on.to_s) + context_method_name.to_s) + args) + "\n    ") + body) + "\n end\n")
+  end
+
+  def name()
+    self_definition_name
+  end
 
- end
+  def build_as_context_method(interpretation_context)
+    AstRewritter.new(self_definition_body, interpretation_context).rewrite!
+    body = Ruby2Ruby.new.process(self_definition_body)
+    raise("Body is undefined") unless body
+    args = self_definition_arguments
+    if args and args.length then
+      args = (("(" + args.join(",")) + ")")
+    else
+      args = ""
+    end
+    real_name = (
+    if (@defining_role == nil) then
+      name.to_s
+    else
+      ((("self_" + @defining_role.to_s) + "_") + name.to_s)
+    end).to_s
+    header = (("def " + real_name) + args)
+    (((header + " ") + body) + " end\n")
+  end
+
+  private
+  attr_reader :definition
 
- private
-attr_reader :on_self
-      attr_reader :block
-      attr_reader :block_source
-      
-       
-def self_block_source_get_arguments()
-    sexp = block_source[2]
-return nil unless sexp
-return sexp[1] if (sexp[0] == :lasgn)
-return [] if (sexp[1] == nil)
-sexp = sexp[(1..-1)]
-args = []
-sexp.each do |e|
-  (args << (if e.instance_of?(Symbol) then
-    e
-  else
-    (e[0] == :splat) ? (("*" + e[1][1].to_s)) : (e[1])
-  end))
-end
-if block then
-  b = ("&" + block.to_s)
-  if args then
-    args = [args] unless args.instance_of?(Array)
-    (args << b)
-  else
-    args = [b]
+  def self_definition_body()
+    args = definition.detect { |d| (d[0] == :args) }
+    index = (definition.index(args) + 1)
+    if (definition.length > (index + 1)) then
+      body = definition[(index..-1)]
+      body.insert(0, :block)
+      body
+    else
+      definition[index]
+    end
   end
-end
-args
 
- end
-   
-def self_block_source_arguments()
-    args = self_block_source_get_arguments
-args and args.length ? (args.join(",")) : (nil)
+  def self_definition_arguments()
+    args = definition.detect { |d| (d[0] == :args) }
+    args and (args.length > 1) ? (args[(1..-1)]) : ([])
+  end
 
- end
-   
-def self_block_source_body()
-    block_source[3]
- end
+  def self_definition_name()
+    if definition[1].instance_of?(Symbol) then
+      definition[1]
+    else
+      ((definition[1].select { |e| e.instance_of?(Symbol) }.map { |e| e.to_s }.join(".") + ".") + definition[2].to_s).to_sym
+    end
+  end
 
-    
-      end
+end

data/lib/Production.rb

@@ -0,0 +1,135 @@
+class Production
+  def initialize(ast, interpretation_context)
+    rebind(ImmutableQueue.empty.push(ast), interpretation_context)
+  end
+
+  def type()
+    case
+      when (nil == production) then
+        nil
+      when self_production_is_block_with_bind? then
+        Tokens.block_with_bind
+      when self_production_is_block? then
+        Tokens.block
+      when (production.instance_of?(Fixnum) or production.instance_of?(Symbol)) then
+        Tokens.terminal
+      when self_production_is_rolemethod_call? then
+        Tokens.rolemethod_call
+      when self_production_is_role? then
+        Tokens.role
+      when self_production_is_indexer? then
+        Tokens.indexer
+      when self_production_is_call? then
+        Tokens.call
+      else
+        Tokens.other
+    end
+  end
+
+  def [](i)
+    @production[i]
+  end
+
+  def []=(i, v)
+    @production[i] = v
+  end
+
+  def length()
+    @production.length
+  end
+
+  def last()
+    @production.last
+  end
+
+  def first()
+    @production.first
+  end
+
+  def data()
+    return @data if @data
+    @data = case
+              when self_production_is_call? then
+                @production[2]
+              else
+                @production
+            end
+  end
+
+  def each()
+    yield(self)
+    if production.instance_of?((Sexp or production.instance_of?(Array))) then
+      @queue = @queue.push_array(production)
+    end
+    while @queue.!=(ImmutableQueue.empty) do
+      rebind(@queue, @interpretation_context)
+      yield(self)
+      if production.instance_of?((Sexp or production.instance_of?(Array))) then
+        @queue = @queue.push_array(production)
+      end
+    end
+  end
+
+  private
+  def rebind(queue, ctx)
+    @data = nil
+    @production, @queue = queue.pop
+    @interpretation_context = ctx
+  end
+
+  attr_reader :interpretation_context
+  attr_reader :queue
+  attr_reader :production
+
+  def self_production_is_role?()
+    case
+      when (self_production_is_call? and interpretation_context.roles.has_key?(production[2])) then
+        @date = [production[2]]
+        return true
+      when (((production == :self) or ((self_production_is_indexer? and ((production[1] == nil) or (production[1] == :self))) or (production and ((production.instance_of?(Sexp) or production.instance_of?(Array)) and (production[0] == :self))))) and @interpretation_context.defining_role) then
+        @data = @interpretation_context.defining_role
+        return true
+      else
+        false
+    end
+  end
+
+  def self_production_is_indexer?()
+    self_production_is_call? and ((production[2] == :[]) or (production[2] == :[]=))
+  end
+
+  def self_production_is_call?()
+    production and ((production.instance_of?(Sexp) or production.instance_of?(Array)) and (production[0] == :call))
+  end
+
+  def self_production_is_block?()
+    production and ((production.instance_of?(Sexp) or production.instance_of?(Array)) and (production[0] == :iter))
+  end
+
+  def self_production_is_block_with_bind?()
+    if self_production_is_block? then
+      body = @production.last
+      if body and exp = body[0] then
+        bind = Production.new(exp, @interpretation_context)
+        true if (bind.type == Tokens.call) and (bind.data == :bind)
+      end
+    end
+  end
+
+  def self_production_is_rolemethod_call?()
+    can_be = self_production_is_call?
+    if can_be then
+      instance = Production.new(production[1], @interpretation_context)
+      can_be = (instance.type == Tokens.role)
+      if can_be then
+        instance_data = instance.data
+        role = @interpretation_context.roles[instance_data]
+        data = production[2]
+        can_be = role.has_key?(data)
+        @data = [data, instance_data]
+      end
+    end
+    can_be
+  end
+
+end

data/lib/Tokens.rb

@@ -0,0 +1,24 @@
+class Tokens
+  def self.define_token(name)
+    class_eval("@@#{name} = Tokens.new :#{name};def Tokens.#{name};@@#{name};end")
+  end
+
+  def to_s
+    @type.to_s
+  end
+
+  private
+  def initialize(type)
+    @type = type
+    self.freeze
+  end
+
+  define_token :terminal
+  define_token :role
+  define_token :rolemethod_call
+  define_token :other
+  define_token :call
+  define_token :indexer
+  define_token :block
+  define_token :block_with_bind
+end

data/lib/build.rb

@@ -1,14 +1,14 @@
 require 'sorcerer'
 require 'sourcify'
 
-require_relative 'self'
-require_relative 'bind'
-require_relative 'ImmutableQueue'
-require_relative 'ImmutableStack'
-require_relative 'interpretation_context'
-require_relative 'MethodDefinition'
-require_relative 'MethodInfo'
-require_relative 'MethodCall'
-
-require_relative 'Context'
+
+require_relative './Tokens'
+require_relative './ImmutableStack'
+require_relative './ImmutableQueue'
+require_relative './interpretation_context'
+require_relative './Production'
+require_relative './AstRewritter'
+require_relative './MethodInfo'
+
+require_relative './Context'