maroon 0.6.1 → 0.6.5

data/base/bind_rewriter.rb

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

@@ -0,0 +1,50 @@
+context :ImmutableQueue do
+  role :front do
+  end
+  role :back do
+  end
+  push do |element|
+    b = back || ImmutableStack::empty
+    ImmutableQueue.new(front, b.push(element))
+  end
+
+  pop do
+    f, b = front, back
+    if f == ImmutableStack::empty
+      #reverse the back stack to be able to pop from the front in correct order
+      until b == ImmutableStack::empty
+        e, b = b.pop
+        f = f.push(e)
+      end
+    end
+    head, f = f.pop
+    if f == b #can only happen if they are both ImmutableStack::empty
+      [head, ImmutableQueue::empty]
+    else
+      [head, ImmutableQueue.new(f, b)]
+    end
+  end
+
+  empty true do
+    @@empty ||= ImmutableQueue.new(ImmutableStack::empty, ImmutableStack::empty)
+  end
+
+  push_array do |arr|
+    q = self
+    if arr
+      arr.each do |i|
+        q = q.push i
+      end
+    end
+    q
+  end
+
+  private
+
+  initialize do |front, back|
+    @front = front || ImmutableStack::empty
+    @back = back || ImmutableStack::empty
+    self.freeze
+  end
+
+end

data/base/maroon_base.rb

@@ -0,0 +1,267 @@
+# -*- encoding: utf-8 -*-
+
+##
+# The Context class is used to define a DCI context with roles and their role methods
+# to define a context call define with the name of the context (this name will become the name of the class that defines the context)
+# the name should be a symbol and since it's going to be used as a class name, use class naming conventions
+# follow the name with a block. With in this block you can define roles and interactions
+# and interaction is defined by write the name of the interaction (hello in the below example) followed by a block
+# the block will become the method body
+# a role can be defined much like a context. instead of calling the define method call the role method followed by the role name (as a symbol)
+# the role will be used for a private instance variable and the naming convention should match this
+# With in the block supplied to the role method you can define role methods the same way as you define interactions. See the method who
+# in the below example
+# = Example
+#    Context::define :Greeter do
+#        role :who do
+#          say do
+#            @who #could be self as well to refer to the current role player of the 'who' role
+#          end
+#        end
+#      greeting do
+#        p "Hello #{who.say}!"
+#      end
+#    end
+#
+#    class Greeter
+#      def initialize(player)
+#         #@who = player
+#      end
+#    end
+#
+#    Greeter.new('world').greeting #Will print "Hello world!"
+#maroon is base on Marvin which was the first injectionless language for DCI
+#being injectionless there's no runtime extend or anything else impacting the performance. There' only regular method invocation even when using role methods
+#Author:: Rune Funch Søltoft (funchsoltoft@gmail.com)
+#License:: Same as for Ruby
+##
+Context::generate_files_in 'generated'
+context :Context do
+  role :roles do
+  end
+  role :interactions do
+  end
+  role :defining_role do
+  end
+  role :role_alias do
+  end
+  role :alias_list do
+  end
+  role :cached_roles_and_alias_list do
+  end
+
+  #define is the only exposed method and can be used to define a context (class)
+  #if maroon/kernel is required calling context of Context::define are equivalent
+  #params
+  #name:: the name of the context. Since this is used as the name of a class, class naming convetions should be used
+  #block:: the body of the context. Can include definitions of roles (through the role method) or definitions of interactions
+  #by simply calling a method with the name of the interaction and passing a block as the body of the interaction
+  define :block => :block, :self => self do |*args|
+    @@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)
+    ctx.generate_files_in(args.last()) if args.last().instance_of? FalseClass or args.last().instance_of? TrueClass
+    return ctx.send(:finalize, name, base_class, default_interaction)
+  end
+
+  generate_files_in :block => :b,:self => self do |*args|
+    return role_or_interaction_method(:generate_files_in, *args, &b) if block_given?
+
+    @@generate_file_path = args[0]
+  end
+
+  private
+  with_contracts self do |*args|
+    return @@with_contracts if args.length == 0
+    value = args[0]
+    raise 'make up your mind! disabling contracts during execution will result in undefined behavior' if @@with_contracts && !value
+    @@with_contracts = value
+  end
+
+  ##
+  #Defines a role with the given name
+  #role methods can be defined inside a block passed to this method
+  # = Example
+  #       role :who do
+  #          say do
+  #            p @who
+  #          end
+  #       end
+  #The above code defines a role called 'who' with a role method called say
+  ##
+  role :block => :b do |*args|
+    role_name = args[0]
+    return role_or_interaction_method(:role, *args, &b) if args.length != 1 or not (role_name.instance_of? Symbol)
+
+    @defining_role = role_name
+    @roles[role_name] = Hash.new
+    yield if block_given?
+    @defining_role = nil
+  end
+
+  initialize :block => :b do |*args|
+    if block_given?
+      role_or_interaction_method(:initialize, *args, &b)
+    else
+      @roles = Hash.new
+      @interactions = Hash.new
+      @role_alias = Hash.new
+      @contracts = Hash.new
+    end
+  end
+
+  role_or_interaction_method(:private)  do
+    @private = true
+  end
+
+  current_interpretation_context :block => :b do |*args|
+    return role_or_interaction_method(:current_interpretation_context, *args, &b) if block_given?
+    InterpretationContext.new(roles, contracts, role_alias, nil)
+  end
+
+  get_methods :block => :b do |*args|
+    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 && !sources
+      @roles[@defining_role][name] = []
+    else
+      (@interactions)[name] = []
+    end
+  end
+
+  role :contracts do
+  end
+
+  add_method :block => :b do |*args|
+    return role_or_interaction_method(:add_method, *args, &b) if block_given?
+    name, method = *args
+    sources = get_methods(name)
+    sources << method
+  end
+
+  finalize :block => :b do |*args|
+    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
+      name = name.to_s
+      complete = 'class ' + name + (base_class ? '<< ' + base_class.name : '') + '
+      ' + code.to_s + '
+      end'
+      File.open('./' + @@generate_file_path.to_s + '/' + name + '.rb', 'w') { |f| f.write(complete) }
+      complete
+    else
+
+      c = base_class ? (Class.new base_class) : Class.new
+      if @@with_contracts
+        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)
+          raise \'Contracts must be supplied\' unless value
+          @@contracts = value
+        end')
+        c.contracts=contracts
+      end
+      Kernel.const_set name, c
+      temp = c.class_eval(code)
+      (temp || c)
+    end
+  end
+
+  create_context_factory self do |args, block|
+    name, base_class, default_interaction = *args
+    #if there's two arguments and the second is not a class it must be an interaction
+    if default_interaction && (!base_class.instance_of? Class) then
+      base_class = eval(base_class.to_s)
+    end
+    base_class, default_interaction = default_interaction, base_class if base_class and !default_interaction and !base_class.instance_of? Class
+    ctx = Context.new
+    ctx.instance_eval &block
+    return base_class, ctx, default_interaction, name
+  end
+
+  generate_context_code :block => :b do |*args|
+    return role_or_interaction_method(:generate_context_code, *args, &b) if block_given?
+    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)
+        if method.is_private
+          getters << code
+        else
+          interactions << code
+        end
+      end
+    end
+
+    if default
+      interactions << '
+         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
+         '
+      interactions << '
+      def call(*args);' + default.to_s + ' *args; end
+'
+    end
+
+    @roles.each do |role, methods|
+      getters << 'attr_reader :' + role.to_s + '
+      '
+
+      methods.each do |method_name, method_sources|
+        raise 'Duplicate definition of ' + method_name.to_s unless method_sources.length < 2
+        raise 'No source for ' + method_name.to_s unless method_sources.length > 0
+
+        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 + '
+ private
+' + getters + '
+    ' + impl + '
+    '
+  end
+
+  role_or_interaction_method({:block => :b}) do |*arguments|
+    method_name, on_self = *arguments
+    unless method_name.instance_of? Symbol
+      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
+end

data/base/method_call.rb

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