maroon 0.7.0 → 0.7.1

data/lib/ImmutableQueue.rb

@@ -40,5 +40,4 @@ class ImmutableQueue
   attr_reader :front
   attr_reader :back
 
-
 end

data/lib/ImmutableStack.rb

@@ -27,8 +27,9 @@ class ImmutableStack
   end
 
   private
+
+
   attr_reader :head
   attr_reader :tail
 
-
 end

data/lib/Production.rb

@@ -77,10 +77,6 @@ class Production
     @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
@@ -109,9 +105,23 @@ class Production
   def self_production_is_block_with_bind?()
     if self_production_is_block? then
       body = @production.last
-      if body and exp = body[0] then
+      if body and exp = body[1] then
         bind = Production.new(exp, @interpretation_context)
-        true if (bind.type == Tokens.call) and (bind.data == :bind)
+        if (bind.type == Tokens.call) and (bind.data == :bind) then
+          aliases = {}
+          list = exp.last[(1..-1)]
+          (list.length / 2).times do |i|
+            local = list[(i * 2)].last
+            role_name = list[((i * 2) + 1)].last
+            raise("Local in bind should be a symbol") unless local.instance_of?(Symbol)
+            unless role_name.instance_of?(Symbol) then
+              raise("Role name in bind should be a symbol")
+            end
+            aliases[local] = role_name
+          end
+          @data = aliases
+          true
+        end
       end
     end
   end
@@ -132,4 +142,8 @@ class Production
     can_be
   end
 
+  attr_reader :interpretation_context
+  attr_reader :queue
+  attr_reader :production
+
 end

data/lib/Transformer.rb

@@ -0,0 +1,174 @@
+class Transformer
+  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
+
+  def transform(file_path, with_contracts)
+    code = (self_interactions_generated_source + self_roles_generated_source)
+    if file_path then
+      name = context_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(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
+
+  def self_roles_generated_source()
+    impl = ""
+    getters = ""
+    roles.each do |role, methods|
+      (getters << (("attr_reader :" + role.to_s) + "\n         "))
+      methods.each do |name, method_sources|
+        temp____defining_role = @defining_role
+        @defining_role = role
+        temp____method_name = @method_name
+        @method_name = name
+        temp____method = @method
+        @method = method_sources
+        definition = self_method_generated_source
+        (impl << ("   " + definition)) if definition
+        @method = temp____method
+        @method_name = temp____method_name
+        @defining_role = temp____defining_role
+      end
+    end
+    ((((impl.strip! or "") + "\n") + (getters.strip! or "")) + "\n")
+  end
+
+  def self_interactions_generated_source()
+    internal_methods = ""
+    external_methods = self_interactions_default
+    interactions.each do |name, interact|
+      interact.each do |m|
+        temp____method_name = @method_name
+        @method_name = name
+        temp____method = @method
+        @method = m
+        @defining_role = nil
+        code = self_method_generated_source
+        (((self_method_is_private? ? (internal_methods) : (external_methods)) << " ") << code)
+        @method = temp____method
+        @method_name = temp____method_name
+      end
+    end
+    ((((external_methods.strip! or "") + "\n     private\n") + (internal_methods.strip! or "")) + "\n")
+  end
+
+  def self_interactions_default()
+    if @default then
+      (((((((((("\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            def call(*args);") + default.to_s) + " *args; end\n")
+    else
+      ""
+    end
+  end
+
+  def self_method_is_private?()
+    (defining_role.!=(nil) or private_interactions.has_key?(self_method_name))
+  end
+
+  def self_method_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) then
+      unless method.instance_of?(Array) and (method.length < 2) then
+        raise((((("Duplicate definition of " + method_name.to_s) + "(") + method.to_s) + ")"))
+      end
+      unless method.instance_of?(Array) and (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 self_method_body()
+    args = self_method_definition.detect { |d| (d[0] == :args) }
+    index = (self_method_definition.index(args) + 1)
+    if (self_method_definition.length > (index + 1)) then
+      body = self_method_definition[(index..-1)]
+      body.insert(0, :block)
+      body
+    else
+      self_method_definition[index]
+    end
+  end
+
+  def self_method_arguments()
+    args = self_method_definition.detect { |d| (d[0] == :args) }
+    args and (args.length > 1) ? (args[(1..-1)]) : ([])
+  end
+
+  def self_method_name()
+    name = if self_method_definition[1].instance_of?(Symbol) then
+             self_method_definition[1].to_s
+           else
+             ((self_method_definition[1].select { |e| e.instance_of?(Symbol) }.map do |e|
+               e.to_s
+             end.join(".") + ".") + self_method_definition[2].to_s)
+           end
+    (
+    if defining_role then
+      ((("self_" + @defining_role.to_s) + "_") + name.to_s)
+    else
+      name
+    end).to_sym
+  end
+
+  def self_method_generated_source()
+    AstRewritter.new(self_method_body, interpretation_context).rewrite!
+    body = Ruby2Ruby.new.process(self_method_body)
+    raise("Body is undefined") unless body
+    args = self_method_arguments
+    if args and args.length then
+      args = (("(" + args.join(",")) + ")")
+    else
+      args = ""
+    end
+    header = (("def " + self_method_name.to_s) + args)
+    (((header + " ") + body) + " end\n")
+  end
+
+  attr_reader :private_interactions
+  attr_reader :context_name
+  attr_reader :roles
+  attr_reader :interactions
+  attr_reader :method_name
+  attr_reader :defining_role
+  attr_reader :method
+
+end

data/lib/build.rb

@@ -1,14 +1,14 @@
 require 'sorcerer'
 require 'sourcify'
 
-
+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 './Transformer'
+
 
-require_relative './Context'
 

data/lib/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/maroon/version.rb

@@ -1,3 +1,3 @@
 module Maroon
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maroon
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Rune Funch Søltoft
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-24 00:00:00.000000000 Z
+date: 2013-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sourcify
@@ -72,18 +72,17 @@ files:
 - Test/Context_test.rb
 - Test/Greeter_test_disabled.rb
 - Test/ImmutableQueue_test.rb
-- Test/MethodInfo_test.rb
+- Test/abstract_syntax_tree_test.rb
 - Test/alltests.rb
 - Test/assertions.rb
-- Test/production_test.rb
 - Test/stack_test.rb
 - Test/test_helper.rb
+- base/AbstractSyntaxTree.rb
 - base/AstRewritter.rb
 - base/ImmutableStack.rb
-- base/Production.rb
 - base/immutable_queue.rb
 - base/maroon_base.rb
-- base/method_info.rb
+- base/transfomer.rb
 - generated/Tokens.rb
 - generated/build.rb
 - generated/interpretation_context.rb
@@ -91,9 +90,9 @@ files:
 - lib/Context.rb
 - lib/ImmutableQueue.rb
 - lib/ImmutableStack.rb
-- lib/MethodInfo.rb
 - lib/Production.rb
 - lib/Tokens.rb
+- lib/Transformer.rb
 - lib/build.rb
 - lib/interpretation_context.rb
 - lib/maroon/contracts.rb

data/Test/MethodInfo_test.rb

@@ -1,86 +0,0 @@
-require 'test/unit'
-require_relative '../generated/MethodInfo'
-require 'ripper'
-require_relative 'test_helper'
-
-class MethodInfoTest < Test::Unit::TestCase
-  include SourceAssertions
-   def get_def(&b)
-     (get_sexp &b).detect do |exp|
-       exp[0] == :defn || exp[0] == :defs
-     end
-   end
-
-  def test_simple
-    block = get_def  do
-      def name (a, b)
-        p 'this is a test'
-      end
-    end
-
-    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
-    expected ='def name(a,b)    p("this is a test") end'
-    assert_source_equal(expected, source)
-  end
-
-  def test_rolemethod
-    block = get_def  do
-      def name (a, b)
-        foo.bar
-      end
-    end
-
-    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({:foo=>{:bar=>[]}}, {}, {}, nil))
-    expected ='def name(a,b)    self_foo_bar end'
-    assert_source_equal(expected, source)
-  end
-
-  def test_class_method
-    block = get_def do
-      def self.name(a, b)
-        p 'this is a test'
-      end
-    end
-
-    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
-    expected = 'def self.name(a,b)  p("this is a test") end'
-
-    assert_source_equal(expected, source)
-  end
-
-  def test_splat_argument
-    block = get_def do
-      def name (a, *b)
-      p 'this is a test'
-      end
-    end
-    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
-    expected = 'def name(a,*b) p("this is a test") end'
-    assert_source_equal(expected, source)
-  end
-
-  def test_block_argument
-    block = get_def do
-     def name(a, b,&block)
-      p 'this is a test'
-     end
-    end
-
-    source = MethodInfo.new( block,nil,false)
-    source = source.build_as_context_method(InterpretationContext.new({}, {}, {}, nil))
-    expected = 'def name(a,b,&block)    p("this is a test")  end'
-
-    assert_source_equal(expected, source)
-  end
-
-  def test_block_argument_class_method
-    block = get_def do
-      def self.name(a, *b,&block)
-        p 'is a test'
-      end
-    end
-    source = MethodInfo.new( block,nil,false).build_as_context_method( InterpretationContext.new({}, {}, {}, nil))
-    expected = 'def self.name(a,*b,&block) p("is a test") end'
-    assert_source_equal(expected, source)
-  end
-end

data/base/method_info.rb

@@ -1,67 +0,0 @@
-context :MethodInfo do
-  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
-
-  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
-
-    def name
-        if definition[1].instance_of? Symbol
-          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
-
-  def is_private
-    @private
-  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