maroon 0.6.1 → 0.6.5

data/lib/ImmutableStack.rb

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

data/lib/MethodCall.rb

@@ -0,0 +1,91 @@
+class MethodCall
+       
+def rewrite_call?()
+    method_name = method[2]
+if (method[0] == :call) then
+  if (method[1] == nil) and ((method.length < 5) and (method[3] and ((method[3].length == 1) and (method[3][0] == :arglist)))) then
+    is_role = interpretation_context.roles.has_key?(method[3])
+    method[3] = (":@" + method[3].to_sym) if is_role
+  else
+    role_name, is_role_method = self_method_role_method_call?(method_name)
+    if is_role_method then
+      method[1] = nil
+      method[2] = ((("self_" + role_name.to_s) + "_") + method_name.to_s).to_sym
+    else
+      if interpretation_context.roles.has_key?(role_name) then
+        unless (method.length == 3) and ((method[1] == nil) and (method[2] == role_name)) then
+          contract_methods = interpretation_context.contracts[role_name] ||= {}
+          contract_methods[method_name] ||= 0
+          contract_methods[method_name] += 1
+        end
+      end
+    end
+  end
+end
+
+ end
+ 
+def initialize(method,interpretation_context)
+    raise("No method supplied") unless method
+@method = method
+@interpretation_context = interpretation_context
+
+ end
+
+         def self.call(*args)
+             arity = MethodCall.method(:new).arity
+             newArgs = args[0..arity-1]
+             obj = MethodCall.new *newArgs
+             if arity < args.length
+                 methodArgs = args[arity..-1]
+                 obj.rewrite_call? *methodArgs
+             else
+                obj.rewrite_call?
+             end
+         end
+         
+      def call(*args);rewrite_call? *args; end
+
+ private
+attr_reader :interpretation_context
+      attr_reader :method
+      
+       
+def self_interpretation_context_role_aliases()
+    (@interpretation_context.role_aliases or {})
+ end
+   
+def self_method_call_in_block?()
+    @in_block unless (@in_block == nil)
+@in_block = (method and (method[0] == :lvar))
+
+ end
+   
+def self_method_get_role_definition()
+    is_call_expression = (method and (method[0] == :call))
+self_is_instance_expression = (is_call_expression and (not method[1]))
+role_name = nil
+role_name = method[2] if self_is_instance_expression
+if (not self_is_instance_expression) and method[1] then
+  if (method[1][1] == nil) and (method[1][0] == :call) then
+    role_name = method[1][2]
+  end
+  if (method[1][0] == :lvar) then
+    role_name = self_interpretation_context_role_aliases[method[1][1]]
+  end
+end
+role = role_name ? (interpretation_context.roles[role_name]) : (nil)
+[role, role ? (role_name) : (nil)]
+
+ end
+   
+def self_method_role_method_call?(method_name)
+    return [nil, nil] unless method
+role, role_name = self_method_get_role_definition
+is_role_method = (role and role.has_key?(method_name))
+return [role_name, is_role_method]
+
+ end
+
+    
+      end

data/lib/MethodDefinition.rb

@@ -0,0 +1,114 @@
+class MethodDefinition
+       
+def rebind()
+    @exp, @expressions = expressions.pop
+@block, @potential_bind = nil
+if @exp and (@exp.instance_of?(Sexp) and (@exp[0] == :iter)) then
+  @exp[(1..-1)].each do |expr|
+    if expr and (expr.length and (expr[0] == :block)) then
+      @block, @potential_bind = expr, expr[1]
+    end
+  end
+end
+@expressions = @exp.instance_of?(Sexp) ? (@expressions.push_array(exp)) : (@expressions)
+
+ end
+ 
+def transform()
+    until self_expressions_empty? do
+  (self_block_transform
+  if exp and exp.instance_of?(Sexp) then
+    is_indexer = ((exp[0] == :call) and ((exp[1] == nil) and ((exp[2] == :[]) or (exp[2] == :[]=))))
+    if (is_indexer or (exp[0] == :self)) and @interpretation_context.defining_role then
+      Self.new(exp, interpretation_context).execute
+    end
+    if (exp[0] == :call) then
+      MethodCall.new(exp, interpretation_context).rewrite_call?
+    end
+  end
+  rebind)
+end
+ end
+ 
+def initialize(exp,interpretationcontext)
+    no_exp = "No expression supplied".to_sym
+no_ctx = "No interpretation context".to_sym
+raise(no_exp) unless exp
+raise(no_ctx) unless interpretationcontext
+@interpretation_context = interpretationcontext
+@expressions = ImmutableQueue.empty.push(exp)
+rebind
+
+ end
+
+         def self.call(*args)
+             arity = MethodDefinition.method(:new).arity
+             newArgs = args[0..arity-1]
+             obj = MethodDefinition.new *newArgs
+             if arity < args.length
+                 methodArgs = args[arity..-1]
+                 obj.transform *methodArgs
+             else
+                obj.transform
+             end
+         end
+         
+      def call(*args);transform *args; end
+
+ private
+attr_reader :interpretation_context
+      attr_reader :exp
+      attr_reader :expressions
+      attr_reader :potential_bind
+      attr_reader :block
+      
+       
+def self_interpretation_context_addalias(key,value)
+    @interpretation_context.role_aliases[key] = value
+ end
+   
+def self_expressions_empty?()
+    (expressions == ImmutableQueue.empty)
+ end
+   
+def self_potential_bind_is_bind?()
+    potential_bind and (potential_bind.length and ((potential_bind[0] == :call) and ((potential_bind[1] == nil) and (potential_bind[2] == :bind))))
+ end
+   
+def self_block_transform()
+    if block then
+  @expressions.push_array(block[(1..-1)]) if self_block_transform_bind?
+end
+ end
+   
+def self_block_transform_bind?()
+    self_potential_bind_is_bind? and self_block_rewrite
+ end
+   
+def self_block_rewrite()
+    changed = false
+arguments = potential_bind[3]
+if arguments and (arguments[0] == :hash) then
+  block.delete_at(1)
+  count = ((arguments.length - 1) / 2)
+  (1..count).each do |j|
+    temp = (j * 2)
+    local = arguments[(temp - 1)][1]
+    local = local[1] if local.instance_of?(Sexp)
+    raise("invalid value for role alias") unless local.instance_of?(Symbol)
+    aliased_role = arguments[temp][1]
+    aliased_role = aliased_role[1] if aliased_role.instance_of?(Sexp)
+    unless aliased_role.instance_of?(Symbol) and interpretation_context.roles.has_key?(aliased_role) then
+      raise(((aliased_role.to_s + "used in binding is an unknown role ") + roles.to_s))
+    end
+    self_interpretation_context_addalias(local, aliased_role)
+    Bind.new(local, aliased_role, block).execute
+    changed = true
+  end
+end
+changed
+
+ end
+
+    
+      end

data/lib/MethodInfo.rb

@@ -0,0 +1,78 @@
+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
+
+ end
+ 
+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
+
+ 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]
+  end
+end
+args
+
+ end
+   
+def self_block_source_arguments()
+    args = self_block_source_get_arguments
+args and args.length ? (args.join(",")) : (nil)
+
+ end
+   
+def self_block_source_body()
+    block_source[3]
+ end
+
+    
+      end

data/lib/Self.rb

@@ -0,0 +1,71 @@
+class Self
+       
+def initialize(abstract_syntax_tree,interpretationcontext)
+    raise("Interpretation context missing") unless interpretationcontext
+unless interpretationcontext.defining_role then
+  raise("Must have a defining role")
+end
+@abstract_syntax_tree = abstract_syntax_tree
+@interpretation_context = interpretationcontext
+
+ end
+ 
+def execute()
+    if abstract_syntax_tree then
+  if (abstract_syntax_tree[0] == :self) then
+    abstract_syntax_tree[0] = :call
+    abstract_syntax_tree[1] = nil
+    abstract_syntax_tree[2] = interpretation_context.defining_role
+  else
+    if (abstract_syntax_tree[0] == :call) and (abstract_syntax_tree[1] == nil) then
+      method_name = abstract_syntax_tree[2]
+      if ((method_name == :[]) or (method_name == :[]=)) then
+        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
+    else
+      if abstract_syntax_tree.instance_of?(Sexp) then
+        if self_abstract_syntax_tree_is_indexer_call_on_self then
+          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
+ end
+
+         def self.call(*args)
+             arity = Self.method(:new).arity
+             newArgs = args[0..arity-1]
+             obj = Self.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 :abstract_syntax_tree
+      attr_reader :interpretation_context
+      
+       
+def self_abstract_syntax_tree_is_indexer_call_on_self()
+    (abstract_syntax_tree.length == 4) and ((abstract_syntax_tree[0] == :call) and ((abstract_syntax_tree[1] == nil) and ((abstract_syntax_tree[2] == :[]) and (abstract_syntax_tree[3][0] == :argslist))))
+ end
+
+    
+      end

data/lib/build.rb

@@ -0,0 +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'
+

data/lib/interpretation_context.rb

@@ -0,0 +1,30 @@
+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/maroon/contracts.rb

@@ -0,0 +1,43 @@
+if Kernel::const_defined? :MiniTest
+  class ContextAsserterBase < MiniTest::Unit::TestCase
+
+  end
+else
+  class ContextAsserterBase
+
+  end
+end
+
+class ContextAsserter < ContextAsserterBase
+  def initialize(contracts, obj, is_asserting = true)
+    raise 'Contracts must be supplied' unless contracts
+    @obj = obj
+    @contracts = contracts
+    @is_asserting = is_asserting
+  end
+
+  def is_test
+    Kernel::const_defined? :MiniTest
+  end
+
+  def can_play(role)
+    msg = "#{@is_asserting ? 'Was' : "wasn't"} expected to be able to play #{role}".intern
+    if is_test
+      assert_equal(@is_asserting, can_play?(role), msg)
+    else
+      raise msg if @is_asserting != can_play?(role)
+    end
+
+  end
+
+  private
+  def can_play?(role)
+    required_methods = @contracts[role]
+    methods = @obj.public_methods
+    missing = required_methods.select do |rm|
+      !methods.include? rm.to_sym
+    end
+    missing.length == 0
+  end
+end
+Context::with_contracts = true