rachinations 0.0.7 → 0.0.8

data/lib/rachinations/domain/nodes/node.rb

@@ -1,6 +1,8 @@
 require_relative '../../domain/modules/common/invariant'
 require_relative '../../domain/modules/common/hash_init'
 
+# @abstract Subclass and override {#take_resource!} and
+#   {#put_resource!} to implement nodes
 class Node
 
   include Invariant
@@ -35,7 +37,6 @@ class Node
 
   end
 
-
   def edges
     if @edges.is_a? Array
       @edges
@@ -102,34 +103,17 @@ class Node
     @triggers
   end
 
-  # def clear_triggers
-  #   triggers.each do |t|
-  #     t[2]=true
-  #   end
-  # end
-
   # Call trigger! on each node stored in self.triggers
   #
   def fire_triggers!
-    triggers.each do |node|
-      node.trigger!
-      # if (n[0].is_a? Proc) && n[2]
-      #   if n[0].call
-      #     n[2]=false
-      #     n[1].trigger!
-      #   end
-      # elsif n[0] && n[2]
-      #   n[2]=false
-      #   n[1].trigger!
-      # end
-    end
+    triggers.each { |node| node.trigger! }
   end
 
   def enabled?
     status=true
     conditions.each do |condition|
       if condition.is_a? Proc
-        status = (status && condition.call)
+        status = (status && condition.call())
       elsif condition === false
         return false
       elsif condition === true

data/lib/rachinations/domain/nodes/pool.rb

@@ -3,7 +3,6 @@ require_relative '../../domain/nodes/node'
 require_relative '../../domain/resources/token'
 require_relative '../resource_bag'
 require_relative '../../domain/exceptions/no_elements_matching_condition_error'
-require_relative '../../domain/exceptions/bad_config'
 require_relative '../../domain/modules/common/refiners/proc_convenience_methods'
 require_relative '../../../../lib/rachinations/helpers/edge_helper'
 
@@ -11,7 +10,7 @@ using ProcConvenienceMethods
 
 class Pool < ResourcefulNode
 
-  Helper = Helpers::EdgeHelper
+  EdgeHelper = Helpers::EdgeHelper
 
   def initialize(hsh={})
 
@@ -276,7 +275,7 @@ class Pool < ResourcefulNode
     enabled_outgoing_edges = outgoing_edges.select { |edge| edge.enabled? }
 
 
-    if Helper.all_can_push?(edges, require_all: true)
+    if EdgeHelper.all_can_push?(edges, require_all: true)
 
       enabled_outgoing_edges.each do |edge|
 

data/lib/rachinations/domain/nodes/resourceful_node.rb

@@ -5,6 +5,9 @@ require_relative '../../domain/modules/common/refiners/proc_convenience_methods'
 
 using ProcConvenienceMethods
 
+# @abstract Subclass and override {#trigger!}, {#resource_count},
+#   {#pull_any!}, {#pull_all!}, {#push_any!}, {#push_all!}, {#take_resource!}
+#   and {#put_resource!} to implement nodes that can store resources
 class ResourcefulNode < Node
 
   include Invariant
@@ -25,13 +28,11 @@ class ResourcefulNode < Node
 
   end
 
-# pools are about resources
-
   def supports?(klass)
     if klass.eql?(Token)
       untyped?
     else
-      #untyped nodes support everything.
+      # untyped nodes support everything.
       if untyped?
         true
       else

data/lib/rachinations/domain/nodes/sink.rb

@@ -9,7 +9,7 @@ class Sink < Pool
     # do nothing
   end
 
-  def put_resource!(obj)
+  def put_resource!(obj, edge=nil)
     inv{obj.unlocked?}
     # do nothing
   end

data/lib/rachinations/dsl/bad_dsl.rb

@@ -1,2 +1,5 @@
+# To be used to signal that a DSL command has not been correctly used.
+#   For instance, when required options have been omitted or when an option
+#   of a different type than expected has been provided
 class BadDSL < RuntimeError
 end

data/lib/rachinations/dsl/bootstrap.rb

@@ -1,5 +1,4 @@
 require_relative '../../../lib/rachinations/domain/diagrams/diagram'
-require_relative 'diagram_shorthand_methods'
 require_relative 'bad_dsl'
 require_relative 'helpers/parser'
 
@@ -7,15 +6,17 @@ require_relative 'helpers/parser'
 module DSL
   module Bootstrap
 
-    def diagram(name='new_diagram', mode: :silent, &blk)
+    def diagram(name='new_diagram', mode: :default, &blk)
 
-      # cant verbose be a simple boolean instead?
-      if mode == :silent || mode == 'silent'
+      supported_modes = [:default, :silent, :verbose]
+
+      raise BadDSL, "Unknown diagram mode: #{mode.to_s}" unless supported_modes.include? mode
+
+      # right now silent and default are the same thing
+      if mode == :default || mode == :silent
         dia= Diagram.new(Parser.validate_name!(name))
       elsif mode == :verbose || mode == 'verbose'
         dia = VerboseDiagram.new(Parser.validate_name!(name))
-      else
-        raise BadDSL, "Unknown diagram mode: #{mode.to_s}"
       end
 
       # This is a modified version of Diagram#add_edge!. It defers some method
@@ -77,7 +78,7 @@ module DSL
 
         node.attach_condition &condition
 
-        if !triggered_by.nil?
+        unless triggered_by.nil?
 
           attach_trigger_task = lambda do |triggeree, triggerer_name, diagram|
             # ask the diagram to evaluate what node it is
@@ -88,7 +89,7 @@ module DSL
 
         end
 
-        if !triggers.nil?
+        unless triggers.nil?
 
           attach_trigger_task = lambda do |triggerer, triggeree_name, diagram|
             # ask the diagram to evaluate what node it is
@@ -105,6 +106,7 @@ module DSL
 
       end
 
+      # after defining all those methods we run
       dia.instance_eval(&blk)
       dia.run_scheduled_tasks
 

data/lib/rachinations/dsl/diagram_shorthand_methods.rb

@@ -1,10 +1,6 @@
 require_relative '../domain/diagrams/diagram'
-require_relative '../domain/diagrams/verbose_diagram'
-require_relative '../domain/diagrams/non_deterministic_diagram'
-require_relative '../domain/modules/diagrams/verbose'
 require_relative '../domain/modules/common/refiners/proc_convenience_methods'
 require_relative './bad_dsl'
-require_relative '../utils/string_helper'
 require_relative 'helpers/parser'
 
 module DSL
@@ -15,6 +11,9 @@ module DSL
 
     # if you can turn this into a refiner and still keep all tests passing,
     # send a PR for me :smile:
+
+    # Reopen class Diagram and add methods that will only be visible
+    # inside a diagram do .. end block
     class ::Diagram
 
       alias_method :run, :run!
@@ -67,7 +66,6 @@ module DSL
 
       end
 
-      # methods to create edges
       def edge(*args)
 
         hash = Parser.parse_edge_arguments(args)
@@ -76,6 +74,13 @@ module DSL
 
       end
 
+      def stop(*args)
+        hash = Parser.parse_stop_condition_arguments(args)
+
+        add_stop_condition!(hash)
+
+      end
+
       # so that I can easily access elements which have been given a name
       # (mostly nodes and maybe edges too)
       def method_missing(method_sym, *args, &block)

data/lib/rachinations/dsl/helpers/parser.rb

@@ -8,6 +8,7 @@ module DSL
     using ProcConvenienceMethods
 
     ConstantHash = ::Extras::ConstantHash
+    StringUtils = ::Utils::StringUtils
 
     # these patterns define what each argument should look like
 
@@ -17,86 +18,93 @@ module DSL
 
     MODE = proc { |arg| [:pull_any, :pull_all, :push_any, :push_all].include? arg }
 
+    GATE_MODE = proc { |arg| [:probabilistic, :deterministic].include? arg }
+
     ACTIVATION= proc { |arg| [:automatic, :passive, :start].include? arg }
 
     PROC = proc { |arg| arg.is_a? Proc }
 
     LABEL = proc { |arg| arg.is_a?(Numeric) || arg.is_a?(Proc) }
 
+    SHORT_STRING = proc { |arg| arg.is_a?(String) && arg.length.between?(1, 25) }
+
     # Parse an arbitrary list of arguments and returns a well-formed
     #  Hash which can then be used as argument to method add_node!
     # @param [Array] arguments an array of arguments.
     # @return [Hash] a well-formed hash
     def self.parse_arguments(arguments)
-      arguments.inject(ConstantHash.new) do |accumulator, arg|
+      arguments.inject(ConstantHash.new) do |acc, elem|
 
-        # named parameters are expressed as hashes
-        # and all arguments can (also) be passed as named parameters
-        if arg.is_a? Hash
+        # elem is here either a hash or a single argument that's 
+        # been passed to this method
+        
+        if elem.is_a? Hash
 
-          if arg.has_key? :activation
-            if ACTIVATION.match? arg[:activation]
-              accumulator[:activation] = arg[:activation]
+          if elem.has_key? :activation
+            if ACTIVATION.match? elem[:activation]
+              acc[:activation] = elem[:activation]
             else
               raise BadDSL.new
             end
           end
 
-          if arg.has_key? :condition
-            if PROC.match? arg[:condition]
-              accumulator[:condition] = arg[:condition]
+          if elem.has_key? :condition
+            if PROC.match? elem[:condition]
+              acc[:condition] = elem[:condition]
             else
               raise BadDSL.new
             end
           end
 
-          if arg.has_key? :initial_value
-            if INITIAL_VALUE.match? arg[:initial_value]
-              accumulator[:initial_value] = arg[:initial_value]
+          if elem.has_key? :initial_value
+            if INITIAL_VALUE.match? elem[:initial_value]
+              acc[:initial_value] = elem[:initial_value]
             else
               raise BadDSL.new
             end
           end
 
-          if arg.has_key? :mode
-            if MODE.match? arg[:mode]
-              accumulator[:mode] = arg[:mode]
+          if elem.has_key? :mode
+            if MODE.match? elem[:mode]
+              acc[:mode] = elem[:mode]
             else
               raise BadDSL.new
             end
           end
 
-          if arg.has_key? :triggered_by
-            if IDENTIFIER.match? arg[:triggered_by]
-              accumulator[:triggered_by] = arg[:triggered_by]
+          if elem.has_key? :triggered_by
+            if IDENTIFIER.match? elem[:triggered_by]
+              acc[:triggered_by] = elem[:triggered_by]
             else
               raise BadDSL.new
             end
           end
 
-          if arg.has_key? :triggers
-            if IDENTIFIER.match? arg[:triggers]
-              accumulator[:triggers] = arg[:triggers]
+          if elem.has_key? :triggers
+            if IDENTIFIER.match? elem[:triggers]
+              acc[:triggers] = elem[:triggers]
             else
               raise BadDSL.new
             end
           end
 
         else
-          if IDENTIFIER.match?(arg) # a node's name, if present, is always the first argument
-            accumulator[:name] = arg
-          elsif INITIAL_VALUE.match?(arg)
-            accumulator[:initial_value] = arg
-          elsif MODE.match?(arg)
-            accumulator[:mode] = arg
-          elsif ACTIVATION.match?(arg)
-            accumulator[:activation] = arg
+          if IDENTIFIER.match?(elem) # a node's name, if present, is always the first elemument
+            acc[:name] = elem
+          elsif INITIAL_VALUE.match?(elem)
+            acc[:initial_value] = elem
+          elsif MODE.match?(elem)
+            acc[:mode] = elem
+          elsif ACTIVATION.match?(elem)
+            acc[:activation] = elem
+          elsif PROC.match?(elem)
+            acc[:condition] = elem
           else
-            raise BadDSL, "Argument #{arg} doesn't fit any known signature"
+            raise BadDSL, "elemument #{elem} doesn't fit any known signature"
           end
         end
         # passing the accumulator onto the next iteration
-        accumulator
+        acc
       end
     end
 
@@ -110,6 +118,8 @@ module DSL
             accumulator[:condition] = arg[:condition] if PROC.match?(arg[:condition])
           elsif arg.has_key? :triggered_by
             accumulator[:triggered_by] = arg[:triggered_by] if IDENTIFIER.match?(arg[:triggered_by])
+          elsif arg.has_key?[:mode]
+            accumulator[:mode] = arg[:mode] if GATE_MODE.match?(arg[:mode])
           else
             raise BadDSL, "Named argument doesn't fit any known signature"
           end
@@ -118,8 +128,10 @@ module DSL
             accumulator[:name] = arg
           elsif ACTIVATION.match?(arg)
             accumulator[:activation] = arg
+          elsif GATE_MODE.match?(arg)
+            accumulator[:mode] = arg
           else
-            raise BadDSL, "Argument #{arg} doesn't fit any known signature"
+            raise BadDSL, "Argument '#{arg}' doesn't fit any known signature"
           end
         end
         accumulator
@@ -129,31 +141,53 @@ module DSL
 
     def self.parse_edge_arguments(arguments)
 
-      arguments.inject(ConstantHash.new) do |accumulator, arg|
-        if arg.is_a? Hash
-          if arg.has_key? :from
-            accumulator[:from] = arg[:from] if IDENTIFIER.match? arg[:from]
+      arguments.inject(ConstantHash.new) do |acc, elem|
+        if elem.is_a? Hash
+          if elem.has_key? :from
+            acc[:from] = elem[:from] if IDENTIFIER.match? elem[:from]
           end
-          if arg.has_key? :to
-            accumulator[:to] = arg[:to] if IDENTIFIER.match? arg[:to]
+          if elem.has_key? :to
+            acc[:to] = elem[:to] if IDENTIFIER.match? elem[:to]
           end
-          if arg.has_key? :label
-            accumulator[:label] = arg[:label] if LABEL.match? arg[:label]
+          if elem.has_key? :label
+            acc[:label] = elem[:label] if LABEL.match? elem[:label]
           end
         else
-          if IDENTIFIER.match?(arg)
-            accumulator[:name] = arg
-          elsif LABEL.match?(arg)
-            accumulator[:label]=arg
+          if IDENTIFIER.match?(elem)
+            acc[:name] = elem
+          elsif LABEL.match?(elem)
+            acc[:label]=elem
           else
-            raise BadDSL, "Argument #{arg} doesn't fit any known signature."
+            raise BadDSL, "argument #{elem} doesn't fit any known signature."
           end
         end
-        accumulator
+        acc
       end
 
     end
 
+    def self.parse_stop_condition_arguments(arguments)
+      arguments.inject(ConstantHash.new) do |acc, elem|
+
+        if elem.is_a? Hash
+
+          if elem.has_key? :message
+            acc[:message] = elem[:message] if IDENTIFIER.match? elem[:message]
+          end
+
+          if elem.has_key? :condition
+            acc[:condition] = elem[:condition] if PROC.match? elem[:condition]
+          end
+
+        else
+          acc[:condition] = elem if PROC.match? elem
+          acc[:message] = elem if SHORT_STRING.match? elem
+        end
+
+        acc
+      end
+    end
+
     # Used to validate that a string is a valid name for diagram components
     #
     # @param [String] text the name we want to validate
@@ -161,7 +195,7 @@ module DSL
     # @return [String] the text itself, but only if it's valid. Otherwise
     #   an exception will be raised.
     def self.validate_name!(text)
-      if StringHelper.valid_ruby_variable_name?(text)
+      if StringUtils.valid_ruby_variable_name?(text)
         text
       else
         raise BadDSL, "Invalid name: '#{text}'"
@@ -171,7 +205,7 @@ module DSL
     # @param [String] text the name we want to validate
     # @return [Boolean] whether or not given text is a valid name for diagram elements
     def self.valid_name?(text)
-      StringHelper.valid_ruby_variable_name?(text)
+      StringUtils.valid_ruby_variable_name?(text)
     end
 
   end