hydra_attribute 0.3.2 → 0.4.0.rc1

data/lib/hydra_attribute/active_record/association_preloader.rb

@@ -1,12 +1,12 @@
 module HydraAttribute
   module ActiveRecord
     class AssociationPreloader
-      attr_reader :relation, :records, :hashed_records
+      attr_reader :relation, :records
 
       def initialize(relation, records = [])
-        @relation       = relation
-        @records        = records
-        @hashed_records = records.each_with_object({}) { |record, hash| hash[record.id] = record }
+        @relation = relation
+        @records  = records
+        prepared_records # lock attributes
       end
 
       def self.run(relation, records)
@@ -14,69 +14,69 @@ module HydraAttribute
       end
 
       def run
-        grouped_values do |association, values, white_list_attribute_ids|
-          association.target.concat(values)
-          association.lock_for_build!(white_list_attribute_ids)
-        end
-      end
+        return if records.blank?
 
-      private
+        prepared_records.keys.each_slice(in_clause_length || prepared_records.keys.length) do |entity_ids|
+          grouped_attribute_ids.each do |backend_type, hydra_attribute_ids|
+            next if hydra_attribute_ids.blank?
 
-      def grouped_values
-        grouped_attribute_ids do |type, attribute_ids|
-          association_name = AssociationBuilder.association_name(type)
-          load_values(type, attribute_ids) do |record, values|
-            yield(record.association(association_name), values, attribute_ids)
+            hydra_attribute_ids.each_slice(in_clause_length || hydra_attribute_ids.length) do |attribute_ids|
+              value_class(backend_type).select(%w(id entity_id hydra_attribute_id value)).where(entity_id: entity_ids, hydra_attribute_id: attribute_ids).each do |model|
+                assoc = association_builder.association_name(backend_type)
+                prepared_records[model.entity_id].association(assoc).target.push(model)
+              end
+            end
           end
         end
       end
 
-      def load_values(type, attribute_ids)
-        return records.each { |record| yield(record, []) } if attribute_ids.empty?
+      private
+        def prepared_records
+          limit = attribute_limit?
+          @prepared_records ||= records.each_with_object({}) do |record, hash|
+            grouped_attribute_ids.each do |backend_type, hydra_attribute_ids|
+              association = record.association(association_builder.association_name(backend_type))
+              limit ? association.lock!(hydra_attribute_ids) : association.loaded!
+            end
+            hash[record.id] = record
+          end
+        end
 
-        attribute_ids.each_slice(in_clause_length || attribute_ids.length) do |sliced_attribute_ids|
-          records.each_slice(in_clause_length || records.length) do |sliced_records|
-            values = AssociationBuilder.class_name(klass, type).constantize.select([:id, :entity_id, :hydra_attribute_id, :value]).where(entity_id: sliced_records, hydra_attribute_id: sliced_attribute_ids)
-            group_records_with_values(sliced_records, values).each do |record_id, grouped_values|
-              yield(hashed_records[record_id], grouped_values)
+        def grouped_attribute_ids
+          @grouped_attribute_ids ||= if attribute_limit?
+            map = klass.hydra_attribute_backend_types.each_with_object({}) { |backend_type, hash| hash[backend_type] = [] }
+            relation.hydra_select_values.each_with_object(map) do |name, grouped_ids|
+              hydra_attribute = klass.hydra_attribute(name)
+              grouped_ids[hydra_attribute.backend_type] << hydra_attribute.id
             end
+          else
+            klass.hydra_attribute_ids_by_backend_type
           end
         end
-      end
 
-      def group_records_with_values(records, values)
-        hash = records.each_with_object({}) { |record, hash| hash[record.id] = [] }
-        values.each { |value| hash[value.entity_id] << value }
-        hash
-      end
+        def attribute_limit?
+          relation.select_values.any? or relation.hydra_select_values.any?
+        end
 
-      def grouped_attribute_ids
-        map     = klass.hydra_attribute_backend_types.each_with_object({}) { |type, object| object[type] = [] }
-        mapping = hydra_attributes.each_with_object(map) do |hydra_attribute, mapping|
-          mapping[hydra_attribute.backend_type] << hydra_attribute.id
+        def value_class(backend_type)
+          instance_variable_get(:"@#{backend_type}_class") || instance_variable_set(:"@#{backend_type}_class", association_builder.class_name(klass, backend_type).constantize)
         end
-        mapping.each { |type, ids| yield(type, ids) }
-      end
 
-      def hydra_attributes
-        if attribute_limit?
-          relation.hydra_select_values.map { |name| klass.hydra_attribute(name) }
-        else
-          klass.hydra_attributes
+        def association_builder
+          AssociationBuilder
         end
-      end
 
-      def attribute_limit?
-        relation.select_values.any? or relation.hydra_select_values.any?
-      end
+        def connection
+          relation.connection
+        end
 
-      def klass
-        relation.klass
-      end
+        def klass
+          relation.klass
+        end
 
-      def in_clause_length
-        klass.connection.in_clause_length
-      end
+        def in_clause_length
+          connection.in_clause_length
+        end
     end
   end
 end

data/lib/hydra_attribute/active_record/attribute_methods.rb

@@ -3,6 +3,8 @@ module HydraAttribute
     module AttributeMethods
       extend ActiveSupport::Concern
 
+      include HydraMethods
+
       NAME_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
       CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
 
@@ -23,34 +25,6 @@ module HydraAttribute
           end
         end
 
-        def hydra_attributes
-          @hydra_attributes ||= HydraAttribute.where(entity_type: base_class.model_name)
-        end
-
-        def grouped_hydra_attributes
-          @grouped_hydra_attributes ||= hydra_attributes.group_by(&:backend_type)
-        end
-
-        %w(id name backend_type).each do |prefix|
-          class_eval <<-EOS, __FILE__, __LINE__ + 1
-            def hydra_attribute_#{prefix}s
-              @hydra_attribute_#{prefix}s ||= hydra_attributes.map(&:#{prefix}).uniq
-            end
-
-            def grouped_hydra_attribute_#{prefix}s(type)
-              instance = "@grouped_hydra_attribute_\#{type}_#{prefix}s"
-              instance_variable_get(instance) || instance_variable_set(instance, grouped_hydra_attributes[type].map(&:#{prefix}).uniq)
-            end
-          EOS
-        end
-
-        def hydra_attribute(identifier)
-          @hydra_attribute_cache ||= {}
-          @hydra_attribute_cache[identifier] ||= hydra_attributes.find do |hydra_attribute|
-            hydra_attribute.id == identifier || hydra_attribute.name == identifier
-          end
-        end
-
         def define_hydra_attribute_methods
           @hydra_attribute_methods_mutex.synchronize do
             return if hydra_attribute_methods_generated?
@@ -78,6 +52,10 @@ module HydraAttribute
 
             generated_hydra_attribute_methods.module_eval <<-EOS, __FILE__, __LINE__ + 1
               #{defn}
+                if hydra_set_id? and self.class.hydra_set_attribute_ids(hydra_set_id).exclude?(#{hydra_attribute.id})
+                  raise MissingAttributeInHydraSetError, 'Attribute "#{hydra_attribute.name}" does not exist in hydra set "\#{hydra_set(hydra_set_id).name}"'
+                end
+
                 if value_model = hydra_value_model(#{hydra_attribute.id})
                   value_model.#{send}
                 else
@@ -88,27 +66,17 @@ module HydraAttribute
           end
         end
 
-        def reset_hydra_attribute_methods
+        def reset_hydra_attribute_methods!
           generated_hydra_attribute_methods.module_eval do
             instance_methods.each { |m| undef_method(m) }
           end
-
-          @hydra_attributes                  = nil
           @hydra_attribute_methods_generated = false
-          @hydra_attribute_cache             = {}
-          @grouped_hydra_attributes          = nil
-
-          %w(id name backend_type).each do |prefix|
-            instance_variable_set("@hydra_attribute_#{prefix}s", nil)
 
-            SUPPORT_TYPES.each do |type|
-              instance_variable_set("@grouped_hydra_attribute_#{type}_#{prefix}s", nil)
-            end
-          end
+          clear_hydra_method_cache!
         end
 
         def undefine_attribute_methods
-          reset_hydra_attribute_methods
+          reset_hydra_attribute_methods!
           super
         end
 
@@ -121,18 +89,32 @@ module HydraAttribute
 
       def respond_to?(name, include_private = false)
         self.class.define_hydra_attribute_methods unless self.class.hydra_attribute_methods_generated?
-        super
+
+        # @COMPATIBILITY with 3.1.x active_model doesn't have "attribute_method_matcher" method
+        if ::ActiveRecord::VERSION::STRING.start_with?('3.1.')
+          matchers  = attribute_method_matchers.partition { |m| m.prefix.empty? && m.suffix.empty? }.reverse.flatten(1)
+          matcher   = matchers.detect { |method| method.match(name) }
+          attr_name = matcher.match(name).attr_name
+        else
+          attr_name = self.class.send(:attribute_method_matcher, name).attr_name
+        end
+
+        if hydra_attribute?(attr_name)
+          self.class.hydra_set_attribute_names(hydra_set_id).include?(attr_name)
+        else
+          super
+        end
       end
 
       def attributes
         hydra_value_models.each_with_object(super) do |model, attributes|
-          attributes[model.attribute_name] = model.read_attribute('value')
+          attributes[model.hydra_attribute_name] = model.read_attribute('value')
         end
       end
 
       def attributes_before_type_cast
         hydra_value_models.each_with_object(super) do |model, attributes|
-          attributes[model.attribute_name] = model.read_attribute_before_type_cast('value')
+          attributes[model.hydra_attribute_name] = model.read_attribute_before_type_cast('value')
         end
       end
 
@@ -140,7 +122,7 @@ module HydraAttribute
         class_eval <<-EOS, __FILE__, __LINE__ + 1
           def #{method}(attr_name)
             identifier = attr_name.to_s
-            if self.class.hydra_attribute_names.include?(identifier)
+            if self.class.hydra_set_attribute_names(hydra_set_id).include?(identifier)
               if value_model = hydra_value_model(identifier)
                 value_model.#{method}('value')
               else
@@ -153,55 +135,25 @@ module HydraAttribute
         EOS
       end
 
-      def hydra_attribute_names
-        @hydra_attribute_names ||= hydra_value_models.map(&:attribute_name)
-      end
-
-      def hydra_attribute_backend_types
-        @hydra_attribute_backend_types ||= self.class.hydra_attribute_backend_types.select do |backend_type|
-          hydra_value_association(backend_type).all_models.any?
-        end
-      end
-
       def inspect
         attrs  = self.class.column_names.map { |name| "#{name}: #{attribute_for_inspect(name)}" }
-        attrs += hydra_value_models.map { |model| "#{model.attribute_name}: #{model.attribute_for_inspect('value')}" }
+        attrs += hydra_value_models.map { |model| "#{model.hydra_attribute_name}: #{model.attribute_for_inspect('value')}" }
         "#<#{self.class} #{attrs.join(', ')}>"
       end
 
       private
-
-      def hydra_value_model(identifier)
-        @hydra_value_model_cache ||= {}
-        @hydra_value_model_cache[identifier] ||= begin
-          hydra_attribute = self.class.hydra_attribute(identifier)
-          association = hydra_value_association(hydra_attribute.backend_type)
-          association.find_model_or_build(hydra_attribute_id: hydra_attribute.id)
-        end
-      end
-
-      def hydra_value_models
-        @hydra_value_models ||= self.class.hydra_attribute_backend_types.inject([]) do |models, backend_type|
-          models + hydra_value_association(backend_type).all_models
-        end
-      end
-
-      def hydra_value_association(backend_type)
-        association(::HydraAttribute::AssociationBuilder.association_name(backend_type))
-      end
-
-      def method_missing(method, *args, &block)
-        if self.class.hydra_attribute_methods_generated?
-          super
-        else
-          self.class.define_hydra_attribute_methods
-          if respond_to_without_attributes?(method)
-            send(method, *args, &block)
-          else
+        def method_missing(method, *args, &block)
+          if self.class.hydra_attribute_methods_generated?
             super
+          else
+            self.class.define_hydra_attribute_methods
+            if respond_to_without_attributes?(method)
+              send(method, *args, &block)
+            else
+              super
+            end
           end
         end
-      end
     end
   end
 end

data/lib/hydra_attribute/active_record/migration.rb

@@ -9,8 +9,8 @@ module HydraAttribute
         Migrator.drop(self, name)
       end
 
-      def migrate_to_hydra_entity(name)
-        Migrator.migrate(self, name)
+      def migrate_to_hydra_entity(name, options = {}, &block)
+        Migrator.migrate(self, name, options, &block)
       end
 
       def rollback_from_hydra_entity(name)

data/lib/hydra_attribute/active_record/reflection.rb

@@ -9,7 +9,7 @@ module HydraAttribute
       end
 
       def backend_type
-        @backend_type ||= SUPPORT_TYPES.find { |type| type == klass.model_name.demodulize.underscore.split('_')[1] }
+        @backend_type ||= SUPPORTED_BACKEND_TYPES.find { |type| type == klass.model_name.demodulize.underscore.split('_')[1] }
       end
     end
   end

data/lib/hydra_attribute/active_record/relation/query_methods.rb

@@ -42,7 +42,8 @@ module HydraAttribute
           @group_values = hydra_helper.quote_columns(@group_values.uniq.reject(&:blank?))
           @order_values = hydra_helper.quote_columns(@order_values.uniq.reject(&:blank?))
 
-          if instance_variable_defined?(:@reorder_value) and instance_variable_get(:@reorder_value).present? # for compatibility with 3.1.x
+          # @COMPATIBILITY with 3.1.x active_record 3.1 uses the separate @reorder_value instance
+          if instance_variable_defined?(:@reorder_value) and instance_variable_get(:@reorder_value).present?
             @reorder_value = hydra_helper.quote_columns(@reorder_value.uniq.reject(&:blank?))
           end
 
@@ -51,9 +52,10 @@ module HydraAttribute
           @hydra_select_values.map!(&:to_s)
           @select_values.map!{ |value| hydra_helper.prepend_table_name(value) }
 
-          # force add ID for preloading hydra attributes
-          if @hydra_select_values.any? && @select_values.none? { |v| hydra_helper.attr_eq_column?(v, klass.primary_key) }
+          # attributes "id" and "hydra_set_id" are important for hydra_attribute gem
+          if @hydra_select_values.any? or @select_values.any?
             @select_values << hydra_helper.prepend_table_name(klass.primary_key)
+            @select_values << hydra_helper.prepend_table_name('hydra_set_id')
           end
 
           super
@@ -153,10 +155,9 @@ module HydraAttribute
         end
 
         private
-
-        def hydra_helper
-          @hydra_helper ||= Helper.new(self)
-        end
+          def hydra_helper
+            @hydra_helper ||= Helper.new(self)
+          end
       end
     end
   end

data/lib/hydra_attribute/active_record/relation.rb

@@ -6,6 +6,7 @@ module HydraAttribute
       included do
         include QueryMethods
 
+        # @COMPATIBILITY with 3.1.x active_record 3.1 doesn't have "exec_queries" method
         target = ::ActiveRecord::VERSION::STRING.starts_with?('3.1.') ? :to_a : :exec_queries
         alias_method :__old_exec_queries__, target
         alias_method target, :__exec_queries__

data/lib/hydra_attribute/active_record.rb

@@ -1,21 +1,29 @@
 module HydraAttribute
-
-  # ActiveRecord::Base extends this module.
   module ActiveRecord
+    def self.append_features(base)
+      unless base.ancestors.include?(::ActiveRecord::Base)
+        raise %(Cannot include HydraAttribute::ActiveRecord module because "#{base}" is not inherited from ActiveRecord::Base)
+      end
+
+      unless base.base_class.equal?(base)
+        raise %(HydraAttribute::ActiveRecord module should be included to base class "#{base.base_class}" instead of "#{base}")
+      end
+
+      super
 
-    # Add EAV behavior to this model.
-    # Generate attribute and value associations.
-    def use_hydra_attributes
-      Builder.build(self)
+      base.extend(ClassMethods)
+      Builder.build(base)
     end
 
-    # Create reflection for hydra association
-    def create_reflection(macro, name, options, active_record)
-      if name.to_s.start_with?('hydra_')
-        reflections[name] = Reflection.new(macro, name, options, active_record)
-      else
-        super
+    module ClassMethods
+      def create_reflection(macro, name, options, active_record)
+        if name.to_s.start_with?('hydra_')
+          reflections[name] = Reflection.new(macro, name, options, active_record)
+        else
+          super
+        end
       end
     end
+
   end
 end

data/lib/hydra_attribute/association_builder.rb

@@ -38,10 +38,9 @@ module HydraAttribute
       value_model.table_name = table_name
       value_model.belongs_to :entity, class_name: klass.model_name, autosave: false
       value_model.belongs_to :hydra_attribute, class_name: 'HydraAttribute::HydraAttribute'
-      value_model.attr_accessible :hydra_attribute_id, :value
 
       value_model.class_eval <<-EOS, __FILE__, __LINE__ + 1
-        def attribute_name
+        def hydra_attribute_name
           #{klass.model_name}.hydra_attribute(hydra_attribute_id).name
         end
       EOS

data/lib/hydra_attribute/builder.rb

@@ -24,15 +24,14 @@ module HydraAttribute
     end
 
     private
-
-    def build_associations
-      SUPPORT_TYPES.each do |type|
-        AssociationBuilder.build(klass, type)
+      def build_associations
+        SUPPORTED_BACKEND_TYPES.each do |type|
+          AssociationBuilder.build(klass, type)
+        end
       end
-    end
 
-    def build_white_list
-      klass.hydra_attributes.each(&:toggle_white_list!)
-    end
+      def build_white_list
+        klass.hydra_attributes.each(&:toggle_white_list!)
+      end
   end
 end

data/lib/hydra_attribute/entity_callbacks.rb

@@ -3,44 +3,24 @@ module HydraAttribute
     extend ActiveSupport::Concern
 
     included do
-      after_create   :create_hydra_values
-      after_update   :update_hydra_values
+      after_create   :save_hydra_values
+      after_update   :save_hydra_values
       before_destroy :destroy_hydra_values
     end
 
     private
-
-    def create_hydra_values
-      created = false
-      each_hydra_value_model do |model|
-        model.entity_id = id
-        model.save
-        created = true
+      def save_hydra_values
+        changed = false
+        self.class.hydra_set_attribute_backend_types(hydra_set_id).each do |backend_type|
+          changed = true if hydra_value_association(backend_type).save
+        end
+        touch if changed
       end
-      touch if created
-    end
-
-    def update_hydra_values
-      updated = false
-      each_hydra_value_model do |model|
-       if model.changed?
-         updated = true
-         model.save
-       end
-      end
-      touch if updated
-    end
 
-    def destroy_hydra_values
-      self.class.hydra_attribute_backend_types.each do |type|
-        AssociationBuilder.class_name(self.class, type).constantize.where(entity_id: id).delete_all
+      def destroy_hydra_values
+        self.class.hydra_attribute_backend_types.each do |backend_type|
+          AssociationBuilder.class_name(self.class, backend_type).constantize.where(entity_id: id).delete_all
+        end
       end
-    end
-
-    def each_hydra_value_model(&block)
-      self.class.hydra_attribute_backend_types.each do |type|
-        association(AssociationBuilder.association_name(type)).all_models.each(&block)
-      end
-    end
   end
 end

data/lib/hydra_attribute/hydra_attribute.rb

@@ -9,16 +9,26 @@ module HydraAttribute
     end
     attr_accessible :white_list, as: :admin
 
+    has_and_belongs_to_many :hydra_sets, join_table: 'hydra_attribute_sets', class_name: 'HydraAttribute::HydraSet', conditions: proc { {hydra_sets: {entity_type: entity_type}} }
+
     with_options presence: true do |klass|
       klass.validates :entity_type,  inclusion: { in: lambda { |attr| [(attr.entity_type.constantize.name rescue nil)] } }
       klass.validates :name,         uniqueness: { scope: :entity_type }
-      klass.validates :backend_type, inclusion: SUPPORT_TYPES
+      klass.validates :backend_type, inclusion: SUPPORTED_BACKEND_TYPES
     end
 
     before_destroy :delete_dependent_values
-    after_commit   :reload_attribute_methods
+    after_commit   :clear_entity_cache
     after_commit   :toggle_white_list!
 
+    # @COMPATIBILITY with 3.1.x association module is directly added to the class instead of including module
+    def hydra_sets_with_clearing_cache=(value)
+      self.hydra_sets_without_clearing_cache = value
+      clear_entity_cache
+      value
+    end
+    alias_method_chain :hydra_sets=, :clearing_cache
+
     def toggle_white_list!
       if destroyed? or !white_list?
         remove_from_white_list
@@ -28,22 +38,21 @@ module HydraAttribute
     end
 
     private
+      def delete_dependent_values
+        value_class = AssociationBuilder.class_name(entity_type.constantize, backend_type).constantize
+        value_class.delete_all(hydra_attribute_id: id)
+      end
 
-    def delete_dependent_values
-      value_class = AssociationBuilder.class_name(entity_type.constantize, backend_type).constantize
-      value_class.delete_all(hydra_attribute_id: id)
-    end
-
-    def reload_attribute_methods
-      entity_type.constantize.reset_hydra_attribute_methods # TODO should not remove all generated methods just for this attribute
-    end
+      def clear_entity_cache
+        entity_type.constantize.clear_hydra_method_cache!
+      end
 
-    def add_to_white_list
-      entity_type.constantize.accessible_attributes.add(name)
-    end
+      def add_to_white_list
+        entity_type.constantize.accessible_attributes.add(name)
+      end
 
-    def remove_from_white_list
-      entity_type.constantize.accessible_attributes.delete(name)
-    end
+      def remove_from_white_list
+        entity_type.constantize.accessible_attributes.delete(name)
+      end
   end
 end