maroon 0.6.5 → 0.7.0

data/base/method_info.rb

@@ -1,86 +1,67 @@
 context :MethodInfo do
-  initialize do |on_self, block_source, is_private|
-    raise 'Must be S-Expressions' unless block_source.instance_of? Sexp
+  def initialize(ast, defining_role, is_private)
+    raise('Must be S-Expressions') unless ast.instance_of?(Sexp)
 
-    if on_self.instance_of? Hash
-      @block = on_self[:block]
-      @on_self = on_self[:self]
-    else
-      @on_self = on_self
-    end
-    @block_source = block_source
+    @defining_role = defining_role
     @private = is_private
+    @definition = ast
     self.freeze
 
   end
 
-  role :on_self do
-  end
-
-  role :block do
-  end
-
-  role :block_source do
-    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
-                  e
-                else
-                  if e[0] == :splat
-                    '*' + e[1][1].to_s
-                  else
-                    e[1]
-                  end
-                end
+  role :definition do
+    def body
+      args = definition.detect { |d| d[0] == :args }
+      index = definition.index(args) + 1
+      if definition.length > index+1
+        body = definition[index..-1]
+        body.insert(0, :block)
+        body
+      else
+        definition[index]
       end
+    end
+
+    def arguments
+      args = definition.detect { |d| d[0] == :args }
+      args && args.length > 1 ? args[1..-1] : []
+    end
 
-      if block
-        b = '&' + block.to_s
-        if args
-          unless args.instance_of? Array
-            args = [args]
-          end
-          args << b
+    def name
+        if definition[1].instance_of? Symbol
+          definition[1]
         else
-          args = [b]
+          (definition[1].select { |e| e.instance_of? Symbol }.map { |e| e.to_s }.join('.') + '.' + definition[2].to_s).to_sym
         end
-      end
-      args
-      }
-
-    arguments {
-      args = block_source.get_arguments
-      args && args.length ? args.join(',') : nil
-    }
-
-    body {
-      block_source[3]
-    }
+    end
   end
 
-  is_private do
+  def is_private
     @private
   end
 
-  build_as_context_method do |context_method_name, interpretation_context|
-    MethodDefinition.new(block_source.body, interpretation_context).transform
-    body = Ruby2Ruby.new.process(block_source.body)
-    args = block_source.arguments ? '(' + block_source.arguments + ')' : ""
-    on = if on_self then
-           'self.'
-         else
-           ''
-         end
-    '
-def ' + on.to_s + context_method_name.to_s + args +'
-    ' + body +'
- end
+  def name
+    definition.name
+  end
+
+  def build_as_context_method(interpretation_context)
+    AstRewritter.new(definition.body, interpretation_context).rewrite!
+    body = Ruby2Ruby.new.process(definition.body)
+    raise 'Body is undefined' unless body
+    args = definition.arguments
+    if args && args.length
+      args = '('+ args.join(',') + ')'
+    else
+      args= ''
+    end
+
+    real_name = (if @defining_role == nil
+                  name.to_s
+                else
+                  'self_' + @defining_role.to_s + '_' + name.to_s
+                end).to_s
+    header = 'def ' + real_name + args
+    header + ' ' + body + ' end
 '
   end
 end

data/generated/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/generated/build.rb

@@ -1,13 +1,14 @@
 require 'sorcerer'
 require 'sourcify'
 
-require_relative './Self'
-require_relative './Bind'
+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 './MethodCall'
-require_relative './MethodDefinition'
-require_relative './Context'
+
+
 

data/lib/AstRewritter.rb

@@ -0,0 +1,55 @@
+class AstRewritter
+  def initialize(ast, interpretation_context)
+    @ast = Production.new(ast, interpretation_context)
+  end
+
+  def rewrite!()
+    ast.each do |production|
+      case production.type
+        when Tokens.rolemethod_call then
+          data = production.data
+          production[2] = ((("self_" + data[1].to_s) + "_") + data[0].to_s).to_sym
+          production[1] = nil
+        when Tokens.block_with_bind then
+          block = production.last
+          must_b_sym = "aliased_role must be a Symbol".to_sym
+          local_must_b_sym = "local must be a Symbol".to_sym
+          raise(must_b_sym) unless aliased_role.instance_of?(Symbol)
+          raise(local_must_b_sym) unless local.instance_of?(Symbol)
+          aliased_field = ("@" + aliased_role.to_s).to_sym
+          temp_symbol = ("temp____" + aliased_role.to_s).to_sym
+          assignment = Sexp.new
+          assignment[0] = :iasgn
+          assignment[1] = aliased_field
+          load_arg = Sexp.new
+          load_arg[0] = :lvar
+          load_arg[1] = local
+          assignment[2] = load_arg
+          block.insert(1, assignment)
+          assignment = Sexp.new
+          assignment[0] = :lasgn
+          assignment[1] = temp_symbol
+          load_field = Sexp.new
+          load_field[0] = :ivar
+          load_field[1] = aliased_field
+          assignment[2] = load_field
+          block.insert(1, assignment)
+          assignment = Sexp.new
+          assignment[0] = :iasgn
+          assignment[1] = aliased_field
+          load_temp = Sexp.new
+          load_temp[0] = :lvar
+          load_temp[1] = temp_symbol
+          assignment[2] = load_temp
+          block[block.length] = assignment
+        else
+          # do nothing
+      end
+    end
+  end
+
+  private
+  attr_reader :ast
+
+
+end

data/lib/Context.rb

@@ -1,187 +1,205 @@
 class Context
-       
-def self.define(*args,&block)
+  def self.define(*args, &block)
     @@with_contracts ||= nil
-@@generate_file_path ||= nil
-(alias :method_missing :role_or_interaction_method)
-base_class, ctx, default_interaction, name = self.send(:create_context_factory, args, block)
-if (args.last.instance_of?(FalseClass) or args.last.instance_of?(TrueClass)) then
-  ctx.generate_files_in(args.last)
-end
-return ctx.send(:finalize, name, base_class, default_interaction)
-
- end
- 
-def self.generate_files_in(*args,&b)
+    @@generate_file_path ||= nil
+    (alias :method_missing :role_or_interaction_method)
+    base_class, ctx, default_interaction, name = self.send(:create_context_factory, args, block)
+    if (args.last.instance_of?(FalseClass) or args.last.instance_of?(TrueClass)) then
+      ctx.generate_files_in(args.last)
+    end
+    return ctx.send(:finalize, name, base_class, default_interaction, @@generate_file_path, @@with_contracts)
+  end
+
+  def self.generate_files_in(*args, &b)
     if block_given? then
-  return role_or_interaction_method(:generate_files_in, *args, &b)
-end
-@@generate_file_path = args[0]
+      return role_or_interaction_method(:generate_files_in, *args, &b)
+    end
+    @@generate_file_path = args[0]
+  end
 
- end
+  private
+  def get_definitions(b)
+    sexp = b.to_sexp
+    unless is_definition?(sexp[3]) then
+      sexp = sexp[3]
+      sexp = sexp.select { |exp| is_definition?(exp) } if sexp
+      sexp ||= []
+    end
+    sexp.select { |exp| is_definition?(exp) }
+  end
+
+  def self.create_context_factory(args, block)
+    name, base_class, default_interaction = *args
+    if default_interaction and (not base_class.instance_of?(Class)) then
+      base_class = eval(base_class.to_s)
+    end
+    if base_class and ((not default_interaction) and (not base_class.instance_of?(Class))) then
+      base_class, default_interaction = default_interaction, base_class
+    end
+    ctx = Context.new
+    ctx.instance_eval do
+      sexp = block.to_sexp
+      temp_block = sexp[3]
+      i = 0
+      while (i < temp_block.length) do
+        exp = temp_block[i]
+        unless temp_block[(i - 2)] and ((temp_block[(i - 2)][0] == :call) and (temp_block[(i - 1)] and (temp_block[(i - 1)][0] == :args))) then
+          if ((exp[0] == :defn) or (exp[0] == :defs)) then
+            add_method(exp)
+            temp_block.delete_at(i)
+            i = (i - 1)
+          else
+            if (exp[0] == :call) and ((exp[1] == nil) and (exp[2] == :private)) then
+              @private = true
+            end
+          end
+        end
+        i = (i + 1)
+      end
+      ctx.instance_eval(&block)
+    end
+    return [base_class, ctx, default_interaction, name]
+  end
 
- private
- 
-def self.with_contracts(*args)
+  def self.with_contracts(*args)
     return @@with_contracts if (args.length == 0)
-value = args[0]
-if @@with_contracts and (not value) then
-  raise("make up your mind! disabling contracts during execution will result in undefined behavior")
-end
-@@with_contracts = value
-
- end
- 
-def role(*args,&b)
+    value = args[0]
+    if @@with_contracts and (not value) then
+      raise("make up your mind! disabling contracts during execution will result in undefined behavior")
+    end
+    @@with_contracts = value
+  end
+
+  def createInfo(definition)
+    MethodInfo.new(definition, @defining_role, @private)
+  end
+
+  def is_definition?(exp)
+    exp and ((exp[0] == :defn) or (exp[0] == :defs))
+  end
+
+  def role(*args, &b)
     role_name = args[0]
-if (args.length.!=(1) or (not role_name.instance_of?(Symbol))) then
-  return role_or_interaction_method(:role, *args, &b)
-end
-@defining_role = role_name
-@roles[role_name] = Hash.new
-yield if block_given?
-@defining_role = nil
-
- end
- 
-def initialize(*args,&b)
-    if block_given? then
-  role_or_interaction_method(:initialize, *args, &b)
-else
-  @roles = Hash.new
-  @interactions = Hash.new
-  @role_alias = Hash.new
-  @contracts = Hash.new
-end
- end
- 
-def private()
-    @private = true
- end
- 
-def current_interpretation_context(*args,&b)
+    if (args.length.!=(1) or (not role_name.instance_of?(Symbol))) then
+      return role_or_interaction_method(:role, *args, &b)
+    end
+    @defining_role = role_name
+    @roles = {} unless @roles
+    @roles[role_name] = Hash.new
+    definitions = get_definitions(b)
+    definitions.each { |exp| add_method(exp) }
+  end
+
+  def current_interpretation_context(*args, &b)
     if block_given? then
-  return role_or_interaction_method(:current_interpretation_context, *args, &b)
-end
-InterpretationContext.new(roles, contracts, role_alias, nil)
+      return role_or_interaction_method(:current_interpretation_context, *args, &b)
+    end
+    InterpretationContext.new(@roles, @contracts, @role_alias, nil)
+  end
 
- end
- 
-def get_methods(*args,&b)
+  def get_methods(*args, &b)
     return role_or_interaction_method(:get_methods, *args, &b) if block_given?
-name = args[0]
-sources = (@defining_role ? (@roles[@defining_role]) : (@interactions))[name]
-if @defining_role and (not sources) then
-  @roles[@defining_role][name] = []
-else
-  @interactions[name] = []
-end
-
- end
- 
-def add_method(*args,&b)
+    name = args[0]
+    sources = (@defining_role ? (@roles[@defining_role]) : (@interactions))[name]
+    if @defining_role and (not sources) then
+      @roles[@defining_role][name] = []
+    else
+      @interactions[name] = []
+    end
+  end
+
+  def add_method(*args, &b)
     return role_or_interaction_method(:add_method, *args, &b) if block_given?
-name, method = *args
-sources = get_methods(name)
-(sources << method)
+    exp = args[0]
+    info = createInfo(exp)
+    sources = get_methods(info.name)
+    (sources << info)
+  end
 
- end
- 
-def finalize(*args,&b)
+  def finalize(*args, &b)
     return role_or_interaction_method(:finalize, *args, &b) if block_given?
-name, base_class, default = *args
-code = generate_context_code(default, name)
-if @@generate_file_path then
-  name = name.to_s
-  complete = ((((("class " + name) + (base_class ? (("<< " + base_class.name)) : (""))) + "\n      ") + code.to_s) + "\n      end")
-  File.open((((("./" + @@generate_file_path.to_s) + "/") + name) + ".rb"), "w") do |f|
-    f.write(complete)
-  end
-  complete
-else
-  c = base_class ? (Class.new(base_class)) : (Class.new)
-  if @@with_contracts then
-    c.class_eval("def self.assert_that(obj)\n          ContextAsserter.new(self.contracts,obj)\n        end\n        def self.refute_that(obj)\n          ContextAsserter.new(self.contracts,obj,false)\n        end\n        def self.contracts\n          @@contracts\n        end\n        def self.contracts=(value)\n          raise 'Contracts must be supplied' unless value\n          @@contracts = value\n        end")
-    c.contracts = contracts
-  end
-  Kernel.const_set(name, c)
-  temp = c.class_eval(code)
-  (temp or c)
-end
-
- end
- 
-def self.create_context_factory(args,block)
-    name, base_class, default_interaction = *args
-if default_interaction and (not base_class.instance_of?(Class)) then
-  base_class = eval(base_class.to_s)
-end
-if base_class and ((not default_interaction) and (not base_class.instance_of?(Class))) then
-  base_class, default_interaction = default_interaction, base_class
-end
-ctx = Context.new
-ctx.instance_eval(&block)
-return [base_class, ctx, default_interaction, name]
-
- end
- 
-def generate_context_code(*args,&b)
+    name, base_class, default, file_path, with_contracts = *args
+    code = generate_context_code(default, name)
+    if file_path then
+      name = name.to_s
+      complete = ((((("class " + name) + (base_class ? (("<< " + base_class.name)) : (""))) + "\n      ") + code.to_s) + "\n           end")
+      File.open((((("./" + file_path.to_s) + "/") + name) + ".rb"), "w") do |f|
+        f.write(complete)
+      end
+      complete
+    else
+      c = base_class ? (Class.new(base_class)) : (Class.new)
+      if with_contracts then
+        c.class_eval("def self.assert_that(obj)\n  ContextAsserter.new(self.contracts,obj)\nend\ndef self.refute_that(obj)\n  ContextAsserter.new(self.contracts,obj,false)\nend\ndef self.contracts\n  @@contracts\nend\ndef self.contracts=(value)\n  @@contracts = value\nend")
+        c.contracts = contracts
+      end
+      Kernel.const_set(name, c)
+      begin
+        temp = c.class_eval(code)
+      rescue SyntaxError
+        p(("error: " + code))
+      end
+      (temp or c)
+    end
+  end
+
+  def generate_context_code(*args, &b)
     if block_given? then
-  return role_or_interaction_method(:generate_context_code, *args, &b)
-end
-default, name = args
-getters = ""
-impl = ""
-interactions = ""
-@interactions.each do |method_name, methods|
-  methods.each do |method|
-    @defining_role = nil
-    code = (" " + method.build_as_context_method(method_name, current_interpretation_context))
-    method.is_private ? ((getters << code)) : ((interactions << code))
-  end
-end
-if default then
-  (interactions << (((((((("\n         def self.call(*args)\n             arity = " + name.to_s) + ".method(:new).arity\n             newArgs = args[0..arity-1]\n             obj = ") + name.to_s) + ".new *newArgs\n             if arity < args.length\n                 methodArgs = args[arity..-1]\n                 obj.") + default.to_s) + " *methodArgs\n             else\n                obj.") + default.to_s) + "\n             end\n         end\n         "))
-  (interactions << (("\n      def call(*args);" + default.to_s) + " *args; end\n"))
-end
-@roles.each do |role, methods|
-  (getters << (("attr_reader :" + role.to_s) + "\n      "))
-  methods.each do |method_name, method_sources|
-    unless (method_sources.length < 2) then
-      raise(("Duplicate definition of " + method_name.to_s))
-    end
-    unless (method_sources.length > 0) then
-      raise(("No source for " + method_name.to_s))
-    end
-    method_source = method_sources[0]
-    @defining_role = role
-    rewritten_method_name = ((("self_" + role.to_s) + "_") + method_name.to_s)
-    definition = method_source.build_as_context_method(rewritten_method_name, current_interpretation_context)
-    (impl << ("   " + definition.to_s)) if definition
-  end
-end
-(((((interactions + "\n private\n") + getters) + "\n    ") + impl) + "\n    ")
-
- end
- 
-def role_or_interaction_method(*arguments,&b)
+      return role_or_interaction_method(:generate_context_code, *args, &b)
+    end
+    default, name = args
+    getters = ""
+    impl = ""
+    interactions = ""
+    @interactions.each do |method_name, methods|
+      methods.each do |method|
+        @defining_role = nil
+        code = (" " + method.build_as_context_method(current_interpretation_context))
+        method.is_private ? ((getters << code)) : ((interactions << code))
+      end
+    end
+    if default then
+      (interactions << (((((((("\n               def self.call(*args)\n             arity = " + name.to_s) + ".method(:new).arity\n             newArgs = args[0..arity-1]\n             obj = ") + name.to_s) + ".new *newArgs\n             if arity < args.length\n                 methodArgs = args[arity..-1]\n                 obj.") + default.to_s) + " *methodArgs\n             else\n                obj.") + default.to_s) + "\n                             end\n         end\n         "))
+      (interactions << (("\n            def call(*args);" + default.to_s) + " *args; end\n"))
+    end
+    @roles.each do |role, methods|
+      (getters << (("attr_reader :" + role.to_s) + "\n      "))
+      methods.each do |method_name, method_sources|
+        unless (method_sources.length < 2) then
+          raise(("Duplicate definition of " + method_name.to_s))
+        end
+        unless (method_sources.length > 0) then
+          raise(("No source for " + method_name.to_s))
+        end
+        method_source = method_sources[0]
+        @defining_role = role
+        definition = method_source.build_as_context_method(current_interpretation_context)
+        (impl << ("   " + definition.to_s)) if definition
+      end
+    end
+    private_string = (getters + impl).strip!.!=("") ? ("\n     private\n") : ("")
+    impl = impl.strip!.!=("") ? ((("\n    " + impl) + "\n    ")) : ("\n    ")
+    (((interactions + private_string) + getters) + impl)
+  end
+
+  def role_or_interaction_method(*arguments, &b)
     method_name, on_self = *arguments
-unless method_name.instance_of?(Symbol) then
-  on_self = method_name
-  method_name = :role_or_interaction_method
-end
-raise(("Method with out block " + method_name.to_s)) unless block_given?
-add_method(method_name, MethodInfo.new(on_self, b.to_sexp, @private))
-
- end
-attr_reader :roles
-      attr_reader :interactions
-      attr_reader :defining_role
-      attr_reader :role_alias
-      attr_reader :alias_list
-      attr_reader :cached_roles_and_alias_list
-      attr_reader :contracts
-      
-    
-    
-      end
+    unless method_name.instance_of?(Symbol) then
+      on_self = method_name
+      method_name = :role_or_interaction_method
+    end
+    raise(("Method with out block " + method_name.to_s)) unless block_given?
+  end
+
+  def private()
+    @private = true
+  end
+
+  def initialize()
+    @roles = {}
+    @interactions = {}
+    @role_alias = {}
+  end
+
+
+end