maroon 0.6.5 → 0.7.0

data/base/bind_rewriter.rb

@@ -1,58 +0,0 @@
-context :Bind, :execute do
-  role :block do
-  end
-  role :local do
-  end
-  role :aliased_role do
-  end
-  initialize do |local, aliased_role, block|
-    @local = local
-    @aliased_role = aliased_role
-    @block = block
-  end
-  ##
-  #removes call to bind in a block
-  #and replaces it with assignment to the proper role player local variables
-  #in the end of the block the local variables have their original values reassigned
-  execute do
-    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
-    # assigning role player to role field
-    #notice that this will be executed after the next block
-    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
-
-    # assign role player to temp
-    # notice this is prepended Ie. inserted in front of the role player to role field
-
-    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
-
-    # reassign original player
-    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
-end

data/base/method_call.rb

@@ -1,78 +0,0 @@
-require_relative '../lib/maroon/kernel'
-context :MethodCall, :rewrite_call? do
-  role :interpretation_context do
-    contracts {
-      @interpretation_context.contracts || {}
-    }
-    roles {
-      @interpretation_context.roles || {}
-    }
-    role_aliases {
-      @interpretation_context.role_aliases || {}
-    }
-  end
-
-  role :method do
-    call_in_block? {
-      @in_block unless @in_block == nil
-      (@in_block = (method && method[0] == :lvar))
-    }
-
-    get_role_definition {
-      is_call_expression = method && method[0] == :call
-      self_is_instance_expression = (is_call_expression && !method[1])
-      role_name = nil
-      role_name = method[2] if self_is_instance_expression
-      if (not self_is_instance_expression) and method[1]
-        role_name = method[1][2] if method[1][1] == nil and method[1][0] == :call #call role field is instance
-        role_name = interpretation_context.role_aliases[method[1][1]] if method[1][0] == :lvar #local var potentially bound
-      end
-      role = role_name ? interpretation_context.roles[role_name] : nil
-      [role, (role ? role_name : nil)]
-    }
-
-    role_method_call? { |method_name|
-
-      return nil, nil unless method
-
-      role, role_name = method.get_role_definition #is it a call to a role getter
-
-      #in_block = method.call_in_block?
-      #role_name = interpretation_context.role_aliases[role_name] if in_block
-      is_role_method = role && role.has_key?(method_name)
-
-      return role_name, is_role_method
-    }
-  end
-
-  rewrite_call? do
-    method_name = method[2]
-    if method[0] == :call
-      if method[1] == nil && method.length < 5 && method[3] && method[3].length == 1 && method[3][0] == :arglist
-        #accessing a role field?
-        is_role = interpretation_context.roles.has_key? method[3]
-        method[3] = ':@' + method[3].to_sym if is_role
-      else
-        role_name, is_role_method = method.role_method_call? method_name
-        if is_role_method #role_name only returned if it's a role method call
-          method[1] = nil #remove call to attribute
-          method[2] = ('self_' + role_name.to_s + '_' + method_name.to_s).to_sym
-        else # it's an instance method invocation
-          if interpretation_context.roles.has_key? role_name
-            unless method.length == 3 && method[1] == nil && method[2] == role_name
-              contract_methods = (interpretation_context.contracts[role_name] ||= {})
-              contract_methods[method_name] ||= 0
-              contract_methods[method_name] += 1
-            end
-          end
-        end
-      end
-    end
-  end
-  initialize do |method, interpretation_context|
-    raise 'No method supplied' unless method
-
-    @method = method
-    @interpretation_context = interpretation_context
-  end
-end

data/base/self.rb

@@ -1,60 +0,0 @@
-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/lib/Bind.rb

@@ -1,65 +0,0 @@
-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/MethodCall.rb

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

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