angry_mob 0.1.0

data/lib/angry_mob/target.rb

@@ -0,0 +1,257 @@
+require "angry_mob/target/tracking"
+
+class AngryMob
+  class TargetError < StandardError; end
+  class Target
+    autoload :Mother  , 'angry_mob/target/mother'
+    autoload :Call    , 'angry_mob/target/call'
+    autoload :Defaults, "angry_mob/target/defaults"
+    autoload :Notify  , "angry_mob/target/notify"
+    autoload :Arguments, "angry_mob/target/arguments"
+
+    autoload :DefaultResourceLocator, "angry_mob/target/default_resource_locator"
+
+    include Tracking
+
+    # Ok lets define some class level helpings.
+    class << self
+      def default_action
+        @set_default_action = true
+      end
+
+      def actions
+        @actions ||= ['nothing']
+      end
+      def all_actions
+        @all_actions ||= from_superclass(:all_actions, ['nothing'])
+        @all_actions |= actions
+      end
+
+      def default_action_name
+        @default_action
+      end
+
+
+      # Based on the args, makes a unique key for a target instance.
+      # This could be overridden by subclasses.
+      def instance_key(args)
+        args.key
+      end
+
+      protected
+      def create_action(method)
+        return if self == AngryMob::Target # XXX protect methods properly and remove this
+
+        if @set_default_action && @default_action
+          raise ArgumentError, "#{nickname}() can only have one default_action"
+        end
+
+        @default_action = method.to_s if @set_default_action
+        actions << method.to_s
+
+        @set_default_action = nil
+      end
+
+      def baseclass #:nodoc:
+        AngryMob::Target
+      end
+
+    end # class << self
+
+    def nickname
+      self.class.nickname
+    end
+
+    attr_reader :args, :current_action
+    attr_accessor :act
+
+    def mob; act.mob end
+    def ui ; mob.ui  end
+
+    def log(message); mob.ui.log message end
+
+    #### Call generation
+
+    # nothing actions are no-ops but by being called, prevent the default action being called
+    def nothing(*)
+      false
+    end
+
+
+    #### Definition-time helpers
+    def to_s
+      if default_object
+        "#{nickname}(#{default_object})"
+      else
+        "#{nickname}()"
+      end
+    end
+
+
+    # Executes actions with full context and all the trimmings.
+    def noticing_changes(args,&blk)
+      reset!
+      @args = args
+
+      ui.push(to_s) do
+        do_validation!
+
+        before_state
+        before_call if respond_to?(:before_call)
+
+        ui.debug "before_state=#{before_state.inspect}"
+
+        if skip?
+          ui.skipped! "skipping"
+          return
+        end
+
+        # Here's the core of the target:
+        if node.dry_run?
+          ui.skipped! "DRY RUN: skipping action"
+          return
+        else
+          # riiight here:
+          yield
+        end
+
+        ui.debug "after_state=#{state.inspect}"
+
+        # If the state's changed, let it be known
+        if state_changed?
+          changed 
+          notify
+          ui.ok!
+        else
+          ui.skipped! "target didn't change"
+        end
+      
+      end
+      self
+    end
+
+    # Has the state changed?
+    #   dir("/tmp/config").changed? && sh("echo it changed")
+    def changed?
+      state_changed?
+    end
+
+
+    protected
+
+    def reset!
+      @skip = nil
+      @args = nil
+    end
+
+    def skip!
+      @skip = true
+    end
+
+    def skip?
+      !! @skip
+    end
+
+    #### Runtime
+
+    # Do some very basic runtime validation. This validation is bound very late!
+    def do_validation!
+      validate!
+      unless @problems.blank?
+        @problems.each {|p| ui.error "problem: #{p}"}
+        raise "target[#{nickname}] wasn't valid"
+      end
+    end
+
+    # Targets should override this (possibly calling super) to do their own validation.
+    def validate!
+      problem!("The default object wasn't set") if default_object.blank?
+    end
+
+    # Flag a validation problem.
+    def problem!(problem)
+      @problems ||= []
+      @problems << problem
+    end
+
+
+    # Calculate and cache the state before any actions have been performed.
+    def before_state
+      @before_state ||= state
+    end
+
+
+
+    def node
+      mob.node
+    end
+
+    def mk_notify
+      Notify.new(act)
+    end
+
+    # Called when the state has changed.
+    # Very simply delegates notification to the target scheduler
+    def notify
+      mob.notifier.notify( args.notify ) if args.notify
+    end
+
+    # Give the target itself a neat place to react to changes.
+    # Default implementation is a no-op.
+    def changed
+      ui.log "target changed"
+      # no-op
+    end
+
+    # has the state changed?
+    def state_changed?
+      before_state != state
+    end
+
+    # Returns the state of the target.
+    # Default implementation is a random number (i.e. it always changes)
+    def state
+      {
+        :rand => rand
+      }
+    end
+
+    # returns the default object
+    # targets can customise this
+    # the default is the default_object argument. 
+    # See #initialize for how the default_option argument is set.
+    def default_object(clear=false)
+      @default_object = nil if clear
+      @default_object ||= default_object!
+    end
+
+    def default_object!
+      return unless args
+
+      case args.default_object
+      when Proc
+        args.default_object[]
+      else
+        args.default_object
+      end
+    end
+
+    # delegates to the node's resource locator
+    def resource(name)
+      node.resource_locator[self,name]
+    end
+
+    def log(message="")
+      ui.log(message)
+    end
+
+    # delegate to the default object
+    def method_missing(method,*args,&blk)
+      if (dobj = default_object) && dobj.respond_to?(method)
+        dobj.send(method,*args,&blk)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/angry_mob/target/arguments.rb

@@ -0,0 +1,71 @@
+class AngryMob
+  class Target
+    class Arguments
+      attr_reader :args, :actions
+
+      def initialize(*args,&blk)
+        @args = extract_args(args,&blk)
+        extract_actions!
+      end
+
+      def self.parse(input,&blk)
+        case input
+        when Arguments
+          input
+        when Array
+          if input.size == 1 && Arguments === input.first
+            input.first
+          else
+            self.new(input,&blk)
+          end
+        else
+          self.new(input,&blk)
+        end
+      end
+
+      # update args without updating actions too
+      def update_preserving_actions(other_args)
+        other_args = self.class.parse(other_args)
+        @args.deep_update(other_args.args)
+        self
+      end
+
+      def method_missing(meth,*args,&block)
+        @args.send(meth,*args,&block)
+      end
+
+      def extract_actions!
+        @actions = [ @args.delete('actions'), @args.delete('action') ].norm.map {|s| s.to_s}
+      end
+      def actions=(array)
+        @actions = array.norm.map{|s| s.to_s}
+      end
+
+      def extract_args(args,&blk)
+        args.flatten!
+
+        case args.size
+        when 0,1
+          if Hash === args[0]
+            new_args = AngryHash.__convert_without_dup(args[0])
+            new_args.default_object = new_args
+          else
+            new_args = AngryHash.new
+            new_args.default_object = args[0]
+          end
+
+        when 2
+          new_args = AngryHash.__convert_without_dup(args[1])
+          new_args.default_object = args[0]
+
+        else
+          raise ArgumentError, "usage: nickname(default_object, [ :optional_hash_of => opts ])"
+        end
+
+        new_args.__eval_as_dsl(&blk) if block_given?
+
+        new_args
+      end
+    end
+  end
+end

data/lib/angry_mob/target/call.rb

@@ -0,0 +1,57 @@
+class AngryMob
+  class Target
+    class Call
+      attr_reader :args, :klass, :actions
+      attr_accessor :target
+
+      def initialize(klass,args)
+        @klass = klass
+        @args  = Arguments.parse(args)
+        validate_actions!
+      end
+
+      def self.instance_key(klass,args)
+        klass.instance_key(Arguments.parse(args))
+      end
+
+      def instance_key
+        self.class.instance_key(klass,args)
+      end
+
+      def add_args(new_args)
+        @args = Arguments.parse(new_args).update_preserving_actions(args)
+        validate_actions!
+      end
+
+      def merge_defaults(defaults)
+        args.reverse_deep_merge!(defaults)
+      end
+
+      def call(act, hints={})
+        target.act = act
+        target.noticing_changes(args) {
+          actions.each {|action|
+            target.send(action)
+          }
+        }
+      end
+
+      def nickname
+        klass.nickname
+      end
+
+      def validate_actions!
+        @actions = args.actions
+
+        extras = actions - klass.all_actions
+        raise(ArgumentError, "#{nickname}() unknown actions #{extras.inspect} known=#{klass.all_actions.inspect}") unless extras.empty? || extras == ['nothing']
+
+        actions << klass.default_action_name if actions.empty?
+
+        if actions.norm.empty?
+          raise ArgumentError, "#{klass.nickname}() no actions selected, and no default action defined"
+        end
+      end
+    end
+  end
+end

data/lib/angry_mob/target/default_resource_locator.rb

@@ -0,0 +1,11 @@
+class AngryMob
+  class Target
+    class DefaultResourceLocator
+      def resource(target,name)
+        path = target.act.definition_file.to_s.sub(/\.([^\.]+)$/,'')
+        (path.pathname + name.to_s)
+      end
+      alias_method :[], :resource
+    end
+  end
+end

data/lib/angry_mob/target/defaults.rb

@@ -0,0 +1,23 @@
+class AngryMob
+  class Target
+    class Defaults
+      def initialize
+        @contexts = Hash.new {|h,k| h[k] = []}
+      end
+
+      def defaults_for(name)
+        @contexts[name].last || {}
+        # TODO -> merge under some circumstances
+      end
+
+      def method_missing(method, *args, &blk)
+        @contexts[method] << args.first
+
+        if block_given?
+          yield
+          @contexts[method].pop
+        end
+      end
+    end
+  end
+end

data/lib/angry_mob/target/mother.rb

@@ -0,0 +1,66 @@
+class AngryMob
+  class Target
+    class Mother
+      attr_reader :mob
+
+      def initialize(mob)
+        @mob = mob
+      end
+
+      def target_classes
+        Target::Tracking.subclasses
+      end
+
+      def pose_as(nickname,nickname_to_pose_as)
+        nickname            = nickname.to_s
+        nickname_to_pose_as = nickname_to_pose_as.to_s
+
+        posing_class = target_classes[nickname           ] || raise(TargetError, "posing class '#{nickname}' doesn't exist!")
+        old_class    = target_classes[nickname_to_pose_as]
+
+        target_classes[nickname_to_pose_as] = posing_class
+
+        if old_class && instances = key_classes.delete(old_class)
+          # TODO - merge instances if required
+        end
+      end
+
+      def clear_instances!
+        @target_instances = nil
+      end
+
+      def target_instances
+        @target_instances ||= {}
+      end
+
+      def unkeyed_instances
+        @unkeyed_instances ||= []
+      end
+
+      def key_classes 
+        @key_classes ||= Hash.new {|h,k| h[k] = []}
+      end
+
+      def target_call(nickname, *args, &blk)
+        raise(MobError, "no target nicknamed '#{nickname}'\n#{target_classes.keys.inspect}") unless target_classes.key?(nickname.to_s)
+        klass = target_classes[nickname.to_s]
+
+        args = Arguments.parse(args,&blk)
+
+        if key = Target::Call.instance_key(klass,args)
+          if call = target_instances[key]
+            call.add_args(args)
+          else
+            call = target_instances[key] = Target::Call.new( klass, args )
+          end
+        else
+          unkeyed_instances << call = Target::Call.new( klass, args )
+        end
+
+        call.target ||= klass.new
+
+        call
+      end
+    end
+  end
+end