rachinations 0.0.3 → 0.0.4

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

@@ -4,12 +4,14 @@ require_relative '../../domain/resources/token'
 require_relative '../resource_bag'
 require_relative '../../domain/exceptions/no_elements_matching_condition_error'
 require_relative '../../domain/modules/common/refiners/proc_convenience_methods'
-
+require_relative '../../../../lib/rachinations/helpers/edge_helper'
 
 using ProcConvenienceMethods
 
 class Pool < ResourcefulNode
 
+  Helper = Helpers::EdgeHelper
+
   def initialize(hsh={})
 
     check_options!(hsh)
@@ -17,7 +19,8 @@ class Pool < ResourcefulNode
 
     @resources = get_initial_resources(params[:initial_value])
 
-    @types = get_types(params[:initial_value], params[:types])
+    @types = get_types(initial_value: params[:initial_value],
+                       given_types: params[:types])
 
     #reference to the underlying diagram
     @diagram = params[:diagram]
@@ -47,16 +50,25 @@ class Pool < ResourcefulNode
 
         pull_any!
 
-      end
+      elsif push? && all?
+
+        push_all!
+
+      elsif pull? && all?
+
+        pull_all!
 
+      else
+
+      end
     end
   end
 
-  def resource_count(type=nil, &block)
+  def resource_count(type: nil, expr: nil)
 
-    raise ArgumentError.new('Please provide either a type or a block, but not both.') if block_given? && !type.nil?
+    raise ArgumentError.new('Please provide either a type or a block, but not both.') if !expr.nil? && !type.nil?
 
-    if type.nil? && !block_given?
+    if type.nil? && expr.nil?
       resources.count_where { |r| r.unlocked? }
     elsif type.is_a?(Class) && type <= Token
 
@@ -67,12 +79,12 @@ class Pool < ResourcefulNode
       else
         raise UnsupportedTypeError.new "Unsupported type: #{type.name}"
       end
-    elsif block_given?
+    elsif !expr.nil?
 
       # client doesn't need to know about locked vs unlocked resources
-      unlock_condition = Proc.new { |r| r.unlocked? }
+      unlock_condition = proc { |r| r.unlocked? }
 
-      resources.count_where { |r| unlock_condition.match?(r) && block.match?(r) }
+      resources.count_where { |r| unlock_condition.match?(r) && expr.match?(r) }
 
     else
       raise ArgumentError.new("Wrong parameter types passed to #{__callee__}")
@@ -117,16 +129,16 @@ class Pool < ResourcefulNode
     end
   end
 
-  def take_resource!(&expression)
+  def take_resource!(expression=nil)
 
-    unless block_given?
+    if expression.nil?
       # if no conditions given, then anything goes.
-      expression = Proc.new{ |res| true }
+      expression = Proc.new { |res| true }
     end
 
     raise RuntimeError.new unless resources.count_where(&expression) > 0
 
-    res=remove_resource! &expression
+    res=remove_resource! expression
 
     fire_triggers!
 
@@ -135,7 +147,7 @@ class Pool < ResourcefulNode
   end
 
   def to_s
-    "Pool '#{@name}':  #{resources} "
+    "Pool '#{@name}': #{resources} "
   end
 
   # TODO this smells. where is this used? can i do without it?
@@ -156,25 +168,6 @@ class Pool < ResourcefulNode
 
   end
 
-  # TODO document this or else refactor it out
-  def get_types(initial_value, given_types)
-    inv { !self.instance_variable_defined?(:@types) }
-
-    if initial_value.is_a?(Fixnum) && given_types.empty?
-      # nothing to do
-    elsif initial_value == 0 && !given_types.empty?
-      # nothing to do
-    elsif initial_value.is_a?(Hash)
-      initial_value.each_key { |type| given_types.push(type) }
-    else
-      raise ArgumentError.new
-    end
-
-    given_types.uniq
-
-  end
-
-
   def types
     @types
   end
@@ -183,16 +176,28 @@ class Pool < ResourcefulNode
 
   attr_reader :resources
 
-  def remove_resource!(&expression)
+  # Tries to remove a Resource that matches given expression from this node.
+  # @param [Proc] expression the expression to match against Resources
+  # @raise [RuntimeError] In case it was not possible to remove a Resource
+  def remove_resource!(expression)
 
     # client doesn't need to know about locked vs unlocked resources
     unlocked_expression = Proc.new { |r| r.unlocked? }
 
-    res=resources.get_where { |r| unlocked_expression.call(r) && expression.call(r) }
+    begin
+      # the original expression plus the expression that specifies that only unlocked
+      # resources may be retrieved
+      res=resources.get_where { |r| unlocked_expression.call(r) && expression.call(r) }
+    rescue ArgumentError
+        raise RuntimeError, 'wrong arguments'
+    rescue NoElementsMatchingConditionError
+        raise RuntimeError, 'no elements matching'
+    else
+      @resources_removed[res.class] += 1
+      res
+    end
 
-    @resources_removed[res.class] += 1
 
-    res
   end
 
   def add_resource!(res)
@@ -201,43 +206,22 @@ class Pool < ResourcefulNode
 
   end
 
-  def options
-    [:conditions, :name, :activation, :mode, :types, :initial_value, :diagram]
-  end
-
-  def defaults
-    {
-        activation: :passive,
-        mode: :pull_any,
-        types: [],
-        initial_value: 0
-    }
-  end
-
-  def aliases
-    {:initial_values => :initial_value}
-  end
-
   def push_any!
 
     outgoing_edges.shuffle.each do |edge|
-      begin
-        blk = edge.push_expression
-      rescue => ex
-        # Could not get a block for one Edge, but this is push_any so I'll go ahead.
-        next #other edges might still be able to serve me.
-      end
+
+      blk = edge.push_expression
 
       edge.label.times do
         begin
-          res = remove_resource!(&blk)
-        rescue => ex
-           # Failed to remove this resource. Let's try another Edge, perhaps?
+          res = remove_resource!(blk)
+        rescue RuntimeError
+          # Failed to remove this resource. Let's try another Edge, perhaps?
           break
+        else
+          edge.push!(res)
         end
 
-        edge.push!(res)
-
       end
 
     end
@@ -245,26 +229,89 @@ class Pool < ResourcefulNode
 
   def pull_any!
     incoming_edges.shuffle.each do |edge|
-      begin
-        blk = edge.pull_expression
-      rescue RuntimeError => ex
-        # Could not get a block for one Edge, but this is pull_any so I'll go ahead.
-        next #other edges might still be able to serve me.
-      end
+
+      blk = edge.pull_expression
 
       edge.label.times do
         begin
-          res = edge.pull!(&blk)
-        rescue RuntimeError => ex
+          res = edge.pull!(blk)
+        rescue RuntimeError
           # Let's try another Edge, perhaps?
           break
+        else
+          add_resource!(res.lock!)
         end
 
-        add_resource!(res.lock!)
+      end
+
+    end
+  end
+
+  def pull_all!
+
+    enabled_incoming_edges = incoming_edges.select { |edge| edge.enabled? }
+
+    if enabled_incoming_edges.all? { |edge| edge.test_ping? }
+
+      enabled_incoming_edges.each do |edge|
+        blk = edge.pull_expression
+
+        edge.label.times do
+          res = edge.pull!(blk)
+
+          add_resource!(res.lock!)
+
+        end
 
       end
+      fire_triggers!
+    end
+
+  end
+
+  def push_all!
+
+    enabled_outgoing_edges = outgoing_edges.select { |edge| edge.enabled? }
+
+
+    if Helper.all_can_push?(edges, require_all: true)
+
+      enabled_outgoing_edges.each do |edge|
+
+        expression = edge.push_expression
+
+        edge.label.times do
+
+          res = remove_resource!(expression)
+
+          edge.push!(res)
+
+        end
 
+      end
+      fire_triggers!
     end
+
+
+  end
+
+  def options
+    [:conditions, :name, :activation, :mode, :types, :initial_value, :diagram]
+  end
+
+  def defaults
+    {
+        activation: :passive,
+        mode: :pull_any,
+        types: [],
+        initial_value: 0
+    }
+  end
+
+  def aliases
+    {
+        :initial_values => :initial_value
+    }
   end
 
 end

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

@@ -3,7 +3,6 @@ require_relative '../../domain/resources/token'
 require_relative '../../domain/nodes/node'
 require_relative '../../domain/modules/common/refiners/proc_convenience_methods'
 
-
 using ProcConvenienceMethods
 
 class ResourcefulNode < Node

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

@@ -14,4 +14,7 @@ class Sink < Pool
     # do nothing
   end
 
+  def to_s
+    "Sink '#{@name}'\n\n"
+  end
 end

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

@@ -28,7 +28,7 @@ class Source < ResourcefulNode
   end
 
   def to_s
-    "Source '#{@name}':  \n"
+    "Source '#{@name}'\n\n"
   end
 
   def put_resource!;
@@ -98,7 +98,7 @@ class Source < ResourcefulNode
 
     #we'll need to change this if source starts accepting
     # more than a single type
-    inv { types.size === 1 }
+    inv("Sources can only have a single type") { types.size === 1 }
 
     if type.nil?
       res = Token.new
@@ -144,6 +144,7 @@ class Source < ResourcefulNode
       end
 
     end
+    fire_triggers!
   end
 
   def options

data/lib/rachinations/domain/resource_bag.rb

@@ -82,16 +82,15 @@ class ResourceBag
       unlocked = count_where{|r| (r.is_type? klass) && (r.unlocked?) }
       locked = count_where{|r| (r.is_type? klass) && (r.locked?) }
 
-      out += "\n #{name} -> #{unlocked} (#{locked}) \n\n"
+      out += "#{name} -> #{unlocked} (#{locked}) \n"
     end
 
     if classes.empty?
-      "\n    Empty\n\n"
+      "Empty\n\n"
     else
-      out
+      out+"\n"
     end
 
-
   end
 
   # created so that I don't have to call count everytime just to see whether there's at least one element matching said condition

data/lib/rachinations/dsl/bad_dsl.rb

@@ -0,0 +1,2 @@
+class BadDSL < RuntimeError
+end

data/lib/rachinations/dsl/bootstrap.rb

@@ -0,0 +1,59 @@
+require_relative '../../../lib/rachinations/domain/diagrams/diagram'
+require_relative 'diagram_shorthand_methods'
+require_relative 'bad_dsl'
+require_relative 'helpers/parser'
+
+# Bootstraping a diagram using the DiagramShorthandMethods
+module DSL
+  module Bootstrap
+
+    def diagram(name='new_diagram', mode: :silent, &blk)
+
+      # cant verbose be a simple boolean instead?
+      if mode == :silent || 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
+
+      # methods in the block get run as if they were called on
+      # the diagram (augmented by the DiagramShorthandMethods module) itself
+      dia.instance_eval(&blk)
+
+      dia
+
+    end
+
+
+    def non_deterministic_diagram(name, verbose=:silent, &blk)
+
+      dia=NonDeterministicDiagram.new(Parser.validate_name!(name))
+
+      # cant verbose be a simple boolean instead?
+      if verbose === :verbose
+        dia.extend(Verbose)
+      end
+
+      dia.instance_eval &blk
+
+      dia
+
+    end
+
+    # This is just a convenience method to create a proc in a way that's more
+    #  intuitive for ends users.
+    # @example Create a proc, equivalent to proc{|x| x+1 }
+    #   expr{|x| x+1 }
+    def expr(&blk)
+      if !block_given?
+        raise ArgumentError, "expected a block, but none was given"
+      else
+        Proc.new(&blk)
+      end
+    end
+
+  end
+
+end

data/lib/rachinations/dsl/diagram_shorthand_methods.rb

@@ -0,0 +1,107 @@
+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
+
+  module DiagramShorthandMethods
+
+    using ProcConvenienceMethods
+
+    # if you can turn this into a refiner and still keep all tests passing,
+    # send a PR for me :smile:
+    class ::Diagram
+
+      alias_method :run, :run!
+
+      def pool(*args)
+
+        hash = Parser.parse_arguments(args)
+
+        add_node! Pool, hash
+
+      end
+
+      def source(*args)
+
+        hash = Parser.parse_arguments(args)
+
+        add_node! Source, hash
+
+      end
+
+      def sink(*args)
+
+        hash = Parser.parse_arguments(args)
+
+        add_node! Sink, hash
+
+      end
+
+      def converter(*args)
+
+        hash = Parser.parse_arguments(args)
+
+        add_node! Converter, hash
+
+      end
+
+      def trader(*args)
+
+        hash = Parser.parse_arguments(args)
+
+        add_node! Trader, hash
+
+      end
+
+      def gate(*args)
+        # gate is different because it doesn't take some arguments
+        hash = Parser.parse_gate_arguments(args)
+
+        add_node! Gate, hash
+
+      end
+
+      # methods to create edges
+      def edge(*args)
+
+        hash = Parser.parse_edge_arguments(args)
+
+        add_edge! Edge, 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)
+        super if method_sym.to_s == 'anonymous' #these aren't actual node names
+
+        begin
+          #does a node with that name exist?
+          node=get_node(method_sym.to_s)
+        rescue RuntimeError => err_node
+          #what about an edge?
+          begin
+            edge = get_edge(method_sym.to_s)
+          rescue RuntimeError => err_edge
+            #no luck, sorry
+            super
+          else
+            edge
+          end
+        else
+          node
+        end
+      end
+
+    end
+
+  end
+
+end