maroon 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8869041ee066afcbfc382e5679bdacbfef33401d
-  data.tar.gz: 30910b3f6b2a216c99bc8b204d52fe6b735a7c01
+  metadata.gz: f663cc4db7c5aafc0525f99404cdeb2afe53f17b
+  data.tar.gz: b52e10404b2bcaafcc8fea74744d134235901aef
 SHA512:
-  metadata.gz: 91a7a468e03ddb94d1549f138d52df08cf819bd85d4942064d867e0bcf6540911fc2882d33b3a33f92188479af5404deed83d730785db4466e52ac87cba895f4
-  data.tar.gz: ad2cc204002f1f19c07cfb8f596648bb78dd2541d4de4c27565e48e355a1aa476d0a3c16fcffe26647921a31356a546552d6967e308a723a39bc6984017c109a
+  metadata.gz: 0d01a342d33a30bea615cc7584868963db58b5637f7adbb82168dd0bcbaa5d7c67f335b1e9f6822215d20a82a61234978e3a9572b58784adf9f1a253c48cdfa9
+  data.tar.gz: 84b7561a6183480bf571a5f7027be75cde74274c11752b9f9975fb418992b97f962ca288a730f591edba16f88ba744504dae2ff27f8f8cfb57559afad885ceb2

data/README.md

@@ -22,7 +22,7 @@ See the examples for detailed information on how to use maroon.
 
 Essentially you can define a context by using
 
-Context::define :context_name do
+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
@@ -34,7 +34,7 @@ end
 
 If you're using Bundler, run `bundle install` to setup your environment.
 
-Run `rake test` or just `rake` to make the tests run.
+Run `rake default` or just `rake` to make the tests run.
 
 
 ## Contributing
@@ -47,10 +47,30 @@ Run `rake test` or just `rake` to make the tests run.
 6. Push to the branch (`git push origin my-new-feature`)
 7. Create new Pull Request
 
+All changes should be done to the code in the base folder or the test folder.
+The code in the base folder is the implementation of maroon. When the default rake task is executed code will be generated
+in the 'generated' folder. The code in generated will be used when running the tests.
+If all tests pass
+1. Copy the generated files from 'generated' to 'lib'
+2. Rerun the the default rake task
+3. If all tests pass copy the generated file from 'generated' to 'lib'
+4. commit and create a pull request
+
+There's a rake task (build_lib) that will do the above if you are courageous enough to potentially loose your changes.
 
 Known bugs
-There are a few known bugs. The two major once are that #{...} syntax in strings can't beused. This is due to
-limitaion/bug in the current version of sourcify.
-If declaring several role methods for the same role sourcify might get confused and return the same sexp for
-multiple of them. The work around is to use do...end for the role ans {|| } for the role methods
+1. There are a few known bugs. The two major once are that double quotes can't be used. This is due to
+limitation/bug in the current version of sourcify.
+2. Using 'self' in a role method points to the context itself where it should be the role player
+
+
 
+Short description of the flow
+The class named Context (defined in maroon_base.rb) will read and parse the block passed to the Context.define method
+When the parsing is complete each method will be represented by an AST (using S-expressions). The transformer context
+will take over from this point. In time it runs through the definition of all roles (including there methods) and interactions.
+For each method it will use the AstRewritter context to rewrite the methods (e.g. call the correct method on the context
+object when a role method is called). The AstRewritter is build on another context namely the AbstractSyntaxTree that is used to represent
+and semantics to the abstract syntax tree (S-expressions) that represents each method.
+When all methods have been rewritten the transformer will either write the corresponding class definition to file (if so specified)
+or create a class in memory.

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList['test/alltests.rb']
   t.verbose = true
 end
 
@@ -12,8 +12,8 @@ task :generate do |t|
   require_relative './lib/Context'
   require_relative './lib/maroon/kernel'
   require_relative './lib/build' #use the one in lib. That should be the stable one
-  Context::generate_files_in(:generated) #generate files not just in memory classes
-  `git ls-files ./base/`.split($/).grep(%r{(.)*.rb}).select {|f|p f; require_relative("#{f}")}
+  Context::generate_files_in=:generated #generate files not just in memory classes
+  `git ls-files ./base/`.split($/).grep(%r{(.)*.rb}).select {|f| require_relative("#{f}")}
 end
 
 #execute as with command line to make memory spaces independent

data/Test/Context_test.rb

@@ -11,7 +11,7 @@ class ContextTest < Test::Unit::TestCase
     name = :MyContextRoleMethodCall
     role_name = :rol
 
-    c=Context::define name do
+    Context.define name do
       role role_name do
         def rolem(x, y)
           x+y
@@ -26,20 +26,20 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(7, MyContextRoleMethodCall.new.add(3, 4))
   end
 
-  def xtest_simple
+  def test_simple
     name = :MyContextSimple
     role_name = :r
-    Context::define name do
+    Context.define name do
       role role_name do
       end
     end
     assert(Kernel::const_defined? name)
   end
 
-  def xtest_bind
+  def test_bind
     name = :MyContextBind
 
-    c= Context::define name do
+    c= Context.define name do
       role :role_name do
         def sum
           @sum += role_name
@@ -58,10 +58,10 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(3, MyContextBind.new.inter)
   end
 
-  def xtest_role_method
+  def test_role_method
     name = :MyContext
     role_name = :rol
-    Context::define name do
+    Context.define name do
       role role_name do
         def rolem
           0+1
@@ -71,10 +71,10 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(1, MyContext.new.send(:self_rol_rolem))
   end
 
-  def xtest_role_method_args
+  def test_role_method_args
     name = :MyContextArgs
     role_name = :rol
-    Context::define name do
+    Context.define name do
       role role_name do
         def rolem(x, y)
           x+y
@@ -84,10 +84,10 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(7, MyContextArgs.new.send(:self_rol_rolem, 3, 4))
   end
 
-  def xtest_role_method_splat
+  def test_role_method_splat
     name = :MyContextSplat
     role_name = :rol
-    Context::define name do
+    Context.define name do
       role role_name do
         def rolem(x, *args)
           x+(args[0])
@@ -97,10 +97,10 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(7, MyContextSplat.new.send(:self_rol_rolem, 3, 4))
   end
 
-  def xtest_role_method_block
+  def test_role_method_block
     name = :MyContextBlock
     role_name = :rol
-    c= Context::define name do
+    c= Context.define name do
       role :num do
         def next
           num + 3
@@ -118,13 +118,13 @@ class ContextTest < Test::Unit::TestCase
         end
       end
     end
-    assert_equal(9, MyContextBlock.new.send(:self_rol_rolem, 3, 4) { |x, res| res + x })
+    assert_equal(13, MyContextBlock.new.send(:self_rol_rolem, 3, 4) { |x, res| res + x })
   end
 
-  def xtest_class_method_block
+  def test_class_method_block
     name = :MyContextClass
     role_name = :rol
-    Context::define name do
+    Context.define name do
       role :dummy do end
       role role_name do
         def rolem(*args, &b)

data/{Examples/Dijkstra → Test/Examples}/CalculateShortestDistance.rb

@@ -1,4 +1,5 @@
-Context::define :CalculateShortestDistance do
+
+context :CalculateShortestDistance do
 
   role :tentative_distance_values do
   end
@@ -12,40 +13,40 @@ Context::define :CalculateShortestDistance do
 
 
   role :map do
-    distance_between do |a, b|
+    def distance_between(a, b)
       map.distances[Edge.new(a, b)]
     end
 
     # These two functions presume always travelling
     # in a southern or easterly direction
-    next_down_the_street_from do |x|
+    def next_down_the_street_from(x)
       map.east_neighbor_of x
     end
 
-    next_along_the_avenue_from do |x|
+    def next_along_the_avenue_from(x)
       map.south_neighbor_of x
     end
   end
 
   role :current do
-    tentative_distance do
+    def tentative_distance
       tentative_distance_values[current]
     end
-    set_tentative_distance_to do |x|
+    def set_tentative_distance_to(x)
       tentative_distance_values[current] = x
     end
   end
 
 
-  rebind do |origin_node, geometries|
+  def rebind(origin_node, geometries)
     @current = origin_node
     @destination = geometries.destination
     @map = geometries
   end
 
-  distance do
-    current.set_tentative_distance_to 0
-    @path = CalculateShortestPath.new(current, destination, map).path
+  def distance
+    current.set_tentative_distance_to(0)
+    @path = CalculateShortestPath.new(current, destination, map,nil,nil,nil,nil).path
     retval = 0
     previous_node = nil
     path.reverse_each { |node|
@@ -59,9 +60,6 @@ Context::define :CalculateShortestDistance do
     retval
   end
 
-end
-
-class CalculateShortestDistance
   def initialize(origin_node, geometries)
     rebind(origin_node, geometries)
     @tentative_distance_values = Hash.new

data/Test/Examples/MoneyTransfer_test.rb

@@ -0,0 +1,76 @@
+require 'test/unit'
+require_relative '../test_helper'
+
+Context.define :MoneyTransfer do
+  def initialize(source, destination, amount)
+    @source = source
+    @destination = destination
+    @amount = amount
+    @log = []
+  end
+
+  role :source do
+    def withdraw(amount)
+      source.movement(amount)
+      source.log 'withdrawal ' + amount.to_s
+    end
+    def log(message)
+      @log << (@source.to_s + ' source ' + message)
+    end
+  end
+
+  role :destination do
+    def deposit(amount)
+      @destination.movement(amount)
+      @destination.log 'deposit ' + amount.to_s
+    end
+    def logger(message)
+      @log << @destination.to_s + ' destination ' + message
+    end
+  end
+
+  role :amount do
+  end
+
+  def transfer
+    source.withdraw -amount
+    destination.deposit amount
+  end
+end
+
+class Account
+  def initialize (amount, id)
+    @balance = amount
+    @account_id = id
+    @log = []
+  end
+
+  def movement(amount)
+    log "Amount #{amount}"
+    @balance+=amount
+  end
+
+  def log(message)
+      @log << message
+  end
+
+  def balance
+    @balance
+  end
+
+  def to_s
+    "balance of #{@account_id}: #{@balance}"
+  end
+end
+
+
+class MoneyTransferTest < Test::Unit::TestCase
+  def test_transfer
+    source = Account.new 1000, "source"
+    destination = Account.new 0, "destination"
+    ctx = MoneyTransfer.new source, destination, 100
+    ctx.transfer
+    assert_equal(900,source.balance)
+    assert_equal(100,destination.balance)
+  end
+end

data/{Examples/Dijkstra → Test/Examples}/calculate_shortest_path.rb

@@ -2,7 +2,7 @@
 #
 # Consider street corners on a Manhattan grid. We want to find the
 # minimal path from the most northeast city to the most
-# southeast city. Use Dijkstra's algorithm
+# southeast city. Use DijkstraTest's algorithm
 #
 
 
@@ -29,80 +29,91 @@
 #
 # The algorithm is straight from Wikipedia:
 #
-# http://en.wikipedia.org/wiki/Dijkstra's_algorithm
+# http://en.wikipedia.org/wiki/DijkstraTest's_algorithm
 #
 # and reads directly from the distance method, below
 
 
-# "Map" as in cartography rather than Computer Science...
+# Map as in cartography rather than Computer Science...
 #
 # Map is a DCI role. The role in this example is played by an
 # object representing a particular Manhattan geometry
-ctx, source = Context::define :CalculateShortestPath do
+#Context::generate_files_in('.')
+c = context :CalculateShortestPath do
+  # public initialize. It's overloaded so that the public version doesn't
+  # have to pass a lot of crap; the initialize method takes care of
+  # setting up internal data structures on the first invocation. On
+  # recursion we override the defaults
+
+  def initialize(origin_node, target_node, geometries,
+      path_vector, unvisited_hash, pathto_hash,
+      tentative_distance_values_hash)
+    @destination = target_node
+
+    rebind(origin_node, geometries)
+
+    execute(path_vector, unvisited_hash, pathto_hash, tentative_distance_values_hash)
+  end
+
+
   role :distance_labeled_graph_node do
     # Access to roles and other Context data
-    tentative_distance_values do
+    def tentative_distance_values
       tentative_distance_values
     end
     # Role Methods
-    tentative_distance do
+    def tentative_distance
       tentative_distance_values[@distance_labeled_graph_node]
     end
-    set_tentative_distance_to do |x|
+    def set_tentative_distance_to(x)
       tentative_distance_values[@distance_labeled_graph_node] = x
     end
   end
 
   # These are handles to to the roles
   role :map do
-    distance_between do |a, b|
-      dist = @map.distances[Edge.new(a, b)]
-      # p "distance between #{a.name} and #{b.name} is #{dist}"
-      dist
+    def distance_between(a, b)
+      @map.distances[Edge.new(a, b)]
     end
-    next_down_the_street_from do |x|
-      n = east_neighbor_of x
-      # p "next down the street from #{x.name} is #{n.name}"
-      n
+    def next_down_the_street_from(x)
+      east_neighbor_of x
     end
-    next_along_the_avenue_from do |x|
-      n = south_neighbor_of x
-      # p "next along the avenue from #{x.name} is #{n.name}"
-      n
+    def next_along_the_avenue_from(x)
+      south_neighbor_of x
     end
-    origin do
+    def origin
       map.root
     end
-    nearest_unvisited_node_to_target do
+    def nearest_unvisited_node_to_target
       min = infinity
       selection = nil
       @unvisited.each_key {
           |intersection|
         bind :intersection => :distance_labeled_graph_node
-        if @unvisited[intersection]
-          tentative_distance = intersection.tentative_distance
+        if @unvisited[distance_labeled_graph_node]
+          tentative_distance = distance_labeled_graph_node.tentative_distance
           if tentative_distance < min
-            # p "min distance is updated from #{min} to #{tentative_distance}"
+
             min = tentative_distance
-            selection = intersection
+            selection = distance_labeled_graph_node
           end
         end
       }
       selection
     end
-    unvisited do
+    def unvisited
       @unvisited
     end
   end
 
   role :current do
     # Access to roles and other Context data
-    unvisited do
+    def unvisited
       map.unvisited
     end
 
     # Role Methods
-    unvisited_neighbors do
+    def unvisited_neighbors
       retval = Array.new
       if @south_neighbor != nil
         if unvisited[@south_neighbor] then
@@ -114,11 +125,10 @@ ctx, source = Context::define :CalculateShortestPath do
           retval << @east_neighbor
         end
       end
-      # p "unvisited neighbors #{retval}"
+
       retval
     end
-    tentative_distance do
-      raise "key (#{current}) not found in #{@tentative_distance_values}" unless @tentative_distance_values && (@tentative_distance_values.has_key? current)
+    def tentative_distance
       @tentative_distance_values[current]
     end
   end
@@ -130,34 +140,32 @@ ctx, source = Context::define :CalculateShortestPath do
 # east_neighbor and south_neighbor roles
 
   role :neighbor_node do
-    relable_node_as do |x|
-      raise "Argument can't be nil" unless x
-      raise "self can't be nil" unless @neighbor_node
+    def relable_node_as(x)
+      raise 'Argument cannot be nil' unless x
+      raise 'self cannot be nil' unless @neighbor_node
 
       if x < neighbor_node.tentative_distance
-        # p "updated tentative distance from #{neighbor_node.tentative_distance} to #{x}"
         neighbor_node.set_tentative_distance_to x
         :distance_was_udated
       else
-        # p "left tentative distance at #{neighbor_node.tentative_distance} instead of #{x}"
         :distance_was_not_udated
       end
     end
 
     # Role Methods
-    tentative_distance do
-      raise "self can't be nil" unless @neighbor_node
+    def tentative_distance
+      raise 'self cannot be nil' unless @neighbor_node
       tentative_distance_values[@neighbor_node]
     end
-    set_tentative_distance_to do |x|
-      raise "Argument can't be nil" unless x
-      raise "self can't be nil" unless @neighbor_node
+    def set_tentative_distance_to(x)
+      raise 'Argument cannot be nil' unless x
+      raise 'self cannot be nil' unless @neighbor_node
       tentative_distance_values[@neighbor_node] = x
     end
   end
 # This is the method that starts the work. Called from initialize.
 
-  execute do |path_vector, unvisited_hash, pathto_hash, tentative_distance_values_hash|
+  def execute (path_vector, unvisited_hash, pathto_hash, tentative_distance_values_hash)
     do_inits(path_vector, unvisited_hash, pathto_hash,
              tentative_distance_values_hash)
 
@@ -165,21 +173,19 @@ ctx, source = Context::define :CalculateShortestPath do
     # Calculate tentative distances of unvisited neighbors
 
     unvisited_neighbors = current.unvisited_neighbors
-    # p "#{unvisited_neighbors}"
+
     if unvisited_neighbors != nil
       unvisited_neighbors.each {
           |neighbor|
         bind :neighbor => :neighbor_node
         tentative_distance = current.tentative_distance
-        raise "tentative distance can't be nil" if tentative_distance == nil
+        raise 'tentative distance cannot be nil' if tentative_distance == nil
         distance_between = map.distance_between(current, neighbor)
-        raise "distance between can't be nil" if distance_between == nil
+        raise 'distance between cannot be nil' if distance_between == nil
         net_distance = tentative_distance + distance_between
 
-        if neighbor.relable_node_as(net_distance) == :distance_was_udated
-          # p "set path"
+        if neighbor_node.relable_node_as(net_distance) == :distance_was_udated
           pathTo[neighbor] = @current
-          # p "path #{@pathTo}"
         end
       }
     end
@@ -200,7 +206,7 @@ ctx, source = Context::define :CalculateShortestPath do
     end
   end
 
-  do_inits do |path_vector, unvisited_hash, pathto_hash, tentative_distance_values_hash|
+  def do_inits(path_vector, unvisited_hash, pathto_hash, tentative_distance_values_hash)
 
     # The conditional switches between the first and subsequent instances of the
     # recursion (the algorithm is recursive in graph contexts)
@@ -213,8 +219,8 @@ ctx, source = Context::define :CalculateShortestPath do
           # Since path_vector isn't set up, this is the first iteration of the recursion
           @tentative_distance_values = Hash.new
 
-          # This is the fundamental data structure for Dijkstra's algorithm, called
-          # "Q" in the Wikipedia description. It is a boolean hash that maps a
+          # This is the fundamental data structure for DijkstraTest's algorithm, called
+          # Q in the Wikipedia description. It is a boolean hash that maps a
           # node onto false or true according to whether it has been visited
 
           @unvisited = Hash.new
@@ -222,13 +228,13 @@ ctx, source = Context::define :CalculateShortestPath do
           # These initializations are directly from the description of the algorithm
           map.nodes.each { |node| @unvisited[node] = true }
           @unvisited.delete(map.origin)
-          map.nodes.each { |node| bind :node => :distance_labeled_graph_node; node.set_tentative_distance_to(infinity) }
+          map.nodes.each { |node| bind :node => :distance_labeled_graph_node; distance_labeled_graph_node.set_tentative_distance_to(infinity) }
           tentative_distance_values[map.origin] = 0
 
           # The path array is kept in the outermost context and serves to store the
           # return path. Each recurring context may add something to the array along
           # the way. However, because of the nature of the algorithm, individual
-          # Context instances don't deliver "partial paths" as partial answers.
+          # Context instances don't deliver partial paths as partial answers.
           @path = Array.new
 
           # The pathTo map is a local associative array that remembers the
@@ -253,8 +259,8 @@ ctx, source = Context::define :CalculateShortestPath do
 
       @tentative_distance_values = Hash.new
 
-      # This is the fundamental data structure for Dijkstra's algorithm, called
-      # "Q" in the Wikipedia description. It is a boolean hash that maps a
+      # This is the fundamental data structure for DijkstraTest's algorithm, called
+      # Q in the Wikipedia description. It is a boolean hash that maps a
       # node onto false or true according to whether it has been visited
 
       @unvisited = Hash.new
@@ -262,11 +268,10 @@ ctx, source = Context::define :CalculateShortestPath do
       # These initializations are directly from the description of the algorithm
       map.nodes.each { |node| @unvisited[node] = true }
       @unvisited.delete(map.origin)
-      # p "map #{map.nodes}"
+
       map.nodes.each { |node|
-        bind :node => :distance_labeled_graph_node;
-        node.set_tentative_distance_to(infinity)
-        # p "initialized node #{node.name}"
+        bind :node => :distance_labeled_graph_node
+        distance_labeled_graph_node.set_tentative_distance_to(infinity)
       }
       tentative_distance_values[map.origin] = 0
 
@@ -274,7 +279,7 @@ ctx, source = Context::define :CalculateShortestPath do
       # The path array is kept in the outermost context and serves to store the
       # return path. Each recurring context may add something to the array along
       # the way. However, because of the nature of the algorithm, individual
-      # Context instances don't deliver "partial paths" as partial answers.
+      # Context instances don't deliver partial paths as partial answers.
 
       @path = Array.new
 
@@ -295,9 +300,18 @@ ctx, source = Context::define :CalculateShortestPath do
       @pathTo = pathto_hash
     end
   end
-end
 
-class CalculateShortestPath
+
+  def each
+    path.each { |node| yield node }
+  end
+
+
+  def path
+    @path
+  end
+
+  private
 
   def pathTo
     @pathTo
@@ -311,10 +325,6 @@ class CalculateShortestPath
     @south_neighbor
   end
 
-  def path;
-    @path
-  end
-
   def destination;
     @destination
   end
@@ -337,27 +347,6 @@ class CalculateShortestPath
     @south_neighbor = map.south_neighbor_of(origin_node)
   end
 
-
-  # public initialize. It's overloaded so that the public version doesn't
-  # have to pass a lot of crap; the initialize method takes care of
-  # setting up internal data structures on the first invocation. On
-  # recursion we override the defaults
-
-  def initialize(origin_node, target_node, geometries,
-      path_vector = nil, unvisited_hash = nil, pathto_hash = nil,
-      tentative_distance_values_hash = nil)
-    @destination = target_node
-
-    rebind(origin_node, geometries)
-
-    execute(path_vector, unvisited_hash, pathto_hash, tentative_distance_values_hash)
-  end
-
-  def each
-    path.each { |node| yield node }
-  end
-
-
   # This method does a simple traversal of the data structures (following pathTo)
   # to build the directed traversal vector for the minimum path
 
@@ -370,5 +359,4 @@ class CalculateShortestPath
   end
 end
 
-File.open('CalculateShortestPath_generated.rb', 'w') { |f| f.write(source) }
-
+p c