hobo 1.1.0 → 1.3.0.RC

data/lib/hobo/model/accessible_associations.rb

@@ -0,0 +1,178 @@
+module Hobo
+  module Model
+    module AccessibleAssociations
+
+      extend self
+
+      def prepare_has_many_assignment(association, association_name, array_or_hash)
+        owner = association.proxy_owner
+
+        array = params_hash_to_array(array_or_hash)
+        array.map! do |record_hash_or_string|
+          finder = association.member_class.scoped :conditions => association.send(:conditions)
+          find_or_create_and_update(owner, association_name, finder, record_hash_or_string) do |id|
+            # The block is required to either locate find an existing record in the collection, or build a new one
+            if id
+              # TODO: We don't really want to find these one by one
+              association.find(id)
+            else
+              association.build
+            end
+          end
+        end
+        array.compact
+      end
+
+
+      def find_or_create_and_update(owner, association_name, finder, record_hash_or_string)
+        if record_hash_or_string.is_a?(String)
+          return nil if record_hash_or_string.blank?
+
+          # An ID or a name - the passed block will find the record
+          record = find_by_name_or_id(finder, record_hash_or_string)
+
+        elsif record_hash_or_string.is_a?(Hash)
+          # A hash of attributes
+          hash = record_hash_or_string
+
+          # Remove completely blank hashes
+          return nil if hash.values.all?(&:blank?)
+
+          id = hash.delete(:id)
+
+          record = yield id
+          record.attributes = hash
+          if owner.new_record? && record.new_record?
+            # work around
+            # https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/3510-has_many-build-does-not-set-reverse-reflection
+            # https://hobo.lighthouseapp.com/projects/8324/tickets/447-validation-problems-with-has_many-accessible-true
+            reverse = owner.class.reverse_reflection(association_name)
+            if reverse && reverse.macro==:belongs_to
+              method = "#{reverse.name}=".to_sym
+              record.send(method, owner) if record.respond_to? method
+            end
+          else
+            owner.include_in_save(association_name, record) unless owner.class.reflections[association_name].options[:through]
+          end
+        else
+          # It's already a record
+          record = record_hash_or_string
+        end
+        record
+      end
+
+
+      def params_hash_to_array(array_or_hash)
+        if array_or_hash.is_a?(Hash)
+          array = array_or_hash.get(*array_or_hash.keys.sort_by(&:to_i))
+        elsif array_or_hash.is_a?(String)
+          # Due to the way that rails works, there's no good way to tell
+          # the difference between an empty array and a params hash that
+          # just isn't making any updates to the array.  So we're
+          # hacking this in: if you pash an empty string where an array
+          # is expected, we assume you wanted an empty array.
+          []
+        else
+          array_or_hash
+        end
+      end
+
+
+      def find_by_name_or_id(finder, id_or_name)
+        if id_or_name =~ /^@(.*)/
+          id = $1
+          finder.find(id)
+        else
+          finder.named(id_or_name)
+        end
+      end
+
+      def finder_for_belongs_to(record, name)
+        refl = record.class.reflections[name]
+        conditions = ActiveRecord::Associations::BelongsToAssociation.new(record, refl).send(:conditions)
+        finder = refl.klass.scoped(:conditions => conditions)
+      end
+
+    end
+
+
+    classy_module(AccessibleAssociations) do
+
+      # --- has_many mass assignment support --- #
+
+      def self.has_many_with_accessible(name, options={}, &block)
+        has_many_without_accessible(name, options, &block)
+
+        if options[:accessible]
+          class_eval %{
+            def #{name}_with_accessible=(array_or_hash)
+              __items = Hobo::Model::AccessibleAssociations.prepare_has_many_assignment(#{name}, :#{name}, array_or_hash)
+              self.#{name}_without_accessible = __items
+              # ensure the loaded array contains any changed records
+              self.#{name}.proxy_target[0..-1] = __items
+            end
+          }, __FILE__, __LINE__ - 7
+          alias_method_chain :"#{name}=", :accessible
+        end
+      end
+      metaclass.alias_method_chain :has_many, :accessible
+
+
+
+      # --- belongs_to assignment support --- #
+
+      def self.belongs_to_with_accessible(name, options={}, &block)
+        belongs_to_without_accessible(name, options, &block)
+
+        if options[:accessible]
+          class_eval %{
+            def #{name}_with_accessible=(record_hash_or_string)
+              finder = Hobo::Model::AccessibleAssociations.finder_for_belongs_to(self, :#{name})
+              record = Hobo::Model::AccessibleAssociations.find_or_create_and_update(self, :#{name}, finder, record_hash_or_string) do |id|
+                if id
+                  raise ArgumentError, "attempted to update the wrong record in belongs_to association #{self}##{name}" unless
+                    #{name} && id.to_s == self.#{name}.id.to_s
+                  #{name}
+                else
+                  finder.new
+                end
+              end
+              self.#{name}_without_accessible = record
+            end
+          }, __FILE__, __LINE__ - 15
+          alias_method_chain :"#{name}=", :accessible
+        else
+          # Not accessible - but finding by name and ID is still supported
+          class_eval %{
+            def #{name}_with_finder=(record_or_string)
+              record = if record_or_string.is_a?(String)
+                         finder = Hobo::Model::AccessibleAssociations.finder_for_belongs_to(self, :#{name})
+                         Hobo::Model::AccessibleAssociations.find_by_name_or_id(finder, record_or_string)
+                       else # it is a record
+                         record_or_string
+                       end
+              self.#{name}_without_finder = record
+            end
+          }, __FILE__, __LINE__ - 12
+          alias_method_chain :"#{name}=", :finder
+        end
+      end
+      metaclass.alias_method_chain :belongs_to, :accessible
+
+
+      # Add :accessible to the valid keys so AR doesn't complain
+
+      def self.valid_keys_for_has_many_association_with_accessible
+        valid_keys_for_has_many_association_without_accessible + [:accessible]
+      end
+      metaclass.alias_method_chain :valid_keys_for_has_many_association, :accessible
+
+      def self.valid_keys_for_belongs_to_association_with_accessible
+        valid_keys_for_belongs_to_association_without_accessible + [:accessible]
+      end
+      metaclass.alias_method_chain :valid_keys_for_belongs_to_association, :accessible
+
+
+    end
+  end
+end

data/lib/hobo/{find_for.rb → model/find_for.rb}

@@ -1,25 +1,25 @@
 module Hobo
-  
-  # FIXME: should be FindByBelongsTo maybe
-  module FindFor
-    
+  module Model
+    # FIXME: should be FindByBelongsTo maybe
+    module FindFor
+
     def self.included(base)
       base.alias_method_chain :method_missing, :find_for
     end
-    
+
     def method_missing_with_find_for(name, *args, &block)
       if name.to_s =~ /(.*)_by_(.*)/
         # name matches the general form
-        
+
         collection_name = $1.to_sym
         anchor_association_name = $2.to_sym
         if (refl = self.class.reflections[collection_name]) && refl.macro == :has_many
           # the association name matches (e.g. comment_for_...)
-          
+
           if (anchor_refl = refl.klass.reflections[anchor_association_name]) && anchor_refl.macro == :belongs_to
             # the whole thing matches (e.g. comment_for_user)
-            
-            
+
+
             #self.class.class_eval %{
             #  def #{name}(anchor)
             #    result = if #{collection_name}.loaded?
@@ -36,7 +36,7 @@ module Hobo
 
             self.class.class_eval %{
               def #{name}
-                Hobo::FindFor::Finder.new(self, '#{name}', :#{collection_name}, :#{anchor_association_name})
+                Hobo::Model::FindFor::Finder.new(self, '#{name}', :#{collection_name}, :#{anchor_association_name})
               end
             }
 
@@ -44,26 +44,26 @@ module Hobo
           end
         end
       end
-      
+
       method_missing_without_find_for(name, *args, &block)
     end
-    
+
     class Finder
-      
+
       def initialize(owner, name, collection, anchor_association)
         @association = owner.send(collection)
         @anchor_reflection = @association.member_class.reflections[anchor_association]
         @name = name
       end
-      
+
       def origin
         @association.proxy_owner
       end
-      
+
       def origin_attribute
         @name
       end
-      
+
       def [](anchor_or_id)
         anchor = if anchor_or_id.is_a?(String)
                    id, klass = anchor_or_id.split(':')
@@ -91,5 +91,5 @@ module Hobo
     end
 
   end
-
+  end
 end

data/lib/hobo/model/guest.rb

@@ -0,0 +1,25 @@
+module Hobo
+  module Model
+    class Guest
+
+      alias_method :has_hobo_method?, :respond_to?
+
+      def to_s
+        "guest"
+      end
+
+      def guest?
+        true
+      end
+
+      def signed_up?
+        false
+      end
+
+      def login
+        "guest"
+      end
+
+    end
+  end
+end

data/lib/hobo/model/include_in_save.rb

@@ -0,0 +1,55 @@
+module Hobo
+  module Model
+    IncludeInSave = classy_module do
+
+      attr_accessor :included_in_save
+
+      validate         :validate_included_in_save
+      before_save      :save_included
+      after_save       :clear_included_in_save
+
+      def include_in_save(association, *records)
+        self.included_in_save ||= Hash.new {|h, k| h[k] = []}
+        included_in_save[association.to_sym].concat records
+      end
+
+      def validate_included_in_save
+        if included_in_save
+          included_in_save._?.each_pair do |association, records|
+            next if self.class.reflections[association].options[:validate]==false
+            added = false
+            records.each do |record|
+              # we want to call valid? on each one, but only add the error to self once
+
+              record.with_acting_user(acting_user) do
+                unless record.valid?
+                  unless added
+                    errors.add association, "..."
+                    added = true
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+
+      def save_included
+        if included_in_save
+          included_in_save.each_pair do |association, records|
+            records.each do |record|
+              # save(:validate => false) means without transactions too
+              record.with_acting_user(acting_user) { record.save(:validate => false) }
+            end
+          end
+        end
+      end
+
+      def clear_included_in_save
+        included_in_save._?.clear
+      end
+
+    end
+  end
+end

data/lib/hobo/model/lifecycles.rb

@@ -0,0 +1,119 @@
+module Hobo
+  module Model
+    module Lifecycles
+
+      class LifecycleError < RuntimeError; end
+
+      class LifecycleKeyError < LifecycleError; end
+
+      ModelExtensions = classy_module do
+
+        attr_writer :lifecycle
+
+        def self.has_lifecycle?
+          defined?(self::Lifecycle)
+        end
+
+        def self.lifecycle(*args, &block)
+          options = args.extract_options!
+          options = options.reverse_merge(:state_field => :state,
+                                          :key_timestamp_field => :key_timestamp,
+                                          :key_timeout => 999.years)
+
+          # use const_defined so that subclasses can define lifecycles
+          # TODO: figure out how to merge with parent, if desired
+          if self.const_defined?(:Lifecycle)
+            lifecycle = self::Lifecycle
+            state_field_class = self::LifecycleStateField
+          else
+            # First call
+
+            module_eval "class ::#{name}::Lifecycle < Hobo::Model::Lifecycles::Lifecycle; end"
+            lifecycle = self::Lifecycle
+            lifecycle.init(self, options)
+
+            module_eval "class ::#{name}::LifecycleStateField < HoboFields::Types::LifecycleState; end"
+            state_field_class = self::LifecycleStateField
+            state_field_class.model_name = name
+          end
+
+          dsl = Hobo::Model::Lifecycles::DeclarationDSL.new(lifecycle)
+          dsl.instance_eval(&block)
+
+          default = lifecycle.default_state ? { :default => lifecycle.default_state.name.to_s } : {}
+          declare_field(options[:state_field], state_field_class, default)
+          unless options[:index] == false
+            index_options = { :name => options[:index] } unless options[:index] == true
+            index(options[:state_field], index_options || {})
+          end
+          attr_protected  options[:state_field]
+
+          unless options[:key_timestamp_field] == false
+            declare_field(options[:key_timestamp_field], :datetime)
+            never_show      options[:key_timestamp_field]
+            attr_protected  options[:key_timestamp_field]
+          end
+
+        end
+
+        # eval avoids the ruby 1.9.2 "super from singleton method ..." error
+        eval %(
+          def valid?(context=nil)
+            if context.nil? && self.class.has_lifecycle? && (step = lifecycle.active_step)
+              context = step.name
+            end
+            super(context)
+          end
+        )
+
+        def lifecycle
+          @lifecycle ||=  if self.class.const_defined?(:Lifecycle)
+                            self.class::Lifecycle.new(self)
+                          else
+                            # search through superclasses
+                            current = self.class.superclass
+                            until (current.const_defined?(:Lifecycle) || current.nil? || !current.respond_to?(:lifecycle)) do
+                              current = current.superclass
+                            end
+                            current::Lifecycle.new(self) if current.const_defined?(:Lifecycle)
+                          end
+        end
+
+      end
+
+
+      class DeclarationDSL
+
+        def initialize(lifecycle)
+          @lifecycle = lifecycle
+        end
+
+        def state(*args, &block)
+          options = args.extract_options!
+          names = args
+          states = names.map {|name| @lifecycle.def_state(name, block) }
+          if options[:default]
+            raise ArgumentError, "you must define one state if you give the :default option" unless states.length == 1
+            @lifecycle.default_state = states.first
+          end
+        end
+
+        def create(name, options={}, &block)
+          @lifecycle.def_creator(name, block, options)
+        end
+
+        def transition(name, change, options={}, &block)
+          @lifecycle.def_transition(name,
+                                    Array(change.keys.first), change.values.first,
+                                    block, options)
+        end
+
+        def invariant(&block)
+          @lifecycle.invariants << block
+        end
+
+      end
+
+    end
+  end
+end