maroon 0.7.0 → 0.7.1

data/base/transfomer.rb

@@ -0,0 +1,197 @@
+context :Transformer do
+
+  def initialize(context_name, roles, interactions,private_interactions, base_class,default_interaction)
+    @context_name = context_name
+
+    @roles = roles
+    @interactions = interactions
+    @base_class = base_class
+    @default_interaction = default_interaction
+    @private_interactions = private_interactions
+    @definitions = {}
+  end
+
+  role :private_interactions do end
+  role :context_name do end
+  role :roles do
+     def generated_source
+       impl = ''
+       getters = ''
+       roles.each do |role, methods|
+         getters << 'attr_reader :' + role.to_s + '
+         '
+         methods.each do |name, method_sources|
+           bind :method_sources => :method , :name=> :method_name , :role => :defining_role
+           definition = method.generated_source
+           (impl << ('   ' + definition )) if definition
+         end
+       end
+       (impl.strip! || '')+ '
+' + (getters.strip!  || '') + '
+'
+     end
+  end
+  role :interactions do
+    def generated_source
+      internal_methods = ''
+      external_methods = interactions.default
+      interactions.each do |name, interact|
+        interact.each do |m|
+          bind :m => :method, :name => :method_name
+          @defining_role = nil
+          code = method.generated_source
+
+          (method.is_private? ? internal_methods : external_methods) << ' ' << code
+        end
+      end
+      (external_methods.strip! || '') + '
+     private
+' + (internal_methods.strip! || '') + '
+'
+    end
+    def default
+       if @default
+         '
+               def self.call(*args)
+             arity = ' + name.to_s + '.method(:new).arity
+             newArgs = args[0..arity-1]
+             obj = ' + name.to_s + '.new *newArgs
+             if arity < args.length
+                 methodArgs = args[arity..-1]
+                 obj.' + default.to_s + ' *methodArgs
+             else
+                obj.' + default.to_s + '
+                             end
+         end
+            def call(*args);' + default.to_s + ' *args; end
+'
+       else
+         ''
+       end
+    end
+  end
+  role :method_name do end
+  role :defining_role do end
+  role :method do
+    def is_private?
+      defining_role != nil || (private_interactions.has_key? method.name)
+    end
+    def definition
+      key = (@defining_role ? @defining_role.to_s : '') + method_name.to_s
+      return @definitions[key] if @definitions.has_key? key
+      unless method.instance_of? Sexp
+        unless (method.instance_of? Array)  && method.length < 2 then
+          raise(('Duplicate definition of ' + method_name.to_s + '(' + method.to_s + ')'))
+        end
+        unless (method.instance_of? Array)  && method.length > 0 then
+          raise(('No source for ' + method_name.to_s))
+        end
+      end
+
+      d = (method.instance_of? Array) ? method[0] : method
+      raise 'Sexp require' unless d.instance_of? Sexp
+      @definitions[key] = d
+    end
+    def body
+      args = method.definition.detect { |d| d[0] == :args }
+      index = method.definition.index(args) + 1
+      if method.definition.length > index+1
+        body = method.definition[index..-1]
+        body.insert(0, :block)
+        body
+      else
+        method.definition[index]
+      end
+    end
+
+    def arguments
+      args = method.definition.detect { |d| d[0] == :args }
+      args && args.length > 1 ? args[1..-1] : []
+    end
+
+    def name
+      name = if method.definition[1].instance_of? Symbol
+               method.definition[1].to_s
+      else
+        (method.definition[1].select { |e| e.instance_of? Symbol }.map { |e| e.to_s }.join('.') + '.' + method.definition[2].to_s)
+      end
+      (
+      unless defining_role
+        name
+      else
+        'self_' + @defining_role.to_s + '_' + name.to_s
+      end).to_sym
+    end
+    def generated_source
+      AstRewritter.new(method.body, interpretation_context).rewrite!
+      body = Ruby2Ruby.new.process(method.body)
+      raise 'Body is undefined' unless body
+      args = method.arguments
+      if args && args.length
+        args = '('+ args.join(',') + ')'
+      else
+        args= ''
+      end
+
+      header = 'def ' + method.name.to_s + args
+      header + ' ' + body + ' end
+'
+    end
+  end
+
+
+  def transform(file_path, with_contracts)
+
+    code = interactions.generated_source + roles.generated_source
+
+    if file_path then
+      name = context_name.to_s
+      complete = ((((('class ' + name) + (@base_class ? (('<< ' + @base_class.name)) : (''))) + '
+      ') + code.to_s) + '
+           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)
+  ContextAsserter.new(self.contracts,obj)
+end
+def self.refute_that(obj)
+  ContextAsserter.new(self.contracts,obj,false)
+end
+def self.contracts
+  @@contracts
+end
+def self.contracts=(value)
+  @@contracts = value
+end')
+        c.contracts = contracts
+      end
+      Kernel.const_set(context_name, c)
+      begin
+        temp = c.class_eval(code)
+      rescue SyntaxError
+        p 'error: ' + code
+      end
+
+      (temp or c)
+    end
+
+  end
+
+  private
+
+  def contracts
+    (@contracts ||= {})
+  end
+  def role_aliases
+    (@role_aliases ||={})
+  end
+  def interpretation_context
+    InterpretationContext.new(roles, contracts, role_aliases, defining_role, @private_interactions)
+  end
+end

data/generated/build.rb

@@ -6,9 +6,9 @@ require_relative './Tokens'
 require_relative './ImmutableStack'
 require_relative './ImmutableQueue'
 require_relative './interpretation_context'
-require_relative './Production'
+require_relative './AbstractSyntaxTree'
 require_relative './AstRewritter'
-require_relative './MethodInfo'
+require_relative './Transformer'
 
 
 

data/generated/interpretation_context.rb

@@ -15,7 +15,11 @@ class InterpretationContext
     @defining_role
   end
 
-  def initialize(roles, contracts, role_aliases, defining_role)
+  def private_interactions
+    (@private_interactions ||= {})
+  end
+
+  def initialize(roles, contracts, role_aliases, defining_role, private_interactions)
     raise "Aliases must be a hash" unless role_aliases.instance_of? Hash or role_aliases == nil
     raise "Roles must be a hash" unless roles.instance_of? Hash or roles == nil
     raise "Contracts must be a hash" unless contracts.instance_of? Hash or contracts == nil
@@ -25,5 +29,7 @@ class InterpretationContext
     @contracts = contracts
     @role_aliases = role_aliases
     @defining_role = defining_role
+    @private_interactions = private_interactions
+
   end
 end

data/lib/AstRewritter.rb

@@ -1,6 +1,7 @@
 class AstRewritter
   def initialize(ast, interpretation_context)
     @ast = Production.new(ast, interpretation_context)
+    @roles = interpretation_context.roles
   end
 
   def rewrite!()
@@ -12,36 +13,44 @@ class AstRewritter
           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
+          block.delete_at(1)
+          production.data.each do |local, aliased_role|
+            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)
+            unless @roles.has_key?(aliased_role) then
+              role_names = []
+              @interpretation_context.each { |k, v| (role_names << k.to_s) }
+              raise(((aliased_role.to_s + " is not a role. Available roles are ") + role_names.join(",")))
+            end
+            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
+          end
         else
           # do nothing
       end
@@ -49,7 +58,8 @@ class AstRewritter
   end
 
   private
-  attr_reader :ast
 
 
+  attr_reader :ast
+
 end

data/lib/Context.rb

@@ -1,22 +1,35 @@
 class Context
   def self.define(*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
     @@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, @@generate_file_path, @@with_contracts)
+    ctx = self.send(:create_context_factory, name, base_class, default_interaction, block)
+    transformer = Transformer.new(name, ctx.roles, ctx.interactions, ctx.private_interactions, base_class, default_interaction)
+    return transformer.transform(@@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]
   end
 
+  def roles()
+    @roles
+  end
+
+  def interactions()
+    @interactions
+  end
+
+  def private_interactions()
+    @private_interactions
+  end
+
   private
   def get_definitions(b)
     sexp = b.to_sexp
@@ -28,15 +41,8 @@ class Context
     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
+  def self.create_context_factory(name, base_class, default_interaction, block)
+    ctx = Context.new(name, base_class, default_interaction)
     ctx.instance_eval do
       sexp = block.to_sexp
       temp_block = sexp[3]
@@ -58,7 +64,7 @@ class Context
       end
       ctx.instance_eval(&block)
     end
-    return [base_class, ctx, default_interaction, name]
+    ctx
   end
 
   def self.with_contracts(*args)
@@ -70,136 +76,58 @@ class Context
     @@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 = {} 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)
+      definitions = get_definitions(b)
+      definitions.each { |exp| add_method(exp) }
     end
-    InterpretationContext.new(@roles, @contracts, @role_alias, nil)
   end
 
   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
+      @private_interactions[name] = true if @private
       @interactions[name] = []
     end
   end
 
-  def add_method(*args, &b)
-    return role_or_interaction_method(:add_method, *args, &b) if block_given?
-    exp = args[0]
-    info = createInfo(exp)
-    sources = get_methods(info.name)
-    (sources << info)
-  end
-
-  def finalize(*args, &b)
-    return role_or_interaction_method(:finalize, *args, &b) if block_given?
-    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(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?
+  def add_method(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
+    sources = get_methods(name)
+    (sources << definition)
   end
 
   def private()
     @private = true
   end
 
-  def initialize()
+  def initialize(name, base_class, default_interaction)
     @roles = {}
     @interactions = {}
+    @private_interactions = {}
     @role_alias = {}
+    @name = name
+    @base_class = base_class
+    @default_interaction = default_interaction
   end
 
+  attr_reader :name
+  attr_reader :base_class
+  attr_reader :default_interaction
 
 end