maroon 0.7.1 → 0.8.0

data/{Examples/Dijkstra/dijkstra.rb → Test/Examples/dijkstra_test.rb}

@@ -1,10 +1,14 @@
 # -*- encoding: utf-8 -*-
-require './Lib/maroon.rb'
-require './Examples/Dijkstra/data.rb'
-require './Examples/Dijkstra/CalculateShortestDistance.rb'
-require './Examples/Dijkstra/Calculate_Shortest_Path.rb'
+require 'test/unit'
+require_relative '../test_helper'
+require_relative 'data.rb'
+require_relative 'CalculateShortestDistance.rb'
+require_relative 'Calculate_Shortest_Path.rb'
+
+
+class DijkstraTest < Test::Unit::TestCase
 #!/usr/bin/env ruby
-# Example in Ruby -- Dijkstra's algorithm in DCI
+# Example in Ruby -- DijkstraTest's algorithm in DCI
 #    Modified and simplified for a Manhattan geometry with 8 roles
 #
 #
@@ -59,27 +63,33 @@ require './Examples/Dijkstra/Calculate_Shortest_Path.rb'
 
 # --- 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}"
+  def test_geometry_1
+    geometries = Geometry_1.new
+    path = []
+    CalculateShortestPath.new(geometries.root, geometries.destination, geometries,nil,nil,nil,nil).each { |node| path << "#{node.name} " }
+    distance = CalculateShortestDistance.new(geometries.root, geometries).distance
+    assert_equal(["'i' ","'h' ","'g' ","'d' ","'a' "], path)
+    assert_equal(6,distance)
+  end
 
-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)]} - "
+  def test_geometry_2
+    geometries = ManhattanGeometry2.new
+    path = CalculateShortestPath.new(geometries.root, geometries.destination, geometries,nil,nil,nil,nil)
+
+    last_node = nil
+    res = []
+    result = []
+    path.each do |node|
+      if last_node != nil;
+        result << geometries.distances[Edge.new(node, last_node)]
+      end
+      res << "#{node.name}"
+      last_node = node
+    end
+    assert_equal([1,1,3,2], result)
+    assert_equal(["'k'", "'j'", "'c'", "'b'", "'a'"], res)
   end
-  print "#{node.name}"
-  last_node = node
 end
-print "\n"
 
-geometries = ManhattanGeometry2.new
-puts "distance is #{CalculateShortestDistance.new(geometries.root, geometries).distance }"
+

data/Test/Examples/greeter_test.rb

@@ -0,0 +1,48 @@
+#Thanks to Ted Milken for updating the original example
+require 'test/unit'
+require_relative '../test_helper'
+
+class Person
+  attr_accessor :name
+  attr_accessor :greeting
+end
+
+class GreeterTest < Test::Unit::TestCase
+  def test_greet
+    Context.generate_dependency_graph = true
+    Context.generate_code = true
+    ctx = Context.define :Greet_Someone do
+      role :greeter do
+        def welcome
+          greeter.greeting
+        end
+      end
+
+      role :greeted do
+      end
+
+      def greet
+        greeter.name.to_s + ': ' + greeter.welcome.to_s + ' ' + greeted.name.to_s + '!'
+      end
+
+      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'
+
+    res = Greet_Someone.new(p1, p2).greet
+    assert_equal("Bob: Hello World!",res)
+    puts ""
+    p ctx.dependencies.to_dot
+  end
+
+end

data/{Examples/meter.rb → Test/Examples/meter_test.rb}

@@ -1,41 +1,39 @@
+require 'test/unit'
+require_relative '../test_helper'
 
-require './lib/maroon/kernel'
+context :Meter do
+  def initialize(clock, start_pos)
+    @clock = clock
+    @route = Route.new({0 => {1 => 1.25}}, Road_types.new)
+    route.update_position start_pos
+    @price_per_sec = 0.05
+  end
 
-context :Meter, :current_total do
-  role :price_per_sec
+  role :price_per_sec do end
 
   role :route do
-    price do
+    def price
       route.calculate_price clock.start
     end
   end
 
   role :clock do
-    price do
-      self.duration * price_per_sec
+    def price
+      clock.duration * price_per_sec
     end
   end
 
-  current_total do |current_position|
+  def current_total(current_position)
     route.update_position current_position
     clock.price + route.price
   end
-  print_route do
+  def print_route
     route.each_point { |x, y|
-      p "#{x},#{y}"
+      p x.to_s + ' ' + y.to_s
     }
   end
 end
 
-class Meter
-  def initialize(start, start_pos)
-    @clock = Clock.new start
-    @route = Route.new({0 => {1 => 1.25}}, Road_types.new)
-    route.update_position start_pos
-    @price_per_sec = 0.05
-  end
-end
-
 class Clock
   attr_reader :start
 
@@ -52,37 +50,34 @@ context :Route do
   role :prices do
   end
   role :payable_position do
-    price_from do |prev|
+    def price_from(prev)
       return 0 unless prev
-      delta = Math.sqrt((prev.x-self.x)**2 + (prev.y-self.y)**2 + (prev.z-self.z)**2)
-      road_type = @road_types[self]
+      delta = Math.sqrt((prev.x-payable_position.x)**2 + (prev.y-payable_position.y)**2 + (prev.z-payable_position.z)**2)
+      road_type = @road_types[payable_position]
       price = prices[road_type]
       delta * price
     end
   end
 
   role :positions do
-    price_for_route do |price_table|
+    def price_for_route(price_table)
       prev = nil
       sum = 0
       positions.each do |pos|
-        bind pos => :payable_position, price_table => :prices
-        sum += pos.price_from prev
-        prev = pos
+        bind :pos => :payable_position, :price_table => :prices
+        sum += payable_position.price_from prev
+        prev = payable_position
       end
       sum
     end
   end
-  update_position do |new_position|
+  def update_position(new_position)
     positions << new_position
   end
-  calculate_price do |start_time|
+  def calculate_price(start_time)
     price_table = prices[start_time.hour / (24/prices.length)]
     positions.price_for_route price_table
   end
-end
-
-class Route
   def initialize(prices, road_types)
     @positions = []
     @prices = prices
@@ -123,3 +118,22 @@ class Position
     @z = z
   end
 end
+
+class MeterTest < Test::Unit::TestCase
+  class TestClock
+    def initialize(duration)
+      @duration = duration
+
+    end
+    def start
+      Time.now
+    end
+    attr_reader :duration
+  end
+
+  def test_run
+    meter = Meter.new(TestClock.new(100),Position.new(0,0,0))
+    price = meter.current_total Position.new(10,4,5)
+    assert_equal(19,price.to_i)
+  end
+end

data/Test/abstract_syntax_tree_test.rb

@@ -4,44 +4,35 @@ require_relative '../generated/AbstractSyntaxTree'
 require_relative 'test_helper'
 
 class AbstractSyntaxTreeTest < Test::Unit::TestCase
-  def get_method_call &b
-    exp = get_sexp &b
-    exp[3]
-  end
 
-  def get_context(roles={},contracts={},role_aliases={},defining=nil,private_interactions= {})
-    InterpretationContext.new(roles, contracts, role_aliases,defining,private_interactions)
+  def get_type_of_production(&b)
+    contracts ={}
+    roles = {:foo => {:bar => []}}
+    interpretation_context = InterpretationContext.new(roles, contracts, nil,nil,nil)
+
+    exp = get_sexp &b
+    method_call = exp[3]
+    production = AbstractSyntaxTree.new(method_call, interpretation_context )
+    production.type
   end
 
   def test_rolemethod
-    method_call = get_method_call { foo.bar }
-
-    production = get_production(method_call)
-    type = production.type
+    type = get_type_of_production { foo.bar }
     assert_equal(Tokens::rolemethod_call, type)
   end
 
-  def get_production(method_call)
-    contracts ={}
-    roles = {:foo => {:bar => []}}
-    AbstractSyntaxTree.new(method_call, get_context(roles, contracts))
-  end
-
   def test_call
-    method_call = get_method_call { foo.baz }
-
-    production = get_production(method_call)
-    type = production.type
-
+    type = get_type_of_production  { foo.baz }
     assert_equal(Tokens::call, type)
   end
 
-  def test_indexer
-    method_call = get_method_call { foo[0] }
-
-    production = get_production(method_call)
-    type = production.type
+  def test_initializer
+    type = get_type_of_production { AbstractSyntaxTreeTest.new(nil) }
+    assert_equal(Tokens::initializer, type)
+  end
 
+  def test_indexer
+    type = get_type_of_production  { foo[0] }
     assert_equal(Tokens::indexer, type)
   end
 end

data/Test/alltests.rb

@@ -1 +1 @@
-`git ls-files`.split($/).grep(%r{(test|spec|features).rb}).select { |f| p f; require_relative("../#{f}") }
+`git ls-files`.split($/).grep(%r{(test|spec|features).rb}).select { |f| p f; require_relative("../#{f}") }

data/Test/test_helper.rb

@@ -2,6 +2,8 @@ require 'minitest/autorun'
 require 'sourcify'
 require_relative 'assertions'
 require_relative '../generated/build'
+require_relative '../generated/maroon/kernel'
+
 #require 'debugger'
 
 def get_sexp &b

data/base/AbstractSyntaxTree.rb

@@ -9,7 +9,7 @@ context :AbstractSyntaxTree do
 
       case
         when production.is_call? && (interpretation_context.roles.has_key?(production[2]))
-          @date = [production[2]]
+          @data = [production[2]]
           return true
         when (production == :self ||
             (production.is_indexer? && (production[1] == nil || production[1] == :self)) ||
@@ -54,14 +54,31 @@ context :AbstractSyntaxTree do
         end
       end
     end
-
+    def is_const?
+      if production.instance_of?(Sexp) && production.length == 2 && production[0] == :const && (production[1].instance_of? Symbol)
+        @data = [production[1]]
+        true
+      else
+        false
+      end
+    end
+    def is_initializer?
+      if production.is_call?
+        if AbstractSyntaxTree.new(production[1], @interpretation_context).type == Tokens::const
+           if production[2] == :new
+             return true
+           end
+        end
+      end
+      false
+    end
     def is_rolemethod_call?
       can_be = production.is_call?
       if can_be
         instance = AbstractSyntaxTree.new(production[1], @interpretation_context)
         can_be = instance.type == Tokens::role
         if can_be
-          instance_data = instance.data
+          instance_data = instance.data[0]
           role = @interpretation_context.roles[instance_data]
           data = production[2]
           can_be = role.has_key?(data)
@@ -93,6 +110,10 @@ context :AbstractSyntaxTree do
         Tokens::role
       when production.is_indexer?
         Tokens::indexer
+      when production.is_const?
+        Tokens::const
+      when production.is_initializer?
+        Tokens::initializer
       when production.is_call?
         Tokens::call
       else

data/base/ImmutableStack.rb

@@ -13,7 +13,7 @@ context :ImmutableStack do
   end
 
   def self.empty
-    @@empty ||= self.new(nil, nil)
+    @empty ||= self.new(nil, nil)
   end
 
   def each

data/base/dependency_graph.rb

@@ -0,0 +1,94 @@
+context :DependencyGraph do
+
+  def initialize(context_name, roles, interactions, dependencies)
+    @context_name = context_name
+
+    @roles = roles
+    @interactions = interactions
+    @dependencies = dependencies
+  end
+
+  role :roles do
+    def dependencies
+      roles.each do |r, methods|
+        bind :r => :role_name
+        role_dependencies = (dependencies[r] ||= {})
+        methods.each do |name, method_sources|
+          bind :method_sources => :method, :role_dependencies => :dependency
+          method.get_dependencies
+        end
+      end
+    end
+  end
+
+  role :interactions do
+    def dependencies
+      interactions.each do |name, interact|
+        role_dependencies = ((dependencies[:interactions] ||= {})[name] ||= {})
+        interact.each do |m|
+          bind :m => :method, :role_dependencies => :dependency
+          method.get_dependencies
+        end
+      end
+    end
+  end
+  role :dependencies do end
+  role :dependency do
+    def add(dependent_role_name,method_name)
+      if dependent_role_name && dependent_role_name != role_name
+        dependency[dependent_role_name] ||= {}
+
+        unless dependency[dependent_role_name].has_key? method_name
+          dependency[dependent_role_name][method_name] = 0
+        end
+        dependency[dependent_role_name][method_name] += 1
+      end
+    end
+  end
+  role :role_name do end
+  role :method do
+    def body
+      args = method.definition.detect { |d| d[0] == :args }
+      index = method.definition.index(args) + 1
+      if method.definition.length > index+1
+        body = method.definition[index..-1]
+        body.insert(0, :block)
+        body
+      else
+        method.definition[index]
+      end
+    end
+
+    def ast
+      AbstractSyntaxTree.new(method.body, InterpretationContext.new(roles,{},{},role_name,{}))
+    end
+    def definition
+      (method.instance_of? Array) ? method[0] : method
+    end
+    def get_dependencies
+      method.ast.each_production do |production|
+        name = nil
+        method_name = nil
+        case production.type
+          when Tokens.rolemethod_call
+            data = production.data
+            name = data[1]
+            method_name = data[0]
+          when Tokens.role
+            name = production.data[0]
+          else
+        end
+        dependency.add(name,method_name) if name != nil
+      end
+    end
+  end
+
+  def create!
+    roles.dependencies
+    interactions.dependencies
+    dependencies
+  end
+
+
+end
+