MonkeyEngine 1.0.0

data/lib/MonkeyManager.rb

@@ -0,0 +1 @@
+require_relative 'MonkeyManager/monkey_manager'

data/lib/MonkeyManager/monkey_manager.rb

@@ -0,0 +1,162 @@
+require 'singleton'
+require 'forwardable'
+
+module MonkeyEngine
+
+  # The MonkeyManager.
+  #
+  # This class provides the functionality needed to manage Monkeys (See Monkey, MonkeyService)
+  #
+  class MonkeyManager
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@monkeys, :each
+
+    include Singleton
+
+    # The constructor
+    #
+    def initialize
+      @monkeys = Array.new
+    end
+
+    public
+
+    # Adds the Monkey to the list of Monkeys to be managed.
+    #
+    # @param (Monkey, #read) monkey The Monkey to add.
+    #
+    # @return [Monkey] the Monkey added.
+    #
+    # @raise [MonkeyEngine::Exceptions::InvalidArgumentTypeException] if parameter monkey is not a Monkey object.
+    # @raise [MonkeyEngine::Exceptions::UniqueObjectException] if monkey already exists.
+    #
+    def add(monkey)
+      raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "Parameter 'monkey' is not Monkey object" unless monkey.is_a? Monkey
+      raise MonkeyEngine::Exceptions::UniqueObjectException.new "Monkeys must be unique" if exists? monkey
+
+      @monkeys.push(monkey)
+      monkey
+    end
+
+    # Returns the total count of Monkey objects being managed by this MonkeyManager.
+    #
+    # @return [int] The Monkey count.
+    #
+    def count
+      @monkeys.count
+    end
+
+    # Returns a [Boolean] indicating whether or not the Monkey exists (e.g. is currently being managed by this MonkeyManager).
+    #
+    # @param [Monkey, #read] monkey The Monkey to check.
+    #
+    # @return [Boolean] true if the Monkey is currently being manager by this MonkeyManager, false otherwise.
+    #
+    def exists?(monkey)
+      true unless get(monkey).nil?
+    end
+
+    # Returns a [Boolean] indicating whether or not the Monkey is alive (Monkey#alive?).
+    #
+    # @param [Monkey] monkey The Monkey to check.
+    #
+    # @return [Boolean] true if the Monkey is currently active (Monkey#.alive?), false otherwise.
+    #
+    def alive?(monkey)
+      monkey = get(monkey)
+      monkey.alive? unless monkey.nil?
+    end
+
+    # Returns the Monkey indicated by *monkey*.
+    #
+    # @param [Monkey, Symbol, String, #read] monkey The Monkey to return.
+    #
+    # @note Monkey#monkey_symbol is interrogated. If *monkey* is a [Monkey] object, Monkey#monkey_symbol is used;
+    #    if *monkey* is a [Symbol], it is used; if *monkey* is a [String], String#to_sym is used.
+    #
+    # @return [Monkey] The Monkey if it exists.
+    #
+    # @raise [MonkeyEngine::Exceptions::InvalidArgumentTypeException] if parameter monkey is not a Monkey, Symbol, or String object.
+    #
+    def get(monkey)
+      return nil if @monkeys.empty?
+
+      # TODO: This seems inefficient.
+      return @monkeys.select { |m| m.monkey_symbol == monkey }.first if monkey.is_a? Symbol
+      return @monkeys.select { |m| m.monkey_symbol == monkey.to_sym }.first if monkey.is_a? String
+      return @monkeys.select { |m| m.monkey_symbol == monkey.monkey_symbol }.first if monkey.is_a? Monkey
+
+      raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "Parameter 'monkey' is not a Symbol, String or Monkey object"
+    end
+
+    # Returns a duplicate Array of Monkey objects managed by this MonkeyManager.
+    #
+    # @return [Array] An Array of Monkey objects managed by this MonkeyManager.
+    #
+    def get_all
+      @monkeys.dup
+    end
+
+    # Removes the Monkey from the list of Monkeys being managed by this MonkeyManager.
+    #
+    # @param [Monkey] monkey The Monkey to delete.
+    #
+    # @note The Monkey to be deleted becomes unmanaged; the Monkey is NOT killed (Monkey#kill)
+    #
+    # @return [Monkey, nil] Returns the deleted Monkey, or nil if no matching Monkey was found to delete.
+    #
+    def delete(monkey)
+      @monkeys.delete(monkey)
+    end
+
+    # Suspends the calling threads execution until all Monkey threads exit, or,
+    # until _limit_ seconds have passed.
+    #
+    # @param [int] limit The seconds to wait for all Monkey threads to exit, or _nil_ to
+    #   wait indefinitely.
+    #
+    # @return [Array, nil] Returns an [Array] of Monkey objects, or, nil, if no Monkey objects are being managed by
+    #    this MonkeyManager.
+    #
+    def join_all(limit=nil)
+      limit = 0 unless limit.nil?
+      @monkeys.each { |monkey| monkey.join limit } unless @monkeys.empty?
+    end
+
+    # Kills the monkey.
+    #
+    # @param [Monkey, #read/#write, Symbol, String] monkey the Monkey to kill.
+    #
+    # @note The Monkey#monkey_do method executed continually by Monkey#thread is
+    #  terminated.
+    #
+    # @return [Monkey] the Monkey that was killed.
+    #
+    def kill!(monkey)
+      monkey = get(monkey)
+      return if monkey.nil?
+
+      @monkeys.delete(monkey)
+      monkey.kill
+
+      monkey
+    end
+
+    # Kills all monkeys managed by this MonkeyManager.
+    #
+    # @note The Monkey#monkey_do method executed continually by Monkey#thread, for each Monkey is
+    #  terminated.
+    #
+    # @return [Array] an Array of Monkey objects that were killed.
+    #
+    def kill_all!
+      @monkeys.each { |monkey| monkey.kill } unless @monkeys.empty?
+      monkeys = @monkeys.dup
+      @monkeys.clear
+
+      monkeys
+    end
+  end
+end

data/lib/MonkeyService.rb

@@ -0,0 +1 @@
+require_relative 'MonkeyService/monkey_service'

data/lib/MonkeyService/monkey_service.rb

@@ -0,0 +1,137 @@
+require 'singleton'
+require 'observer'
+require 'forwardable'
+
+require 'Monkey'
+require 'MonkeyEngine'
+require 'MonkeyManager'
+
+module MonkeyEngine
+
+  # The monkey service.
+  #
+  # Provides the main interface for all functionality relating to
+  # the MonkeyEngine (see MonkeyEngine) and this gem. This class wraps
+  # MonkeyManager and MonkeyEngine classes.
+  #
+  class MonkeyService
+    include Singleton
+    include Observable
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@monkey_manager, :alive?, :get, :get_all, :count, :exists?, :join_all
+
+    def initialize
+      @monkey_manager = MonkeyEngine::MonkeyManager.instance
+      @engine = MonkeyEngine::Engine.instance
+    end
+
+    # Adds the Monkey to be managed.
+    #
+    # @param [Monkey, #read] monkey the Monkey to add.
+    #
+    # @note Observers are notified after this operation in the form of these update method params:
+    #  ObserverKlass#update(param1, param2, param3); where param1=Time of the operation,
+    #  param2=Symbol representing the operation (in this case, :add), param3=The following Hash:
+    #  {monkey: [monkey]} where monkey=The Monkey added.
+    #
+    def add(monkey)
+      @monkey_manager.add(monkey).start
+      do_notify_observers(:add, {monkey: monkey})
+    end
+
+    # Determines if any Monkeys that are being managed by the
+    # underlining MonkeyManager are alive.
+    #
+    # @note A Monkey is considered alive if the Monkey#thread.alive? is true.
+    #
+    # @return [Boolean] true if any Monkeys are alive, false otherwise.
+    #
+    def any_alive?
+      return false if @monkey_manager.count == 0
+
+      alive_count = 0
+
+      @monkey_manager.each { |monkey| alive_count += 1 if monkey.alive? }
+
+      alive_count > 0
+    end
+
+    # Kills the monkey.
+    #
+    # @param [Monkey, #read/#write] monkey the Monkey to kill.
+    #
+    # @note The Monkey#monkey_do method executed continually by Monkey#thread is
+    #  terminated.
+    #
+    # @note Observers are notified after this operation in the form of these update method params:
+    #  ObserverKlass#update(param1, param2, param3); where param1=Time of the operation,
+    #  param2=Symbol representing the operation (in this case, :kill!), param3=The following Hash:
+    #  {monkey: [monkey]} where monkey=The Monkey killed.
+    #
+    def kill!(monkey)
+      @monkey_manager.kill!(monkey)
+      do_notify_observers(:kill!, {monkey: monkey})
+    end
+
+    # Kills all monkeys managed by the underlying MonkeyManager.
+    #
+    # @note The Monkey#monkey_do method executed continually by Monkey#thread, for each Monkey is
+    #  terminated.
+    #
+    # @note Observers are notified after this operation in the form of these update method params:
+    #  ObserverKlass#update(param1, param2, param3); where param1=Time of the operation,
+    #  param2=Symbol representing the operation (in this case, :kill_all!), param3=nil.
+    #
+    # @return [Array] an Array of Monkey objects that were killed.
+    #
+    def kill_all!
+      monkey_array = @monkey_manager.kill_all!
+      do_notify_observers(:kill_all!, nil)
+      monkey_array
+    end
+
+    def new_action(monkey)
+      @engine.new_action monkey
+    end
+
+    # Performs the action against the Monkey associated with this action.
+    #
+    # @param [MonkeyActionDead, MonkeyActionEat, MonkeyActionPause, MonkeyActionSleep, MonkeyActionType, MonkeyActionWake, etc., #read/#write]
+    #  action the action to apply against the Monkey associated with this action.
+    #
+    # @note Observers are notified after this operation in the form of these update method params:
+    #  ObserverKlass#update(param1, param2, param3); where param1=Time of the operation,
+    #  param2=Symbol representing the operation (in this case, :action_complete), param3=The following Hash:
+    #  {action: [action]} where action=The action that was completed.
+    #
+    # @return (Boolean) true if the action performed has been completed (Action#action_completed?), false otherwise.
+    #
+    def monkey_do(action)
+      do_notify_observers(:action_completed, {action: action}) if @engine.do_action action
+    end
+
+    # Evaluates the given action, to determine whether or not the action is completed (Action#action_completed?).
+    #
+    # @param [MonkeyActionDead, MonkeyActionEat, MonkeyActionPause, MonkeyActionSleep, MonkeyActionType, MonkeyActionWake, etc., #read]
+    #  action the action to interrogate as to whether or not it is completed (Action#action_completed?).
+    #
+    # @return (Boolean) true if the action is completed (Action#action_completed?), false otherwise.
+    #
+    def action_eval!(action)
+      @engine.action_eval! action
+    end
+
+    private
+
+    # Notifies all observers.
+    #
+    def do_notify_observers(param1, param2)
+      changed
+      notify_observers(Time.now, param1, param2)
+    end
+
+  end
+
+end

data/lib/tasks/engine.rb

@@ -0,0 +1,91 @@
+require 'pry'
+
+require 'yaml'
+require "minitest/autorun"
+require 'LittleWeasel'
+
+require File.expand_path('../../MonkeyFactory', __FILE__)
+require File.expand_path('../../MonkeyEngine', __FILE__)
+
+module Runner
+  
+  class MonkeyRun
+    attr_reader :monkey_service, :runtime, :thread, :words
+
+    def initialize(monkey_service, runtime)
+      @words = Array.new
+      @monkey_service = monkey_service
+      @runtime = runtime.to_i
+
+      @monkey_service.add_observer self
+
+      @thread = Thread.new {
+        go
+        sleep @runtime
+      }
+
+      self
+    end
+
+    #protected
+
+    def go
+      @monkey_service.add(MonkeyFactory::create :groucho)
+      @monkey_service.add(MonkeyFactory::create :harpo)
+      @monkey_service.add(MonkeyFactory::create :chico)
+      @monkey_service.add(MonkeyFactory::create :zeppo)
+    end
+
+    def update(time, action, param)
+      begin
+
+        return unless param.is_a?(Hash) && param.has_key?(:action)
+
+        if param[:action].is_a?(MonkeyActionType) && action == :action_completed
+        
+          monkey = param[:action].monkey.monkey_symbol.to_s
+          is_word = param[:action].keyboard_input.is_word
+          word = param[:action].keyboard_input.input_to_s
+
+          #if param[:action].is_a?(MonkeyActionType) && action == :action_completed
+            puts "Monkey: [#{monkey.capitalize}] | Is Word: [#{is_word}] | Value: [#{word.capitalize}]"
+          #end
+
+          if is_word
+            @words << { word: word, monkey: monkey }
+          end
+        end
+      rescue Exception => e
+        puts "Exception: #{e}"
+      end
+    end
+  end
+end
+
+
+namespace :engine do
+  desc "Run the MonkeyEngine"
+  task :run do
+    runtime = 10 #ARGV[0]
+
+    service = MonkeyEngine::MonkeyService.instance
+
+    LittleWeasel::Checker.instance.options = {exclude_alphabet: true, strip_whitespace: false, ignore_numeric: false}
+
+    runner = Runner::MonkeyRun.new service, runtime
+    runner.thread.join
+
+    service.kill_all!
+    service.join_all(10)
+
+    puts "Total valid words: #{runner.words.count}"
+
+    runner.words.sort!{|a,b| a[:monkey]<=>b[:monkey]}
+
+    runner.words.each { |word|
+      puts "Monkey [#{word[:monkey].capitalize}] typed [#{word[:word].capitalize}]"
+    }
+  end
+end
+
+

data/monkeyengine.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'MonkeyEngine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "MonkeyEngine"
+  spec.version       = MonkeyEngine::VERSION
+  spec.authors       = ["Gene M. Angelo, Jr."]
+  spec.email         = ["public.gma@gmail.com"]
+  spec.description   = %q{MonkeyEngine - FUN!}
+  spec.summary       = %q{The engine that drives my monkeys!}
+  spec.homepage      = "http://www.geneangelo.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '~> 2.1' 
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake', '~> 0'
+  spec.add_development_dependency 'rspec', '~> 3.0', '>= 3.0.0'
+  spec.add_development_dependency 'yard', '0.8.6.2'
+  spec.add_development_dependency 'redcarpet', '~> 2.3', '>= 2.3.0'
+  spec.add_development_dependency 'pry'
+
+  spec.add_runtime_dependency 'LittleWeasel', '~> 3.0'
+  spec.add_runtime_dependency 'ProtectedConstructor', '~> 2.0', '>=2.0.0'
+end

data/spec/action_rules_spec.rb

@@ -0,0 +1,59 @@
+require_relative 'spec_helpers'
+
+require 'Monkey'
+require 'MonkeyFactory'
+require 'MonkeyEngine'
+require 'MonkeyManager'
+require 'MonkeyActions'
+require_relative '../lib/MonkeyKeyboard/keyboard_input'
+
+describe 'ActionRules' do
+
+  before(:each) do
+  end
+
+  after(:all) do
+  end
+
+  context 'get_next_action' do
+
+    it 'should throw an exception if the action is not completed' do
+      monkey = MonkeyFactory::create :groucho
+
+      monkey.extend(SpecHelpers::SetMonkeyAction)
+
+      keyboard_input = KeyboardInput.new
+      keyboard_input.input = %w{H e l l o}
+
+      action = MonkeyActionType.new(monkey, keyboard_input)
+      action.action_completed = false
+
+      monkey.set_action(action)
+
+      lambda { ActionRules.instance.get_next_action monkey }.should raise_error MonkeyEngine::Exceptions::InvalidOperationException
+    end
+
+    it 'should get correct action if current action is nil?' do
+      monkey = MonkeyFactory::create :groucho
+
+      monkey.extend(SpecHelpers::SetMonkeyAction)
+
+      monkey.set_action(nil)
+
+      ActionRules.instance.get_next_action(monkey).is_a?(MonkeyActionWake).should == true
+    end
+
+    it 'should get correct action if current action is MonkeyActionSleep' do
+      monkey = MonkeyFactory::create :groucho
+
+      monkey.extend(SpecHelpers::SetMonkeyAction)
+
+      action = MonkeyActionSleep.new(monkey, 6 * 60)
+      action.action_completed = true
+
+      monkey.set_action(action)
+
+      ActionRules.instance.get_next_action(monkey).is_a?(MonkeyActionWake).should == true
+    end
+  end
+end