maroon 0.5.2

data/Examples/Dijkstra/dijkstra.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+require '../../Lib/maroon.rb'
+require './data.rb'
+require './CalculateShortestDistance.rb'
+require './Calculate_Shortest_Path.rb'
+#!/usr/bin/env ruby
+# Example in Ruby -- Dijkstra's algorithm in DCI
+#    Modified and simplified for a Manhattan geometry with 8 roles
+#
+#
+#
+# Demonstrates an example where:
+#
+#    - objects of class Node play several roles simultaneously
+#      (albeit spread across Contexts: a Node can
+#      play the CurrentIntersection in one Context and an Eastern or
+#      Southern Neighbor in another)
+#    - stacked Contexts (to implement recursion)
+#     - mixed access of objects of Node through different
+#      paths of role elaboration (the root is just a node,
+#      whereas others play roles)
+#    - there is a significant pre-existing data structure called
+#      a Geometry (plays the Map role) which contains the objects
+#      of instance. Where DCI comes in is to ascribe roles to those
+#      objects and let them interact with each other to evaluate the
+#      minimal path through the network
+#    - true to core DCI we are almost always concerned about
+#      what happens between the objects (paths and distance)
+#      rather than in the objects themselves (which have
+#      relatively uninteresting properties like "name")
+#    - equality of nodes is not identity, and several
+#      nodes compare equal with each other by standard
+#      equality (eql?)
+#    - returns references to the original data objects
+#      in a vector, to describe the resulting path
+#
+# There are some curiosities
+#
+#    - east_neighbor and south_neighbor were typographically equivalent,
+#      so I folded them into a single role: Neighbor. That type still
+#      serves the two original roles
+#    - Roles are truly scoped to the use case context
+#    - The Map and Distance_labeled_graph_node roles have to be
+#      duplicated in two Contexts. blah blah blah
+#    - Node inheritance is replaced by injecting two roles
+#       into the object
+#    - Injecting roles no longer adds new fields to existing
+#       data objects.
+#    - There is an intentional call to distance_between while the
+#       Context is still extant, but outside the scope of the
+#       Context itself. Should that be legal?
+#    - I have added a tentative_distance_values array to the Context
+#       to support the algorithm. Its data are shared across the
+#       roles of the CalculateShortestPath Context
+#    - nearest_unvisited_node_to_target is now a feature of Map,
+#       which seems to reflect better coupling than in the old
+#       design
+
+
+
+# --- Main Program: test driver
+#
+geometries = Geometry_1.new
+path = CalculateShortestPath.new(geometries.root, geometries.destination, geometries)
+print 'Path is: '
+path.each { |node| print "#{node.name} " }
+print "\n"
+puts "distance is #{CalculateShortestDistance.new(geometries.root, geometries).distance}"
+
+puts ''
+
+geometries = ManhattanGeometry2.new
+path = CalculateShortestPath.new(geometries.root, geometries.destination, geometries)
+print 'Path is: '
+last_node = nil
+path.each do |node|
+  if last_node != nil; print " - #{geometries.distances[Edge.new(node, last_node)]} - " end
+  print "#{node.name}"
+  last_node = node
+end
+print "\n"
+
+geometries = ManhattanGeometry2.new
+puts "distance is #{CalculateShortestDistance.new(geometries.root,  geometries).distance }"

data/Examples/MoneyTransfer.rb

@@ -0,0 +1,61 @@
+require '../lib/maroon.rb'
+
+Context::define :MoneyTransfer do
+  role :source do
+    withdraw do |amount|
+      source.movement(amount)
+      source.log "withdrawal #{amount}"
+    end
+    log do |message|
+      p "#{@source} source #{message}"
+    end
+  end
+
+  role :destination do
+    deposit do |amount|
+      @destination.movement(amount)
+      @destination.log "deposit #{amount}"
+    end
+    logger do |message|
+      p "#{@source} destination #{message}"
+    end
+  end
+
+  role :amount do end
+
+  transfer do
+    source.withdraw -amount
+    destination.deposit amount
+  end
+end
+
+class MoneyTransfer
+  def initialize(source, destination, amount)
+    @source = source
+    @destination = destination
+    @amount  = amount
+  end
+end
+class Account
+  def initialize (amount, id)
+    @balance = amount
+    @account_id = id
+  end
+
+  def movement(amount)
+    log "Amount #{amount}"
+    @balance+=amount
+  end
+
+  def log(message)
+    (p s = "instance #{message}")
+  end
+
+  def to_s
+    "balance of #{@account_id}: #{@balance}"
+  end
+end
+
+account = Account.new 1000, "source"
+ctx = MoneyTransfer.new account, account, 100
+ctx.transfer

data/Examples/greeter.rb

@@ -0,0 +1,45 @@
+#Thanks to Ted Milken for updating the original example
+
+require '../lib/maroon.rb'
+require '../lib/Moby/kernel.rb'
+
+class Person
+  attr_accessor :name
+  attr_accessor :greeting
+end
+
+context :Greet_Someone, :greet do
+  role :greeter do
+    welcome do
+      self.greeting
+    end
+  end
+
+  role :greeted do
+  end
+
+  greet do
+    puts "#{greeter.name}: \"#{greeter.welcome}, #{greeted.name}!\""
+  end
+end
+
+class Greet_Someone
+  def initialize(greeter, greeted)
+    @greeter = greeter
+    @greeted = greeted
+  end
+end
+
+p1 = Person.new
+p1.name = 'Bob'
+p1.greeting = 'Hello'
+
+p2 = Person.new
+p2.name = 'World!'
+p2.greeting = 'Greetings'
+
+#Execute is automagically created for the default interaction (specified by the second argument in context :Greet_Someone, :greet do)
+#Executes construc a context object and calls the default interaction on this object
+Greet_Someone.execute p1, p2
+#constructs a Greet_Someone context object and executes greet.
+Greet_Someone.new(p2, p1).greet

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in maroon.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Maroon
+
+A module to make pure DCI available in Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'maroon'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install maroon
+
+## Usage
+
+See the examples for detailed information on how to use maroon.
+
+Essentially you can define a context by using
+
+Context::define :context_name do
+   role :role_name do
+      print_self do |x| #notice no symbol
+         p "#{role_name} #use role_name to refer to the role of said name
+      end
+   end
+end
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/maroon.rb

@@ -0,0 +1,363 @@
+# -*- encoding: utf-8 -*-
+require 'live_ast'
+require 'live_ast/to_ruby'
+
+##
+# 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
+##
+class Context
+  @roles
+  @interactions
+  @defining_role
+  @role_alias
+  @alias_list
+  @cached_roles_and_alias_list
+
+  #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
+  def self.define(*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
+    base_class,default_interaction = default_interaction, base_class if base_class and !default_interaction and base_class.instance_of? Symbol
+    ctx = Context.new
+    ctx.instance_eval &block
+    return ctx.send(:finalize, name,base_class,default_interaction)
+  end
+
+  private
+  ##
+  #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
+  ##
+  def role(role_name)
+    raise 'Argument role_name must be a symbol' unless role_name.instance_of? Symbol
+
+    @defining_role = role_name
+    @roles[role_name] = Hash.new
+    yield if block_given?
+    @defining_role = nil
+  end
+
+  def initialize
+    @roles = Hash.new
+    @interactions = Hash.new
+    @role_alias = Array.new
+  end
+
+  def role_aliases
+    @alias_list if @alias_list
+    @alias_list = Hash.new
+    @role_alias.each {|aliases|
+      aliases.each {|k,v|
+        @alias_list[k] = v
+      }
+    }
+    @alias_list
+  end
+
+  def roles
+    @cached_roles_and_alias_list if @cached_roles_and_alias_list
+    @roles unless @role_alias and @role_alias.length
+    @cached_roles_and_alias_list = Hash.new
+    @roles.each {|k,v|
+       @cached_roles_and_alias_list[k] = v
+    }
+    role_aliases.each {|k,v|
+      @cached_roles_and_alias_list[k] = @roles[v]
+    }
+    @cached_roles_and_alias_list
+  end
+
+  def methods
+    (@defining_role ? @roles[@defining_role] : @interactions)
+  end
+
+  def add_alias (a,role_name)
+    @cached_roles_and_alias_list,@alias_list = nil
+    @role_alias.last()[a] = role_name
+  end
+
+  def finalize(name, base_class, default)
+    c = base_class ? (Class.new base_class) : Class.new
+    Kernel.const_set name, c
+    code = ''
+    fields = ''
+    getters = ''
+    impl = ''
+    interactions = ''
+    @interactions.each do |method_name, method_source|
+      @defining_role = nil
+      interactions << "  #{lambda2method(method_name, method_source)}"
+    end
+    if default
+      interactions <<"\ndef self.execute(*args);#{name}.new(*args).#{default}; end\n"
+    end
+
+    @roles.each do |role, methods|
+        fields << "@#{role}\n"
+        getters << "def #{role};@#{role} end\n"
+
+        methods.each do |method_name, method_source|
+          @defining_role = role
+          rewritten_method_name = "self_#{role}_#{method_name}"
+          definition = lambda2method rewritten_method_name, method_source
+          impl << "  #{definition}" if definition
+        end
+    end
+
+    code << "#{interactions}\n#{fields}\n  private\n#{getters}\n#{impl}\n"
+
+    complete = "class #{name}\r\n#{code}\r\nend"
+    return c.class_eval(code),complete
+  end
+
+  def role_or_interaction_method(method_name,*args, &b)
+    raise "method with out block #{method_name}" unless b
+
+    args, block = block2source b.to_ruby, method_name
+    args = "|#{args}|" if args
+    source = "(proc do #{args}\n #{block}\nend)"
+    methods[method_name] = source
+  end
+
+  alias method_missing role_or_interaction_method
+
+  def role_method_call(ast, method)
+    is_call_expression = ast && ast[0] == :call
+    self_is_instance_expression = is_call_expression && (!ast[1]) #implicit self
+    is_in_block = ast && ast[0] == :lvar
+    role_name_index = self_is_instance_expression ? 2 : 1
+    role = (self_is_instance_expression || is_in_block) ? roles[ast[role_name_index]] : nil #is it a call to a role getter
+    is_role_method = role && role.has_key?(method)
+    role_name = is_in_block ? role_aliases[ast[1]] : (ast[2] if self_is_instance_expression)
+    role_name if is_role_method #return role name
+  end
+
+  def lambda2method (method_name, method_source)
+    evaluated = ast_eval method_source, binding
+    ast = evaluated.to_ast
+    transform_ast ast
+    args, block = block2source LiveAST.parser::Unparser.unparse(ast), method_name
+    args = "(#{args})" if args
+    "\ndef #{method_name} #{args}\n#{block} end\n"
+  end
+
+  ##
+  #Test if there's a block that needs to potentially be transformed
+  ##
+  def transform_block(exp)
+       if exp && exp[0] == :iter
+           (exp.length-1).times do |i|
+             expr = exp[i+1]
+             #find the block
+             if expr  && expr.length && expr[0] == :block
+               transform_ast exp if rewrite_bind? expr,expr[1]
+             end
+           end
+       end
+  end
+
+  ##
+  #Calls rewrite_block if needed and will return true if the AST was changed otherwise false
+  ##
+  def rewrite_bind?(block, expr)
+    #check if the first call is a bind call
+    if expr && expr.length && (expr[0] == :call && expr[1] == nil && expr[2] == :bind)
+      arglist = expr[3]
+      if arglist && arglist[0] == :arglist
+        arguments = arglist[1]
+        if arguments && arguments[0] == :hash
+          block.delete_at 1
+          count = (arguments.length-1) / 2
+          (1..count).each do |j|
+            temp = j * 2
+            local = arguments[temp-1][1]
+            if local.instance_of? Sexp
+              local = local[1]
+            end
+            raise 'invalid value for role alias' unless local.instance_of? Symbol
+            #find the name of the role being bound to
+            aliased_role = arguments[temp][1]
+            if aliased_role.instance_of? Sexp
+              aliased_role = aliased_role[1]
+            end
+            raise "#{aliased_role} used in binding is an unknown role #{roles}" unless aliased_role.instance_of? Symbol and @roles.has_key? aliased_role
+            add_alias local, aliased_role
+            #replace bind call with assignment of iteration variable to role field
+            rewrite_bind(aliased_role, local, block)
+            return true
+          end
+        end
+      end
+    end
+    false
+  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
+  def rewrite_bind(aliased_role, local, block)
+    raise 'aliased_role must be a Symbol' unless aliased_role.instance_of? Symbol
+    raise 'local must be a Symbol' unless local.instance_of? Symbol
+    assignment = Sexp.new
+    assignment[0] = :iasgn
+    assignment[1] = aliased_role
+    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
+    temp_symbol = "temp____#{aliased_role}".to_sym
+    assignment = Sexp.new
+    assignment[0] = :lasgn
+    assignment[1] = temp_symbol
+    load_field = Sexp.new
+    load_field[0] = :ivar
+    load_field[1] = aliased_role
+    assignment[2] = load_field
+    block.insert 1, assignment
+
+    # reassign original player
+    assignment = Sexp.new
+    assignment[0] = :iasgn
+    assignment[1] = aliased_role
+    load_temp = Sexp.new
+    load_temp[0] = :lvar
+    load_temp[1] = temp_symbol
+    assignment[2] = load_temp
+    block[block.length] = assignment
+  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
+  def rewrite_self (ast)
+    ast.length.times do |i|
+      raise 'Invalid argument. must be an expression' unless ast.instance_of? Sexp
+      exp = ast[i]
+      if exp == :self
+        ast[0] = :call
+        ast[1] = nil
+        ast[2] = @defining_role
+        arglist = Sexp.new
+        ast[3] = arglist
+        arglist[0] = :arglist
+      elsif exp.instance_of? Sexp
+        rewrite_self exp
+      end
+    end
+  end
+
+  #rewrites the ast so that role method calls are rewritten to a method invocation on the context object rather than the role player
+  #also does rewriting of binds in blocks
+  def transform_ast(ast)
+    if ast
+      if @defining_role
+        rewrite_self ast
+      end
+      ast.length.times do |k|
+        exp = ast[k]
+        if exp
+          method_name = exp[2]
+          role = role_method_call exp[1], exp[2]
+          if exp[0] == :iter
+            @role_alias.push Hash.new
+            transform_block exp
+            @role_alias.pop()
+          end
+          if exp[0] == :call && role
+            exp[1] = nil #remove call to attribute
+            exp[2] = "self_#{role}_#{method_name}".to_sym
+          end
+          if exp.instance_of? Sexp
+            transform_ast exp
+          end
+        end
+      end
+    end
+  end
+
+  #cleans up the string for further processing and separates arguments from body
+  def block2source(b, method_name)
+    args = nil
+    block = b.strip
+    block = block[method_name.length..-1].strip if block.start_with? method_name.to_s
+    block = cleanup_head_and_tail(block)
+    if block.start_with? '|'
+      args = block.scan(/\|([\w\d,\s]*)\|/)
+      if args.length && args[0]
+        args = args[0][0]
+      else
+        args = nil
+      end
+      block = block[(2 + (block[1..-1].index '|'))..-1].strip
+    end
+    return args, block
+  end
+
+  # removes proc do/{ at start and } or end at the end of the string
+  def cleanup_head_and_tail(block)
+    if /^proc\s/.match(block)
+      block = block['proc'.length..-1].strip
+    end
+    if /^do\s/.match(block)
+      block = block[2..-1].strip
+    elsif block.start_with? '{'
+      block = block[1..-1].strip
+    end
+
+    if /end$/.match(block)
+      block = block[0..-4]
+    elsif /\}$/.match(block)
+      block = block[0..-2]
+    end
+    block
+  end
+end