angry_mob 0.1.0

data/lib/angry_mob/extend/hash.rb

@@ -0,0 +1,67 @@
+class Hash
+	def delete_all_of(*keys)
+		keys = keys.map {|k| [ k.to_s, k.to_sym ]}.flatten.uniq
+		values = values_at(*keys).flatten.compact.uniq
+		keys.each {|k| delete k}
+		values
+	end
+
+  # from ActiveSupport:
+  #
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  def deep_merge(other_hash)
+    self.merge(other_hash) do |key, oldval, newval|
+      oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+      newval = newval.to_hash if newval.respond_to?(:to_hash)
+      oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? oldval.deep_merge(newval) : newval
+    end
+  end
+
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  # Modifies the receiver in place.
+  def deep_merge!(other_hash)
+    replace(deep_merge(other_hash))
+  end
+
+  # Return a new hash with all keys converted to symbols.
+    def symbolize_keys
+      inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
+        options
+      end
+    end
+
+    # Destructively convert all keys to symbols.
+    def symbolize_keys!
+      self.replace(self.symbolize_keys)
+    end
+
+    def deep_symbolize_keys
+      inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = __recurse_deep_symbolize_keys(value)
+      options
+      end
+    end
+
+    def __recurse_deep_symbolize_keys(value)
+      case value
+      when Hash
+        value.deep_symbolize_keys
+      when Array
+        value.map {|v| __recurse_deep_symbolize_keys(v)}
+      else
+        value
+      end
+    end
+    
+
+end
+
+class AngryHash
+    def delete_all_of(*keys)
+      keys.map {|k| delete(k.to_s)}.compact.uniq
+    end
+
+    require 'angry_hash/merge_string'
+    include AngryHash::MergeString
+end

data/lib/angry_mob/extend/object.rb

@@ -0,0 +1,21 @@
+require 'pp'
+
+class Object
+  def tapp(tag=nil)
+    print "#{tag}=" if tag
+    pp self
+    self
+	end
+
+	def stapp(tag=nil)
+    print "#{tag} " if tag
+		puts "c=#{self.class} i=#{self.inspect[0..100]}"
+    self
+	end
+
+
+	def returning(obj)
+		yield obj
+		obj
+	end
+end

data/lib/angry_mob/extend/pathname.rb

@@ -0,0 +1,23 @@
+require 'fileutils'
+
+class Pathname
+  def self.here(file)
+    Pathname(file).dirname.expand_path
+  end
+
+  def pathname
+    Pathname(self)
+  end
+
+  def touch
+    FileUtils.touch(self)
+  end
+
+  def cp_to(to)
+    FileUtils.cp(self,to)
+  end
+
+  def ls
+    Pathname.glob(self+'*').reject {|e| e.basename.to_s[0] == '.'}
+  end
+end

data/lib/angry_mob/extend/string.rb

@@ -0,0 +1,8 @@
+require 'pathname'
+
+class String
+  def pathname
+    Pathname(self)
+  end
+  alias_method :p, :pathname
+end

data/lib/angry_mob/log.rb

@@ -0,0 +1,28 @@
+class AngryMob
+	module Log
+
+		def __class_to_s
+			@__class_to_s ||= __class_to_s!
+		end
+		def __class_to_s!
+			@__class_to_s = self.class.to_s.sub(/^AngryMob::/,'AM::').sub(/^Target\[/,'T[')
+			@__class_to_s[0..19]
+		end
+
+		def log(*msg)
+			puts "  %-20s| #{msg * ' '}" % __class_to_s
+		rescue
+			puts "#{self.class.to_s} | #{msg * ' '}"
+    ensure
+      $stdout.flush
+		end
+
+		def debug(*msg)
+			puts "* %-20s| #{msg * ' '}" % __class_to_s
+		rescue
+			puts "Debug #{self.class.to_s} | #{msg * ' '}"
+    ensure
+      $stdout.flush
+		end
+	end
+end

data/lib/angry_mob/mob.rb

@@ -0,0 +1,77 @@
+class AngryMob
+  class MobError < StandardError; end
+  class Mob
+    attr_reader :node, :notifier, :act_scheduler, :target_mother
+
+    def initialize
+      @target_mother = Target::Mother.new(self)
+      @act_scheduler = Act::Scheduler.new(self)
+    end
+
+    # delegate to the curren ui
+    def self.ui
+      (@ui ||= ui!).current
+    end
+    def self.ui!
+      @ui = UI.new
+    end
+    def self.ui=(ui)
+      @ui = ui
+    end
+    def ui
+      self.class.ui
+    end
+
+    # main entry point the the whole system
+    def riot!(nodename, attributes)
+      start = Time.now
+      ui.info "An AngryMob is rioting on #{nodename}."
+
+      @node               = Node.new(nodename, attributes)
+      @act_scheduler.node = @node
+      @notifier           = Notifier.new(self)
+
+      setup!
+      run!
+
+      ui.info "beaten in #{Time.now-start}s"
+      ui.info "#{nodename} has been beaten by an AngryMob. Have a nice day!"
+
+      @target_mother.clear_instances!
+      @act_scheduler.reset!
+    end
+
+    # bind selected targets to the node
+    def setup!
+      ui.task "setting up node"
+      defaults = AngryHash.new
+
+      setup_node[node,defaults]       if setup_node
+      node_defaults[node,defaults]    if node_defaults
+      consolidate_node[node,defaults] if consolidate_node
+
+      node.setup_finished!
+
+      ui.good "setup complete"
+      
+      self
+    end
+
+    # runs acts and then delayed targets
+    def run!
+      act_scheduler.run!
+    end
+
+    # building
+    # builder populates the following with definition blocks
+
+    # node defaults
+    attr_accessor :setup_node, :consolidate_node, :node_defaults
+
+    # acts
+    def acts
+      @acts ||= Dictionary.new
+    end
+    
+  end
+end

data/lib/angry_mob/mob_loader.rb

@@ -0,0 +1,115 @@
+require 'tsort'
+
+class AngryMob
+  class MobLoadingError < StandardError; end
+
+  ::Target = AngryMob::Target
+
+  class MobLoader
+    attr_reader :builder, :mobs, :loaded_mobs
+
+    def ui
+      Mob.ui
+    end
+
+    def initialize
+      @builder = Builder.new
+      @mobs = Dictionary.new
+      @loaded_mobs = {}
+    end
+
+    def add_mob(path,name=nil)
+      path = Pathname(path).expand_path
+      name ||= path.basename.to_s
+
+      ui.log "added mob #{name} from #{path}"
+
+      mobs[name] ||= path
+    end
+
+    def load_a_mob(name)
+      path = mobs[name]
+      raise "unable to load unknown mob #{name}" unless path
+
+      return if loaded_mobs[name]
+      loaded_mobs[name] = true
+
+      old_path,@current_path = @current_path,path
+
+      ui.push("loading mob #{name} at path #{path}") do
+
+        mob_root = path
+
+        loader = path+'load_mob.rb'
+
+        if loader.exist?
+          instance_eval(loader.read,loader.to_s)
+        else
+          load_lib(path+'lib')
+          load_targets(path+'targets')
+          load_acts(path+'acts')
+        end
+      end
+
+      self
+    ensure
+      @current_path = old_path
+    end
+
+    def load_mobs
+      mobs.keys.each do |name|
+        load_a_mob(name)
+      end
+    end
+
+    def to_mob
+      load_mobs
+      @builder.to_mob
+    end
+
+
+    # API
+
+    alias_method :depends_on_mob, :load_a_mob
+
+    def load_targets(path=nil)
+      path ||= mob_root + 'targets'
+
+      raise "targets path #{path} didn't exist" unless path.exist?
+      ui.log "loading targets from #{path}"
+
+      $LOAD_PATH << path
+      Pathname.glob(path+'**/*.rb').each do |file|
+        require file
+      end
+    end
+
+    def load_lib(path=nil)
+      path ||= mob_root + 'lib'
+
+      raise "lib path #{path} didn't exist" unless path.exist?
+
+      ui.log "adding load path #{path}"
+      $LOAD_PATH << path
+    end
+
+    def load_acts(path=nil)
+      path ||= mob_root + 'acts'
+
+      raise "acts path #{path} didn't exist" unless path.exist?
+      ui.log "loading acts from #{path}"
+
+      Pathname.glob(path+'**/*.rb').each do |file|
+        @builder.from_file(file)
+      end
+    end
+
+    def load_act_file(path)
+      raise "act file at path #{path} didn't exist" unless path.exist?
+      ui.log "loading acts from #{path}"
+
+      @builder.from_file(path)
+    end
+
+  end
+end

data/lib/angry_mob/node.rb

@@ -0,0 +1,44 @@
+class AngryMob
+  class Node < Struct.new(:name,:attributes,:resource_locator)
+    include Log
+
+    def initialize(name, attributes)
+      self.name = name
+      self.attributes = AngryHash[attributes]
+    end
+
+    def merge_defaults!(attrs)
+      puts "merging defaults"
+      attributes.reverse_deep_merge!(attrs)
+    end
+
+    def setup_finished!
+      self.resource_locator ||= AngryMob::Target::DefaultResourceLocator.new
+    end
+
+    def consolidate!
+      node = self
+      __consolidate_hash(attributes,{})
+    end
+
+
+    def __consolidate_hash(hash,seen)
+
+      return if seen.key?(hash)
+      seen[hash] = true
+
+      hash.each do |key,value|
+        case value
+        when Hash
+          __consolidate_hash(value,seen)
+        when Proc
+          hash[key] = value[self]
+        end
+      end
+    end
+
+    def method_missing(method,*args,&block)
+      attributes.__send__(method,*args)
+    end
+  end
+end

data/lib/angry_mob/notifier.rb

@@ -0,0 +1,76 @@
+class AngryMob
+  class NotificationInspector
+    attr_reader :nickname, :options
+    def initialize(scheduler,nickname,options={},&block)
+      @scheduler,@nickname,@options = scheduler,nickname.to_s,options
+
+      unless notifications.empty?
+        yield_in_context(self,&block)
+      end
+    end
+
+    def yield_in_context(*args,&block)
+      if o = options[:context]
+        o.instance_exec(*args,&block)
+      else
+        block.call(*args)
+      end
+    end
+
+    def notifications
+      @notifications ||= @scheduler.notifications.select {|n| n.target == nickname}
+    end
+
+    def action?(*actions)
+      actions.norm!.all? {|action| notifications.any? {|n| n.actions.include?(action.to_s)}}
+    end
+
+    def select_and_run_action(actions, &block)
+      if matched = actions.find {|action| action?(action)}
+        yield_in_context matched, &block
+      end
+    end
+  end
+
+  class Notifier < Struct.new(:mob)
+    def ui; mob.ui end
+
+    # The list of delayed targets.
+    def notifications
+      @notifications ||= []
+    end
+
+    def for(nickname,options={},&block)
+      NotificationInspector.new(self,nickname,options,&block)
+    end
+
+    def select(&block); notifications.select(&block) end
+    def find(&block); notifications.find(&block) end
+    def any?(&block); notifications.any?(&block) end
+    def all?(&block); notifications.all?(&block) end
+
+    # queries
+    def include_nickname?(nickname)
+      nickname = nickname.to_s
+      notifications.any? {|n| n.target == nickname}
+    end
+
+    def __predicate_to_lambda()
+      args = Target::Arguments.parse(*args)
+    end
+
+    # Handles a notification, by either placing it on the queue or calling it now
+    def notify(notification)
+      if AngryMob::Target::Notify === notification
+        notifications << notification
+      elsif Proc === notification
+        notification[mob]
+      end
+    end
+
+    def schedule_notification(call)
+      notifications << call
+    end
+
+  end
+end