davidlee-state-fu 0.3.1 → 0.10.0

data/lib/state_fu/active_support_lite/blank.rb

@@ -1,4 +1,4 @@
-class Object
+class Object  #:nodoc:all
   # An object is blank if it's false, empty, or a whitespace string.
   # For example, "", "   ", +nil+, [], and {} are blank.
   #
@@ -9,49 +9,58 @@ class Object
   # to
   #
   #   if !address.blank?
+  #:nodoc
   def blank?
     respond_to?(:empty?) ? empty? : !self
   end
-    
+
   # An object is present if it's not blank.
+   #:nodoc
   def present?
     !blank?
   end
 end
 
-class NilClass #:nodoc:
+class NilClass #:nodoc
+   #:nodoc
   def blank?
     true
   end
 end
 
-class FalseClass #:nodoc:
+class FalseClass #:nodoc
+   #:nodoc
   def blank?
     true
   end
 end
 
-class TrueClass #:nodoc:
+class TrueClass #:nodoc
+   #:nodoc
   def blank?
     false
   end
 end
 
-class Array #:nodoc:
+class Array #:nodoc
+   #:nodoc
   alias_method :blank?, :empty?
 end
 
-class Hash #:nodoc:
+class Hash #:nodoc
+   #:nodoc
   alias_method :blank?, :empty?
 end
 
-class String #:nodoc:
+class String #:nodoc
+   #:nodoc
   def blank?
     self !~ /\S/
   end
 end
 
-class Numeric #:nodoc:
+class Numeric #:nodoc
+   #:nodoc
   def blank?
     false
   end

data/lib/state_fu/active_support_lite/cattr_reader.rb

@@ -6,7 +6,8 @@
 #  end
 #
 #  Person.hair_colors = [:brown, :black, :blonde, :red]
-class Class
+class Class  #:nodoc:all
+   #:nodoc
   def cattr_reader(*syms)
     syms.flatten.each do |sym|
       next if sym.is_a?(Hash)
@@ -26,6 +27,7 @@ class Class
     end
   end
 
+   #:nodoc
   def cattr_writer(*syms)
     options = syms.extract_options!
     syms.flatten.each do |sym|
@@ -47,6 +49,7 @@ class Class
     end
   end
 
+   #:nodoc
   def cattr_accessor(*syms)
     cattr_reader(*syms)
     cattr_writer(*syms)

data/lib/state_fu/active_support_lite/keys.rb

@@ -1,8 +1,9 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Hash #:nodoc:
+module ActiveSupport #:nodoc:all:
+  module CoreExtensions #:nodoc
+    module Hash #:nodoc
       module Keys
         # Return a new hash with all keys converted to strings.
+         #:nodoc
         def stringify_keys
           inject({}) do |options, (key, value)|
             options[key.to_s] = value
@@ -11,6 +12,7 @@ module ActiveSupport #:nodoc:
         end
 
         # Destructively convert all keys to strings.
+         #:nodoc
         def stringify_keys!
           keys.each do |key|
             self[key.to_s] = delete(key)
@@ -19,6 +21,7 @@ module ActiveSupport #:nodoc:
         end
 
         # Return a new hash with all keys converted to symbols.
+         #:nodoc
         def symbolize_keys
           inject({}) do |options, (key, value)|
             options[(key.to_sym rescue key) || key] = value
@@ -27,6 +30,7 @@ module ActiveSupport #:nodoc:
         end
 
         # Destructively convert all keys to symbols.
+         #:nodoc
         def symbolize_keys!
           self.replace(self.symbolize_keys)
         end
@@ -42,6 +46,7 @@ module ActiveSupport #:nodoc:
         #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
         #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
         #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+        #:nodoc
         def assert_valid_keys(*valid_keys)
           unknown_keys = keys - [valid_keys].flatten
           raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?

data/lib/state_fu/active_support_lite/misc.rb

@@ -1,4 +1,4 @@
-class Object
+class Object  #:nodoc:all
   # Returns +value+ after yielding +value+ to the block. This simplifies the
   # process of constructing an object, performing work on the object, and then
   # returning the object from a method. It is a Ruby-ized realization of the K
@@ -25,7 +25,7 @@ class Object
   #  end
   #
   #  foo # => ['bar', 'baz']
-  #  
+  #
   #  # returning with a block argument
   #  def foo
   #    returning [] do |values|
@@ -33,8 +33,9 @@ class Object
   #      values << 'baz'
   #    end
   #  end
-  #  
+  #
   #  foo # => ['bar', 'baz']
+   #:nodoc
   def returning(value)
     yield(value)
     value
@@ -50,8 +51,9 @@ class Object
   #     tap    { |x| puts "evens: #{x.inspect}" }.
   #     map    { |x| x*x }.
   #     tap    { |x| puts "squares: #{x.inspect}" }
+   #:nodoc
   def tap
     yield self
     self
   end unless Object.respond_to?(:tap)
-end
+end

data/lib/state_fu/active_support_lite/module/delegation.rb

@@ -0,0 +1,130 @@
+class Module
+  # Provides a delegate class method to easily expose contained objects' methods
+  # as your own. Pass one or more methods (specified as symbols or strings)
+  # and the name of the target object as the final <tt>:to</tt> option (also a symbol
+  # or string).  At least one method and the <tt>:to</tt> option are required.
+  #
+  # Delegation is particularly useful with Active Record associations:
+  #
+  #   class Greeter < ActiveRecord::Base
+  #     def hello()   "hello"   end
+  #     def goodbye() "goodbye" end
+  #   end
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :to => :greeter
+  #   end
+  #
+  #   Foo.new.hello   # => "hello"
+  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+  #
+  # Multiple delegates to the same target are allowed:
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :goodbye, :to => :greeter
+  #   end
+  #
+  #   Foo.new.goodbye # => "goodbye"
+  #
+  # Methods can be delegated to instance variables, class variables, or constants
+  # by providing them as a symbols:
+  #
+  #   class Foo
+  #     CONSTANT_ARRAY = [0,1,2,3]
+  #     @@class_array  = [4,5,6,7]
+  #     
+  #     def initialize
+  #       @instance_array = [8,9,10,11]
+  #     end
+  #     delegate :sum, :to => :CONSTANT_ARRAY
+  #     delegate :min, :to => :@@class_array
+  #     delegate :max, :to => :@instance_array
+  #   end
+  #
+  #   Foo.new.sum # => 6
+  #   Foo.new.min # => 4
+  #   Foo.new.max # => 11
+  #
+  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+  # delegated to.
+  #
+  #   Person = Struct.new(:name, :address)
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => true
+  #   end
+  #
+  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.client_name    # => "John Doe"
+  #   invoice.client_address # => "Vimmersvej 13"
+  #
+  # It is also possible to supply a custom prefix.
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => :customer
+  #   end
+  #
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.customer_name    # => "John Doe"
+  #   invoice.customer_address # => "Vimmersvej 13"
+  #
+  # If the object to which you delegate can be nil, you may want to use the
+  # :allow_nil option. In that case, it returns nil instead of raising a
+  # NoMethodError exception:
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar
+  #  end
+  #
+  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar, :allow_nil => true
+  #  end
+  #
+  #  Foo.new.zoo   # returns nil
+  #
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    end
+
+    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
+
+    methods.each do |method|
+      on_nil =
+        if options[:allow_nil]
+          'return'
+        else
+          %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        end
+
+      module_eval(<<-EOS, file, line)
+        def #{prefix}#{method}(*args, &block)                           # def customer_name(*args, &block)
+          #{on_nil} if #{to}.nil?
+          #{to}.__send__(#{method.inspect}, *args, &block)  #   client && client.__send__(:name, *args, &block)
+        end                                                             # end
+      EOS
+    end
+  end
+end

data/lib/state_fu/active_support_lite/module.rb

@@ -0,0 +1 @@
+require File.join( File.dirname( __FILE__),'module/delegation')

data/lib/state_fu/active_support_lite/object.rb

@@ -1,6 +1,9 @@
-class Object
-  def extended_by #:nodoc:
+class Object  #:nodoc:all
+
+   #:nodoc
+  def extended_by #:nodoc
     ancestors = class << self; ancestors end
     ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
   end
+    
 end

data/lib/state_fu/active_support_lite/string.rb

@@ -1,4 +1,5 @@
-class String
+class String  #:nodoc:all
+   #:nodoc
   def underscore
     self.gsub(/::/, '/').
       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
@@ -7,10 +8,12 @@ class String
       downcase
   end
 
+   #:nodoc
   def demodulize
     gsub(/^.*::/, '')
   end
 
+   #:nodoc
   def constantize
     unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
       raise NameError, "#{self} is not a valid constant name!"
@@ -18,10 +21,12 @@ class String
     Object.module_eval("::#{$1}", __FILE__, __LINE__)
   end
 
+   #:nodoc
   def classify # DOES NOT SINGULARISE
     camelize(self.sub(/.*\./, ''))
   end
 
+   #:nodoc
   def camelize( first_letter_in_uppercase = true)
     if first_letter_in_uppercase
       gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }

data/lib/state_fu/active_support_lite/symbol.rb

@@ -1,4 +1,4 @@
-unless :to_proc.respond_to?(:to_proc)
+unless :to_proc.respond_to?(:to_proc)  #:nodoc:all
   class Symbol
     # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
     #
@@ -7,6 +7,7 @@ unless :to_proc.respond_to?(:to_proc)
     #
     #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
     #   people.select(&:manager?).collect(&:salary)
+     #:nodoc
     def to_proc
       Proc.new { |*args| args.shift.__send__(self, *args) }
     end

data/lib/state_fu/applicable.rb

@@ -0,0 +1,41 @@
+module StateFu
+  module Applicable
+    module InstanceMethods
+
+      # if given a hash of options (or a splatted arglist containing
+      # one), merge them into @options. If given a block, eval it
+      # (yielding self if the block expects it)
+
+      def apply!( _options=nil, &block )
+        if _options.is_a?(Array)
+          _options  = _options.dup.extract_options!.symbolize_keys
+        else          
+          _options ||= {}
+          _options = _options.symbolize_keys!
+        end
+
+        @options = @options.nil?? _options : @options.merge(_options)
+        returning self do
+          if block_given?
+            case block.arity.abs
+            when 1, -1
+              instance_exec self, &block
+            when 0
+              instance_exec &block
+            else
+              raise ArgumentError, "Your block wants too many arguments!"
+            end
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+    end
+
+    def self.included( mod )
+      mod.send( :include, InstanceMethods )
+      mod.extend( ClassMethods )
+    end
+  end
+end

data/lib/state_fu/{helper.rb → arrays.rb}

@@ -1,48 +1,12 @@
 module StateFu
 
-  # Utilities and snippets
-  module Helper
-
-    # Instance methods mixed in on inclusion of StateFu::Helper
-    module InstanceMethods
-
-      # if given a hash of options (or a splatted arglist containing
-      # one), merge them into @options. If given a block, eval it
-      # (yielding self if the block expects it)
-      def apply!( options={}, &block )
-        options.respond_to?(:keys) || options = options.extract_options!
-        @options.merge!( options.symbolize_keys! )
-        return self unless block_given?
-        case block.arity
-        when 1     # lambda{ |state| ... }
-          yield self
-        when -1, 0 # lambda{ } ( -1 in ruby 1.8.x but 0 in 1.9.x )
-          instance_eval &block
-        else
-          raise ArgumentError, "unexpected block arity: #{block.arity}"
-        end
-        self
-      end
-      alias_method :update!, :apply!
-
-    end
-
-    # Class methods mixed in on inclusion of StateFu::Helper
-    module ClassMethods
-    end
-
-    def self.included( mod )
-      mod.send( :include, InstanceMethods )
-      mod.extend( ClassMethods )
-    end
-
-  end
-
   # Stuff shared between StateArray and EventArray
   module ArrayWithSymbolAccessor
+
     # Pass a symbol to the array and get the object with that .name
     # [<Foo @name=:bob>][:bob]
     # => <Foo @name=:bob>
+
     def []( idx )
       begin
         super( idx )
@@ -69,9 +33,41 @@ module StateFu
     def only *syms
       select {|el| syms.flatten.compact.map(&:to_sym).include?(el.to_sym) } #.extend ArrayWithSymbolAccessor
     end
+      
+    def all
+      self
+    end
+    
+    def rand
+      self.rand
+    end
 
   end
 
+  module TransitionArgsArray
+    attr_reader :transition
+    
+    def init(t)
+      @transition = t
+      self
+    end
+    
+    delegate :options, :to => :transition
+    delegate :binding, :to => :transition
+    delegate :machine, :to => :transition
+    delegate :origin,  :to => :transition
+    delegate :target,  :to => :transition                
+
+    def []( index )
+      begin
+        super( index )
+      rescue TypeError
+        options[index]
+      end
+    end
+    
+  end 
+  
   # Array extender. Used by Machine to keep a list of states.
   module StateArray
     include ArrayWithSymbolAccessor
@@ -153,6 +149,17 @@ module StateFu
     include ModuleRefArray
   end
 
+
+  module MessageArray
+    def strings
+      select { |m| m.is_a? String }
+    end
+
+    def symbols
+      select { |m| m.is_a? Symbol }
+    end
+  end
+
   # Extend an Array with this. It's a fairly compact implementation,
   # though it won't be super fast with lots of elements.
   # items. Internally objects are stored as a list of
@@ -187,87 +194,4 @@ module StateFu
       map(&:last)
     end
   end  # OrderedHash
-
-  # satanic incantations we use for evaluating blocks conditionally,
-  # massaging their arguments and managing execution context.
-  module ContextualEval
-    # :nodoc:
-    module InstanceMethods
-
-      # if we use &block syntax it stuffs the arity up, so we have to
-      # pass it as a normal argument. Ruby bug!
-      def limit_arguments( block, *args )
-        case block.arity
-        when -1, 0
-          nil
-        else
-          args[0 .. (block.arity - 1) ]
-        end
-      end
-
-      def evaluate( *args, &proc )
-        if proc.arity > 0
-          args = limit_arguments( proc, *args )
-          object.instance_exec( *args, &proc )
-        else
-          instance_eval( &proc )
-        end
-      end
-
-      def call_on_object_with_optional_args( name, *args )
-        if meth = object.method( name )
-          args = limit_arguments( meth, *args )
-          if args.nil?
-            object.send( name )
-          else
-            object.send( name, *args )
-          end
-        else
-          raise NoMethodError.new( "undefined method #{name} for #{object.inspect}" )
-        end
-      end
-
-      def call_on_object_with_self( name )
-        call_on_object_with_optional_args( name, self )
-      end
-
-      def evaluate_named_proc_or_method( name, *args )
-        if (name.is_a?( Proc ) && proc = name) || proc = machine.named_procs[ name ]
-          evaluate( *args, &proc )
-        elsif self.respond_to?( name )
-          if method(name).arity == 0
-            send(name)
-          else
-            send(name, *args )
-          end
-          # evaluate( *args, &method(name) )
-        elsif object.respond_to?( name )
-          call_on_object_with_optional_args( name, *args )
-        else # method is not defined
-          if name.to_s =~ /^not_(.*)$/
-            !evaluate_named_proc_or_method( $1, *args )
-          else
-            raise NoMethodError.new("#{name} is not defined on #{object} or #{self} or as a named proc in #{machine}")
-          end
-        end
-      end
-
-      def find_event_target( evt, tgt )
-        case tgt
-        when StateFu::State
-          tgt
-        when Symbol
-          binding && binding.machine.states[ tgt ] # || raise( tgt.inspect )
-        when NilClass
-          evt.respond_to?(:target) && evt.target
-        else
-          raise ArgumentError.new( "#{tgt.class} is not a Symbol, StateFu::State or nil (#{evt})" )
-        end
-      end
-    end
-
-    def self.included( klass )
-      klass.send :include, InstanceMethods
-    end
-  end
 end