rachinations 0.0.3 → 0.0.4

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

@@ -0,0 +1,170 @@
+require_relative '../../domain/modules/common/refiners/proc_convenience_methods'
+require_relative '../../extras/constant_hash'
+
+module DSL
+
+  # This module helps with parsing arguments used in the DiagramShorthandMethods
+  module Parser
+    using ProcConvenienceMethods
+
+    ConstantHash = ::Extras::ConstantHash
+
+    # these patterns (*_EXPR) define what each argument should look like
+
+    IDENTIFIER_EXPR = proc { |arg| arg.is_a?(String) && valid_name?(arg) }
+
+    INITIAL_VALUE_EXPR = proc { |arg| arg.is_a? Fixnum }
+
+    MODE_EXPR = proc { |arg| [:pull_any, :pull_all, :push_any, :push_all].include? arg }
+
+    ACTIVATION_EXPR = proc { |arg| [:automatic, :passive, :start].include? arg }
+
+    PROC_EXPR = proc { |arg| arg.is_a? Proc }
+
+    # returns true for integers or floats
+    LABEL_EXPR = proc { |arg| arg.is_a? Numeric }
+
+    # 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|
+
+        # named parameters are expressed are hashes
+        # and all arguments can (also) be passed as named parameters
+        if arg.is_a? Hash
+          if arg.has_key? :condition
+            if PROC_EXPR.match? arg[:condition]
+              accumulator[:condition] = arg[:condition]
+            else
+              raise BadDSL.new
+            end
+          end
+
+          if arg.has_key? :triggered_by
+            if IDENTIFIER_EXPR.match? arg[:triggered_by]
+              accumulator[:triggered_by] = arg[:triggered_by]
+            else
+              raise BadDSL.new
+            end
+          end
+
+          if arg.has_key? :activation
+            if ACTIVATION_EXPR.match? arg[:activation]
+              accumulator[:activation] = arg[:activation]
+            else
+              raise BadDSL.new
+            end
+          end
+
+          if arg.has_key? :initial_value
+            if INITIAL_VALUE_EXPR.match? arg[:initial_value]
+              accumulator[:initial_value] = arg[:initial_value]
+            else
+              raise BadDSL.new
+            end
+          end
+
+          if arg.has_key? :mode
+            if MODE_EXPR.match? arg[:mode]
+              accumulator[:mode] = arg[:mode]
+            else
+              raise BadDSL.new
+            end
+          end
+
+        else
+          if IDENTIFIER_EXPR.match?(arg) # a node's name, if present, is always the first argument
+            accumulator[:name] = arg
+          elsif INITIAL_VALUE_EXPR.match?(arg)
+            accumulator[:initial_value] = arg
+          elsif MODE_EXPR.match?(arg)
+            accumulator[:mode] = arg
+          elsif ACTIVATION_EXPR.match?(arg)
+            accumulator[:activation] = arg
+          else
+            raise BadDSL, "Argument #{arg} doesn't fit any known signature"
+          end
+        end
+        # passing the accumulator onto the next iteration
+        accumulator
+      end
+    end
+
+    def self.parse_gate_arguments(arguments)
+
+      # mode is always pull_any so user can't choose it
+      # initial_value makes no sense for gates either
+      arguments.inject(ConstantHash.new) do |accumulator, arg|
+        if arg.is_a? Hash
+          if arg.has_key? :condition
+            accumulator[:condition] = arg[:condition] if PROC_EXPR.match?(arg[:condition])
+          elsif arg.has_key? :triggered_by
+            accumulator[:triggered_by] = arg[:triggered_by] if IDENTIFIER_EXPR.match?(arg[:triggered_by])
+          else
+            ra
+          end
+        else
+          if IDENTIFIER_EXPR.match?(arg)
+            accumulator[:name] = arg
+          elsif ACTIVATION_EXPR.match?(arg)
+            accumulator[:activation] = arg
+          else
+            raise BadDSL, "Argument #{arg} doesn't fit any known signature"
+          end
+        end
+        accumulator
+      end
+
+    end
+
+    def self.parse_edge_arguments(arguments)
+
+      arguments.inject(ConstantHash.new) do |accumulator, arg|
+        if IDENTIFIER_EXPR.match?(arg)
+          accumulator[:name] = arg
+        elsif LABEL_EXPR.match?(arg)
+          accumulator[:label]=arg
+        elsif arg.is_a? Hash
+
+          if arg.has_key? :from
+            accumulator[:from] = arg[:from]
+          end
+          if arg.has_key? :to
+            accumulator[:to] = arg[:to]
+          end
+          if arg.has_key? :label
+            accumulator[:label] = arg[:label]
+          end
+        else
+          raise BadDSL, "Argument #{arg} doesn't fit any known signature."
+        end
+        accumulator
+      end
+
+    end
+
+    # Used to validate that a string is a valid name for diagram components
+    #
+    # @param [String] text the name we want to validate
+    # @raise [BadDSL] if given text is not a valid name
+    # @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)
+        text
+      else
+        raise BadDSL, "Invalid name: '#{text}'"
+      end
+    end
+
+    # @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)
+    end
+
+  end
+
+end

data/lib/rachinations/extras/constant_hash.rb

@@ -0,0 +1,25 @@
+module Extras
+
+  # A normal hash except that it raises RuntimeErrors
+  #  if a key gets assigned twice
+  class ConstantHash < Hash
+
+    def []=(key, value)
+
+      if has_key?(key)
+        raise RuntimeError, "key :#{key} has already been set"
+      end
+
+      super
+    end
+
+    def store(key, value)
+      if has_key?(key)
+        raise RuntimeError, "key :#{key} has already been set"
+      end
+
+      super
+    end
+
+  end
+end

data/lib/rachinations/extras/fifo.rb

@@ -1,27 +1,33 @@
 require 'forwardable'
 
-class Fifo
-  extend Forwardable
+module Extras
 
-  def_delegators :@store, :length
+  # A class that provides a queue-like (first-in, first-out)
+  #  structure to clients
+  class Fifo
+    extend Forwardable
 
-  def initialize
-    @store = Array.new
-  end
+    def_delegators :@store, :length
 
-  # Puts an object into the queue
-  #
-  # @param [Object] obj
-  # @return [Fifo] The queue itself.
-  def put!(obj)
-    @store.push(obj)
-    self
-  end
+    def initialize
+      @store = Array.new
+    end
 
-  # Takes the least recently added element.
-  #
-  # @return [Object] whatever was stored in this queue.
-  def take!
-    @store.shift
+    # Puts an object into the queue
+    #
+    # @param [Object] obj
+    # @return [Fifo] The queue itself.
+    def put!(obj)
+      @store.push(obj)
+      self
+    end
+
+    # Takes the least recently added element.
+    #
+    # @return [Object] whatever was stored in this queue.
+    def take!
+      @store.shift
+    end
   end
+
 end

data/lib/rachinations/helpers/edge_helper.rb

@@ -0,0 +1,40 @@
+module Helpers
+  module EdgeHelper
+
+    # Returns true if all edges passed as arguments can execute a push
+    #  when called in the same round. The difference between calling this
+    #  method and calling Edge#test_ping? on each edge is that this method
+    #  knows that each edge removes at least one Resource when it performs
+    #  a push.
+    # @param [Array<Edge>] edges the edges
+    # @param [Boolean] require_all whether to require that the maximum amount
+    #  of resources supported by each edge (i.e. its label) be available in
+    #  order to succeed.
+    # @return [Boolean]
+    def self.all_can_push?(edges, require_all: false)
+      initial = {
+          partial_success: true,
+          number_of_resources: 0
+      }
+
+      raise NotImplementedError, 'only require_all is implemented so far' unless require_all
+
+      final = edges.inject(initial) do |accumulator, edge|
+        accumulator[:number_of_resources] += edge.label
+
+        resources_available = edge.from.resource_count(expr: edge.push_expression)
+
+        if resources_available >= accumulator[:number_of_resources]
+          accumulator[:partial_success] &&= true
+        else
+          accumulator[:partial_success] &&= false
+        end
+        accumulator
+      end
+
+      final[:partial_success]
+
+    end
+
+  end
+end

data/lib/rachinations/utils/string_helper.rb

@@ -0,0 +1,7 @@
+module StringHelper
+
+  def self.valid_ruby_variable_name?(str)
+    (/^[a-z_][a-zA-Z_0-9]*$/ =~ str) == 0
+  end
+
+end

data/lib/rachinations/version.rb

@@ -1,3 +1,3 @@
 module Rachinations
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/rachinations.rb

@@ -2,23 +2,26 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rachinations/version'
 
-
-
 require 'rachinations/domain/modules/common/refiners/proc_convenience_methods'
+require 'rachinations/domain/modules/common/refiners/number_modifiers'
+
 require 'rachinations/extras/fifo'
 
 require 'rachinations/domain/diagrams/diagram'
 require 'rachinations/domain/diagrams/verbose_diagram'
-require 'rachinations/dsl/dsl'
+require 'rachinations/dsl/diagram_shorthand_methods'
+require 'rachinations/dsl/bootstrap'
 require 'rachinations/domain/strategies/strategy'
 require 'rachinations/domain/strategies/valid_types'
-require 'rachinations/domain/edges/random_edge'
 require 'rachinations/domain/edges/edge'
+
 require 'rachinations/domain/exceptions/no_elements_of_given_type'
 require 'rachinations/domain/exceptions/unsupported_type_error'
 require 'rachinations/domain/exceptions/bad_options'
 require 'rachinations/domain/exceptions/no_elements_matching_condition_error'
 require 'rachinations/domain/exceptions/no_elements_found'
+require 'rachinations/dsl/bad_dsl'
+
 require 'rachinations/domain/nodes/node'
 require 'rachinations/domain/nodes/resourceful_node'
 require 'rachinations/domain/nodes/pool'
@@ -33,4 +36,9 @@ require 'rachinations/domain/node_collection'
 require 'rachinations/domain/resource_bag'
 
 
-include DSL
+# users can call .percent on integers
+#using NumberModifiers
+
+# users can use the dsl to create diagrams
+include DSL::Bootstrap
+using DSL::DiagramShorthandMethods

data/rachinations.gemspec

@@ -9,9 +9,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Felipe Almeida"]
   spec.email         = ["falmeida1988@gmail.com"]
   spec.summary       = %q{Ruby port for Dr. J. Dormans' Machinations Game Mechanics Diagrams.}
-  spec.description   = %q{This project provides a Ruby-based DSL to enable game designers to
+  spec.description   = %q{This project provides a Ruby-based DiagramShorthandMethods to enable game designers to
 design and also test tentative game designs and/or prototypes}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/queirozfcom/rachinations"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -30,5 +30,6 @@ design and also test tentative game designs and/or prototypes}
 
   spec.add_dependency "activesupport","3.0.0"
   spec.add_dependency "i18n","0.6.11"
+  spec.add_dependency "weighted_distribution"
 
 end

data/testing/simulations/modelo1.rb

@@ -4,7 +4,7 @@ require_relative '../../domain/nodes/pool'
 require_relative '../../domain/nodes/source'
 require_relative '../../domain/edges/edge'
 
-include DSL
+include DiagramShorthandMethods
 
 n=diagram 'test_diagram' , :verbose do
   node 'source', Source

data/testing/simulations/sequencial.rb

@@ -2,7 +2,7 @@ require_relative '../../domain/diagrams/diagram'
 require_relative '../../dsl/dsl'
 require_relative '../../domain/nodes/pool'
 require_relative '../../domain/edges/edge'
-include DSL
+include DiagramShorthandMethods
 
 n=diagram 'test_diagram', :verbose do
   node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8

data/testing/simulations/sobonito.rb

@@ -3,7 +3,7 @@ require_relative '../../dsl/dsl'
 require_relative '../../domain/nodes/pool'
 require_relative '../../domain/edges/edge'
 
-include DSL
+include DiagramShorthandMethods
 
 n=diagram 'test_diagram',:verbose do
   node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8

data/testing/simulations/sobonitowhile.rb

@@ -2,7 +2,7 @@ require_relative '../../domain/diagrams/diagram'
 require_relative '../../dsl/dsl'
 require_relative '../../domain/nodes/pool'
 require_relative '../../domain/edges/edge'
-include DSL
+include DiagramShorthandMethods
 
 n=diagram 'test_diagram', :verbose do
   node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8

data/testing/simulations/whatIwish1.rb

@@ -1,6 +1,6 @@
 require_relative '../domain/diagram'
-require_relative '../dsl/dsl.rb'
-include DSL
+require_relative '../dsl/diagram_shorthand_methods.rb'
+include DiagramShorthandMethods
 
 n=diagram 'test_diagram' do
   node 'source', Source

data/testing/spec/canon/conditions_spec.rb

@@ -15,14 +15,13 @@ describe 'Nodes that can be given conditions' do
         :initial_value => 0
     }
 
-
     d.add_edge! Edge, {
         :name => 'connector',
         :from => 'source',
         :to => 'deposit'
     }
 
-    d.get_node('source').attach_condition(lambda { false })
+    d.get_node('source').attach_condition{ false }
 
     d.run!(10)
 
@@ -53,7 +52,7 @@ describe 'Nodes that can be given conditions' do
         :to => 'deposit'
     }
 
-    d.get_node('source').attach_condition(lambda { d.get_node('deposit').resource_count < 3 })
+    d.get_node('source').attach_condition { d.get_node('deposit').resource_count < 3 }
 
     d.run!(10)
 
@@ -82,7 +81,7 @@ describe 'Nodes that can be given conditions' do
         :to => 'deposit'
     }
 
-    d.get_node('deposit').attach_condition(lambda { d.get_node('deposit').resource_count < 3 })
+    d.get_node('deposit').attach_condition { d.get_node('deposit').resource_count < 3 }
 
     d.run!(10)
 

data/testing/spec/converter_spec.rb

@@ -96,7 +96,6 @@ describe Converter do
 
         expect(@c).to receive(:in_conditions_met?).and_return(true)
 
-
         expect(@edge_out).to receive(:test_push?).and_return(true)
         expect(@edge_out).to receive(:push_expression).and_return(proc{true})
         expect(@edge_out).to receive(:push!)
@@ -119,13 +118,13 @@ describe Converter do
 
       it 'pushes and pulls if all edges (incoming and outgoing) can push and pull, respectively' do
 
-        expect(@edge_in).to receive(:test_pull?).with(true).and_return(true)
+        expect(@edge_in).to receive(:test_pull?).with(require_all:true).and_return(true)
         expect(@edge_in).to receive(:pull!)
 
-        expect(@edge_in2).to receive(:test_pull?).with(true).and_return(true)
+        expect(@edge_in2).to receive(:test_pull?).with(require_all:true).and_return(true)
         expect(@edge_in2).to receive(:pull!)
 
-        expect(@edge_out).to receive(:test_push?).with(true).and_return(true)
+        expect(@edge_out).to receive(:test_push?).with(require_all:true).and_return(true)
         expect(@edge_out).to receive(:push!)