rachinations 0.0.1

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

@@ -0,0 +1,6 @@
+require_relative '../../domain/nodes/node'
+require_relative '../../domain/nodes/resourceless_node'
+
+class Gate < ResourcelessNode
+
+end

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

@@ -0,0 +1,166 @@
+require_relative '../../domain/modules/common/invariant'
+require_relative '../../domain/modules/common/hash_init'
+
+class Node
+
+  include Invariant
+  include HashInit
+
+  attr_reader :name,:types
+
+
+  def attach_condition(condition)
+    conditions.push(condition)
+  end
+
+  def conditions
+    @conditions ||= Array.new
+  end
+
+  def edges
+    if @edges.is_a? Array
+      @edges
+    else
+      @edges = Array.new
+      @edges
+    end
+  end
+
+  def incoming_edges
+    edges.select{|e| e.to == self}
+  end
+
+  def outgoing_edges
+    edges.select{|e| e.from == self}
+  end
+
+  def attach_edge(edge)
+    edges.push(edge)
+  end
+
+  def attach_edge!(edge)
+    attach_edge(edge)
+    self
+  end
+
+  def detach_edge(edge)
+    if edges.include?(edge)
+      edges.pop(edge)
+    else
+      raise RuntimeError "This #{self.class} does not include this #{edge.class}"
+    end
+  end
+
+  def detach_edge!(edge)
+    detach_edge(edge)
+    self
+  end
+
+  def typed?
+    !untyped?
+  end
+
+  def untyped?
+    types.empty?
+  end
+
+  def attach_trigger(trig)
+    triggers.push(trig+[true])
+  end
+
+  def triggers
+    @triggers ||= Array.new
+  end
+
+  def clear_triggers
+    triggers.each do |t|
+      t[2]=true
+    end
+  end
+
+  def fire_triggers!
+    triggers.each do |n|
+      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
+  end
+
+  def enabled?
+    res=true
+    conditions.each do |cond|
+      if cond.is_a? Proc
+        res=res && cond.call
+      elsif cond === false
+        return false
+      elsif cond === true
+        # do nothing
+      end
+    end
+    res
+  end
+
+  def disabled?
+    !enabled?
+  end
+
+  def commit!
+    clear_triggers
+    self
+  end
+
+  def pull?
+    @mode === :pull || @mode === :pull_any || @mode === :pull_all
+  end
+
+  def push?
+    @mode === :push || @mode === :push_any || @mode === :push_all
+  end
+
+  def automatic?
+    @activation === :automatic
+  end
+
+  def passive?
+    @activation === :passive
+  end
+
+  def start?
+    @activation === :start
+  end
+
+  def any?
+    @mode === :push_any || @mode === :pull_any
+  end
+
+  def all?
+    @mode === :push_all || @mode === :pull_all
+  end
+
+  # Tries to take any resource that, when yielded to expression, returns true.
+  # In other words, tries to take any resource which matches the expression
+  # block given as parameter.
+  #
+  # @raise [RuntimeError] in case no resources in this node match given
+  #  expression block.
+  # @param expression [Proc] the expression
+  def take_resource!(&expression)
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+  # Places a single resource into this Node. Each subclass may then
+  # decide what to do with it; examples are to store the resource and/or to
+  # fire triggers.
+  #
+  # @raise [RuntimeError] in case this node won't take the resource
+  def put_resource!(res,edge=nil)
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+end

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

@@ -0,0 +1,267 @@
+require_relative '../../domain/nodes/resourceful_node'
+require_relative '../../domain/nodes/node'
+require_relative '../../domain/resources/token'
+require_relative '../resource_bag'
+require_relative '../../domain/exceptions/no_elements_matching_condition_error'
+
+
+class Pool < ResourcefulNode
+
+  def initialize(hsh={})
+
+    check_options!(hsh)
+    params = set_defaults(hsh)
+
+    @resources = get_initial_resources(params[:initial_value])
+
+    @types = get_types(params[:initial_value], params[:types])
+
+    #reference to the underlying diagram
+    @diagram = params[:diagram]
+
+    #this node's identifier
+    @name = params[:name]
+
+    #whether this node is passive or automatic (active)
+    @activation = params.fetch(:activation)
+
+    #pull or push
+    @mode = params.fetch(:mode)
+
+    #calling parent constructor to setup other variables.
+    super(hsh)
+
+  end
+
+  def trigger!
+
+    if enabled?
+      if push? && any?
+
+        push_any!
+
+      elsif pull? && any?
+
+        pull_any!
+
+      end
+
+    end
+  end
+
+  def resource_count(type=nil, &block)
+
+    raise ArgumentError.new('Please provide either a type or a block, but not both.') if block_given? && !type.nil?
+
+    if type.nil? && !block_given?
+      resources.count_where { |r| r.unlocked? }
+    elsif type.is_a?(Class) && type <= Token
+
+      if supports? type
+        resources.count_where { |r|
+          r.unlocked? && r.is_type?(type)
+        }
+      else
+        raise UnsupportedTypeError.new "Unsupported type: #{type.name}"
+      end
+    elsif block_given?
+
+      # client doesn't need to know about locked vs unlocked resources
+      unlock_condition = Proc.new { |r| r.unlocked? }
+
+      resources.count_where { |r| unlock_condition.match?(r) && block.match?(r) }
+
+    else
+      raise ArgumentError.new("Wrong parameter types passed to #{__callee__}")
+    end
+  end
+
+  def instant_resource_count(type=nil)
+    if type.nil?
+      @resources.count_where { true }
+    else
+
+      if supports? type
+        @resources.count_where { |r|
+          r.instance_of?(type)
+        }
+      else
+        raise UnsupportedTypeError.new "Unsupported type: #{type.name}"
+      end
+    end
+  end
+
+
+  def commit!
+
+    unlock_resources!
+
+    super
+
+  end
+
+
+  def put_resource!(obj, edge=nil)
+
+    inv { obj.unlocked? }
+
+    if supports? obj.class
+      @resources_added[obj.class] += 1
+      resources.add!(obj.lock!)
+      fire_triggers!
+    else
+      raise UnsupportedTypeError.new
+    end
+  end
+
+  def take_resource!(&expression)
+
+    unless block_given?
+      # if no conditions given, then anything goes.
+      expression = Proc.new{ |res| true }
+    end
+
+    raise RuntimeError.new unless resources.count_where(&expression) > 0
+
+    res=remove_resource! &expression
+
+    fire_triggers!
+
+    res
+
+  end
+
+  def to_s
+    "Pool '#{@name}':  #{@resources.to_s}"
+  end
+
+  # TODO this smells. where is this used? can i do without it?
+  def get_initial_resources(initial_value)
+    inv { !self.instance_variable_defined?(:@resources) }
+
+    bag = ResourceBag.new
+
+    if initial_value.is_a?(Fixnum)
+      initial_value.times { bag.add!(Token.new) }
+    elsif initial_value.is_a?(Hash)
+      initial_value.each do |type, quantity|
+        quantity.times { bag.add!(type.new) }
+      end
+    end
+
+    return bag
+
+  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
+
+  private
+
+  attr_reader :resources
+
+  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) }
+
+    @resources_removed[res.class] += 1
+
+    res
+  end
+
+  def add_resource!(res)
+
+    resources.add!(res) and @resources_added[res.type]+=1
+
+  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
+
+      edge.label.times do
+        begin
+          res = remove_resource!(&blk)
+        rescue => ex
+           # Failed to remove this resource. Let's try another Edge, perhaps?
+          break
+        end
+
+        edge.push!(res)
+
+      end
+
+    end
+  end
+
+  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
+
+      edge.label.times do
+        begin
+          res = edge.pull!(&blk)
+        rescue RuntimeError => ex
+          # Let's try another Edge, perhaps?
+          break
+        end
+
+        add_resource!(res.lock!)
+
+      end
+
+    end
+  end
+
+end

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

@@ -0,0 +1,96 @@
+require 'set'
+require_relative '../../domain/resources/token'
+require_relative '../../domain/nodes/node'
+
+class ResourcefulNode < Node
+
+  include Invariant
+
+  def initialize(hsh=nil)
+    @resources_added=Hash.new(0)
+    @resources_removed=Hash.new(0)
+  end
+
+  def initialize_copy(orig)
+    super
+
+    #need to clone the resource bag as well...
+    @resources = @resources.clone()
+
+    #don't need this. takes too much space
+    @diagram = nil
+
+  end
+
+# pools are about resources
+
+  def supports?(klass)
+    if klass.eql?(Token)
+      untyped?
+    else
+      #untyped nodes support everything.
+      if untyped?
+        true
+      else
+        typed? && types.include?(klass)
+      end
+    end
+  end
+
+  alias_method :support?, :supports?
+
+
+  def resources_added(klass=nil)
+    if klass.nil?
+      @resources_added.values.reduce(0) { |acc, elem| acc += elem }
+    else
+      @resources_added[klass]
+    end
+  end
+
+  def resources_removed(klass=nil)
+    if klass.nil?
+      @resources_removed.values.reduce(0) { |acc, elem| acc += elem }
+    else
+      @resources_removed[klass]
+    end
+  end
+
+  def commit!
+    super
+  end
+
+  def unlock_resources!
+    @resources.each_where { |r|
+      if r.locked?
+        r.unlock!
+      end
+    }
+  end
+
+  def trigger!
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+  def resource_count(type=nil)
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+  def push_any
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+  def push_all
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+  def pull_any
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+  def pull_all
+    raise NotImplementedError, "Please update class #{self.class} to respond to: :#{__callee__}"
+  end
+
+end
+