maroon 0.6.1 → 0.6.5

data/base/method_info.rb

@@ -0,0 +1,86 @@
+context :MethodInfo do
+  initialize do |on_self, block_source, is_private|
+    raise 'Must be S-Expressions' unless block_source.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
+    @private = is_private
+    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
+      end
+
+      if block
+        b = '&' + block.to_s
+        if args
+          unless args.instance_of? Array
+            args = [args]
+          end
+          args << b
+        else
+          args = [b]
+        end
+      end
+      args
+      }
+
+    arguments {
+      args = block_source.get_arguments
+      args && args.length ? args.join(',') : nil
+    }
+
+    body {
+      block_source[3]
+    }
+  end
+
+  is_private do
+    @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
+'
+  end
+end

data/base/self.rb

@@ -0,0 +1,60 @@
+context :Self, :execute do
+  initialize do |abstract_syntax_tree, interpretationcontext|
+    raise 'Interpretation context missing' unless interpretationcontext
+    raise 'Must have a defining role' unless interpretationcontext.defining_role
+
+    @abstract_syntax_tree = abstract_syntax_tree
+    @interpretation_context = interpretationcontext
+  end
+
+  role :abstract_syntax_tree do
+    is_indexer_call_on_self do
+      abstract_syntax_tree.length == 4 &&
+          abstract_syntax_tree[0] == :call &&
+          abstract_syntax_tree[1] == nil &&
+          abstract_syntax_tree[2] == :[] &&
+          abstract_syntax_tree[3][0] == :argslist
+    end
+
+  end
+  role :interpretation_context do
+    defining_role do
+      interpretation_context.defining_role
+    end
+  end
+
+  # rewrites a call to self in a role method to a call to the role player accessor
+  # which is subsequently rewritten to a call to the instance variable itself
+  # in the case where no role method is called on the role player
+  # It's rewritten to an instance call on the context object if a role method is called
+  execute do
+    if abstract_syntax_tree
+      if abstract_syntax_tree[0] == :self #if self is used in a role method, then rewrite to role getter
+        abstract_syntax_tree[0] = :call
+        abstract_syntax_tree[1] = nil
+        abstract_syntax_tree[2] = interpretation_context.defining_role
+      elsif abstract_syntax_tree[0] == :call and abstract_syntax_tree[1] == nil
+        method_name = abstract_syntax_tree[2]
+        #self is removed from S-expressions
+        if method_name == :[] or method_name == :[]=
+          get_role = Sexp.new
+          get_role[0] = :call
+          get_role[1] = nil
+          get_role[2] = interpretation_context.defining_role
+          abstract_syntax_tree[1] = get_role
+        end
+      elsif abstract_syntax_tree.instance_of? Sexp
+        if abstract_syntax_tree.is_indexer_call_on_self
+          getter = new Sexp.new
+          getter[0] = :call
+          getter[1] = nil
+          getter[2] = interpretation_context.defining_role
+          arglist = Sexp.new
+          getter[3] = arglist
+          arglist[0] = :arglist
+          abstract_syntax_tree[1] = getter
+        end
+      end
+    end
+  end
+end

data/generated/build.rb

@@ -0,0 +1,13 @@
+require 'sorcerer'
+require 'sourcify'
+
+require_relative './Self'
+require_relative './Bind'
+require_relative './ImmutableStack'
+require_relative './ImmutableQueue'
+require_relative './interpretation_context'
+require_relative './MethodInfo'
+require_relative './MethodCall'
+require_relative './MethodDefinition'
+require_relative './Context'
+

data/generated/interpretation_context.rb

@@ -0,0 +1,29 @@
+class InterpretationContext
+  def contracts
+    (@contracts ||= {})
+  end
+
+  def roles
+    (@roles ||= {})
+  end
+
+  def role_aliases
+    (@role_aliases ||= {})
+  end
+
+  def defining_role
+    @defining_role
+  end
+
+  def initialize(roles, contracts, role_aliases, defining_role)
+    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
+
+    @roles = roles
+    raise "Defining role is undefined" if defining_role && (!self.roles.has_key? defining_role)
+    @contracts = contracts
+    @role_aliases = role_aliases
+    @defining_role = defining_role
+  end
+end

data/lib/Bind.rb

@@ -0,0 +1,65 @@
+class Bind
+       
+def initialize(local,aliased_role,block)
+    @local = local
+@aliased_role = aliased_role
+@block = block
+
+ end
+ 
+def execute()
+    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
+
+ end
+
+         def self.call(*args)
+             arity = Bind.method(:new).arity
+             newArgs = args[0..arity-1]
+             obj = Bind.new *newArgs
+             if arity < args.length
+                 methodArgs = args[arity..-1]
+                 obj.execute *methodArgs
+             else
+                obj.execute
+             end
+         end
+         
+      def call(*args);execute *args; end
+
+ private
+attr_reader :block
+      attr_reader :local
+      attr_reader :aliased_role
+      
+    
+    
+      end

data/lib/Context.rb

@@ -0,0 +1,187 @@
+class Context
+       
+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)
+    if block_given? then
+  return role_or_interaction_method(:generate_files_in, *args, &b)
+end
+@@generate_file_path = args[0]
+
+ end
+
+ private
+ 
+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)
+    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 block_given? then
+  return role_or_interaction_method(:current_interpretation_context, *args, &b)
+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
+  @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)
+
+ end
+ 
+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)
+    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)
+    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

data/lib/ImmutableQueue.rb

@@ -0,0 +1,50 @@
+class ImmutableQueue
+       
+def push(element)
+    b = (back or ImmutableStack.empty)
+ImmutableQueue.new(front, b.push(element))
+
+ end
+ 
+def pop()
+    f, b = front, back
+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
+ 
+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
+
+ private
+ 
+def initialize(front,back)
+    @front = (front or ImmutableStack.empty)
+@back = (back or ImmutableStack.empty)
+self.freeze
+
+ end
+attr_reader :front
+      attr_reader :back
+      
+    
+    
+      end