hydra_attribute 0.2.0 → 0.3.0.beta1

data/lib/hydra_attribute/active_record/association.rb

@@ -0,0 +1,77 @@
+module HydraAttribute
+  module ActiveRecord
+    class Association < ::ActiveRecord::Associations::HasManyAssociation
+
+      def find_model(attributes = {})
+        load_target unless loaded?
+        target.detect do |model|
+          model.hydra_attribute_id == attributes[:hydra_attribute_id]
+        end
+      end
+
+      def find_model_or_build(attributes = {})
+        find_model(attributes) || build(attributes)
+      end
+
+      def build(attributes = {}, options = {}, &block)
+        return if locked_for_build? and white_list_for_build.exclude?(attributes[:hydra_attribute_id])
+        super
+      end
+
+      def all_models
+        unless @full_loaded
+          (all_attribute_ids - target.map(&:hydra_attribute_id)).each do |hydra_attribute_id|
+            build(hydra_attribute_id: hydra_attribute_id)
+          end
+          @full_loaded = true
+        end
+        target
+      end
+
+      def locked_for_build
+        @locked_for_build ||= false
+      end
+      alias_method :locked_for_build?, :locked_for_build
+
+      def lock_for_build!(white_list_for_build = [])
+        @locked_for_build     = true
+        @white_list_for_build = Array(white_list_for_build)
+        loaded!
+      end
+
+      def white_list_for_build
+        @white_list_for_build ||= []
+      end
+
+      def all_attribute_ids
+        hydra_attribute_ids  = owner.class.grouped_hydra_attribute_ids(reflection.backend_type)
+        hydra_attribute_ids &= white_list_for_build if locked_for_build?
+        hydra_attribute_ids
+      end
+
+      private
+
+      # Optimized method
+      # Remove unnecessary callbacks
+      def add_to_target(record)
+        @target << record
+        record
+      end
+
+      # Optimized method
+      # Attributes are written via low level function without additional checks
+      def build_record(attributes, _)
+        reflection.klass.new do |record|
+          unless attributes.has_key?(:value)
+            attributes[:value] = owner.class.hydra_attribute(attributes[:hydra_attribute_id]).default_value
+          end
+
+          record.send :write_attribute, 'id', attributes[:id]
+          record.send :write_attribute, 'entity_id', owner.id
+          record.send :write_attribute, 'hydra_attribute_id', attributes[:hydra_attribute_id]
+          record.send :write_attribute, 'value', attributes[:value]
+        end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/active_record/association_preloader.rb

@@ -0,0 +1,82 @@
+module HydraAttribute
+  module ActiveRecord
+    class AssociationPreloader
+      attr_reader :relation, :records, :hashed_records
+
+      def initialize(relation, records = [])
+        @relation       = relation
+        @records        = records
+        @hashed_records = records.each_with_object({}) { |record, hash| hash[record.id] = record }
+      end
+
+      def self.run(relation, records)
+        new(relation, records).run
+      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
+
+      private
+
+      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)
+          end
+        end
+      end
+
+      def load_values(type, attribute_ids)
+        return records.each { |record| yield(record, []) } if attribute_ids.empty?
+
+        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)
+            end
+          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 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
+        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
+        end
+      end
+
+      def attribute_limit?
+        relation.select_values.any? or relation.hydra_select_values.any?
+      end
+
+      def klass
+        relation.klass
+      end
+
+      def in_clause_length
+        klass.connection.in_clause_length
+      end
+    end
+  end
+end

data/lib/hydra_attribute/active_record/attribute_methods.rb

@@ -3,69 +3,177 @@ module HydraAttribute
     module AttributeMethods
       extend ActiveSupport::Concern
 
-      included do
-        @hydra_attributes = {}
+      NAME_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
+      CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
 
-        include Read
-        include BeforeTypeCast
+      included do
+        @hydra_attribute_methods_mutex = Mutex.new
       end
 
       module ClassMethods
-        def inherited(base)
-          base.instance_variable_set(:@hydra_attributes, hydra_attributes)
-          super
+        def hydra_attribute_methods_generated?
+          @hydra_attribute_methods_generated ||= false
+        end
+
+        def generated_hydra_attribute_methods
+          @generated_hydra_attribute_methods ||= begin
+            mod = Module.new
+            include mod
+            mod
+          end
         end
 
         def hydra_attributes
-          @hydra_attributes.dup
+          @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_names
-          hydra_attributes.keys
+        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 hydra_attribute_types
-          hydra_attributes.values.uniq
+        def define_hydra_attribute_methods
+          @hydra_attribute_methods_mutex.synchronize do
+            return if hydra_attribute_methods_generated?
+            hydra_attributes.each { |hydra_attribute| define_hydra_attribute_method(hydra_attribute) }
+            @hydra_attribute_methods_generated = true
+          end
+        end
+
+        def define_hydra_attribute_method(hydra_attribute)
+          attribute_method_matchers.each do |matcher|
+            current = matcher.method_name(hydra_attribute.name)
+            target  = matcher.method_name(:value)
+
+            if current =~ NAME_COMPILABLE_REGEXP
+              defn = "def #{current}(*args)"
+            else
+              defn = "define_method(:'#{current}') do |*args|"
+            end
+
+            if target =~ CALL_COMPILABLE_REGEXP
+              send = "#{target}(*args)"
+            else
+              send = "send(:'#{target}', *args)"
+            end
+
+            generated_hydra_attribute_methods.module_eval <<-EOS, __FILE__, __LINE__ + 1
+              #{defn}
+                if value_model = hydra_value_model(#{hydra_attribute.id})
+                  value_model.#{send}
+                else
+                  missing_attribute('#{hydra_attribute.name}', caller)
+                end
+              end
+            EOS
+          end
+        end
+
+        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
+        end
+
+        def undefine_attribute_methods
+          reset_hydra_attribute_methods
+          super
         end
       end
 
-      def initialize(attributes = nil, options = {})
-        @hydra_attribute_names = self.class.hydra_attribute_names
+      def respond_to?(name, include_private = false)
+        self.class.define_hydra_attribute_methods unless self.class.hydra_attribute_methods_generated?
         super
       end
 
-      def init_with(coder)
-        @hydra_attribute_names = self.class.hydra_attribute_names
-        super
+      %w(attributes attributes_before_type_cast).each do |method|
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          def #{method}
+            self.class.hydra_attribute_backend_types.each_with_object(super) do |type, attributes|
+              hydra_value_association(type).all_models.each do |model|
+                hydra_attribute = self.class.hydra_attribute(model.hydra_attribute_id)
+                attributes[hydra_attribute.name] = model.#{method}['value']
+              end
+            end
+          end
+        EOS
       end
 
-      def initialize_dup(other)
-        if other.instance_variable_defined?(:@hydra_attribute_names)
-          @hydra_attribute_names = other.instance_variable_get(:@hydra_attribute_names)
-        else
-          @hydra_attribute_names = self.class.hydra_attribute_names
-        end
-        super
+      %w(read_attribute read_attribute_before_type_cast).each do |method|
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          def #{method}(attr_name)
+            identifier = attr_name.to_s
+            if self.class.hydra_attribute_names.include?(identifier)
+              if value_model = hydra_value_model(identifier)
+                value_model.#{method}('value')
+              else
+                missing_attribute(identifier, caller)
+              end
+            else
+              super
+            end
+          end
+        EOS
       end
 
-      def hydra_attribute_model(name, type)
-        collection = send(HydraAttribute.config.association(type))
-        collection.detect { |model| model.name == name } || collection.build(name: name)
+      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 attributes
-        super.merge(hydra_attributes)
+      def hydra_value_association(backend_type)
+        association(::HydraAttribute::AssociationBuilder.association_name(backend_type))
       end
 
-      %w(attributes attributes_before_type_cast).each do |attr_method|
-        module_eval <<-EOS, __FILE__, __LINE__ + 1
-          def hydra_#{attr_method}
-            @hydra_attribute_names.each_with_object({}) do |name, attributes|
-              type = self.class.hydra_attributes[name]
-              attributes[name] = hydra_attribute_model(name, type).#{attr_method}['value']
-            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
+            super
           end
-        EOS
+        end
       end
     end
   end

data/lib/hydra_attribute/active_record/migration.rb

@@ -0,0 +1,21 @@
+module HydraAttribute
+  module ActiveRecord
+    module Migration
+      def create_hydra_entity(name, options = {}, &block)
+        Migrator.create(self, name, options, &block)
+      end
+
+      def drop_hydra_entity(name)
+        Migrator.drop(self, name)
+      end
+
+      def migrate_to_hydra_entity(name)
+        Migrator.migrate(self, name)
+      end
+
+      def rollback_from_hydra_entity(name)
+        Migrator.rollback(self, name)
+      end
+    end
+  end
+end

data/lib/hydra_attribute/active_record/reflection.rb

@@ -0,0 +1,16 @@
+module HydraAttribute
+  module ActiveRecord
+    class Reflection < ::ActiveRecord::Reflection::AssociationReflection
+
+      # Return custom association class
+      # which is optimized to load hydra attributes
+      def association_class
+        Association
+      end
+
+      def backend_type
+        @backend_type ||= SUPPORT_TYPES.find { |type| type == klass.model_name.demodulize.underscore.split('_')[1] }
+      end
+    end
+  end
+end

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

@@ -25,9 +25,9 @@ module HydraAttribute
             opts.inject(self) do |relation, (name, value)|
               if klass.hydra_attribute_names.include?(name.to_s)
                 relation, name = relation.clone, name.to_s
-                relation.hydra_joins_aliases << hydra_ref_alias(name, value)
-                relation.joins_values += build_hydra_joins_values(name, value)
-                relation.where_values += build_where(build_hydra_where_options(name, value))
+                relation.hydra_joins_aliases << hydra_helper.ref_alias(name, value)
+                relation.joins_values += hydra_helper.build_joins(name, value)
+                relation.where_values += build_where(hydra_helper.where_options(name, value))
                 relation
               else
                 relation.where_without_hydra_attribute(name => value)
@@ -39,21 +39,21 @@ module HydraAttribute
         end
 
         def build_arel
-          @group_values = build_hydra_values_for_arel(@group_values.uniq.reject(&:blank?))
-          @order_values = build_hydra_values_for_arel(@order_values.uniq.reject(&:blank?))
+          @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
-            @reorder_value = build_hydra_values_for_arel(@reorder_value.uniq.reject(&:blank?))
+            @reorder_value = hydra_helper.quote_columns(@reorder_value.uniq.reject(&:blank?))
           end
 
+          # detect hydra attributes from select list
           @hydra_select_values, @select_values = @select_values.partition { |value| klass.hydra_attribute_names.include?(value.to_s) }
           @hydra_select_values.map!(&:to_s)
-          @select_values.map!{ |value| hydra_attr_helper.prepend_table_name(value) }
+          @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_attr_helper.attr_eq_column?(v, klass.primary_key) }
-            @select_values << hydra_attr_helper.prepend_table_name(klass.primary_key)
-            @id_for_hydra_attributes = true
+          if @hydra_select_values.any? && @select_values.none? { |v| hydra_helper.attr_eq_column?(v, klass.primary_key) }
+            @select_values << hydra_helper.prepend_table_name(klass.primary_key)
           end
 
           super
@@ -77,83 +77,85 @@ module HydraAttribute
             ].include?(attr)
           end
 
-          def prepend_table_name(column)
-            return column unless column.is_a?(Symbol) or column.is_a?(String)
-
-            copy = column.to_s.strip
-            if copy =~ /^\w+$/
-              klass.quoted_table_name + '.' + connection.quote_column_name(copy)
+          def prepend_table_name(column, table = klass.table_name)
+            case column
+            when String, Symbol
+              copy = column.to_s.strip
+              if copy =~ /^\w+$/
+                connection.quote_table_name(table) + '.' + connection.quote_column_name(copy)
+              else
+                column
+              end
             else
               column
             end
           end
-        end
 
-        private
+          def build_joins(name, value)
+            conn         = klass.connection
+            quoted_alias = conn.quote_table_name(ref_alias(name, value))
+
+            [[
+              "#{join_type(value)} JOIN",
+              conn.quote_table_name(ref_table(name)),
+              'AS',
+              quoted_alias,
+              'ON',
+              "#{klass.quoted_table_name}.#{klass.quoted_primary_key}",
+              '=',
+              "#{quoted_alias}.#{conn.quote_column_name(:entity_id)}",
+              'AND',
+              "#{quoted_alias}.#{conn.quote_column_name(:hydra_attribute_id)}",
+              '=',
+              hydra_attribute_id(name)
+            ].join(' ')]
+          end
 
-        def hydra_attr_helper
-          @hydra_attr_helper ||= Helper.new(self)
-        end
+          def where_options(name, value)
+            {ref_alias(name, value) => {value: value}}
+          end
 
-        def build_hydra_values_for_arel(collection)
-          collection.map do |attribute|
-            attribute = attribute.respond_to?(:to_sql) ? attribute.to_sql : attribute.to_s
-            if klass.hydra_attribute_names.include?(attribute)
-              join_alias = hydra_ref_alias(attribute, 'inner') # alias for inner join
-              join_alias = hydra_ref_alias(attribute, nil) unless hydra_joins_aliases.include?(join_alias) # alias for left join
+          def ref_class(name)
+            type = klass.hydra_attribute(name).backend_type
+            AssociationBuilder.class_name(klass, type).constantize
+          end
 
-              @joins_values += build_hydra_joins_values(attribute, nil) unless hydra_joins_aliases.include?(join_alias)
-              klass.connection.quote_table_name(join_alias) + '.' + klass.connection.quote_column_name('value')
-            else
-              hydra_attr_helper.prepend_table_name(attribute)
-            end
+          def ref_table(name)
+            ref_class(name).table_name
           end
-        end
 
-        def build_hydra_joins_values(name, value)
-          ref_alias        = hydra_ref_alias(name, value)
-          conn             = klass.connection
-          quoted_ref_alias = conn.quote_table_name(ref_alias)
-
-          [[
-            "#{hydra_join_type(value)} JOIN",
-            conn.quote_table_name(hydra_ref_table(name)),
-            'AS',
-            quoted_ref_alias,
-            'ON',
-            "#{klass.quoted_table_name}.#{klass.quoted_primary_key}",
-            '=',
-            "#{quoted_ref_alias}.#{conn.quote_column_name(:entity_id)}",
-            'AND',
-            "#{quoted_ref_alias}.#{conn.quote_column_name(:entity_type)}",
-            '=',
-            conn.quote(klass.base_class.name),
-            'AND',
-            "#{quoted_ref_alias}.#{conn.quote_column_name(:name)}",
-            '=',
-            conn.quote(name)
-          ].join(' ')]
-        end
+          def ref_alias(name, value)
+            ref_table(name) + '_' + join_type(value).downcase + '_' + name
+          end
 
-        def build_hydra_where_options(name, value)
-          {hydra_ref_alias(name, value) => {value: value}}
-        end
+          def join_type(value)
+            value.nil? ? 'LEFT' : 'INNER'
+          end
 
-        def hydra_ref_class(name)
-          type = klass.hydra_attributes[name]
-          HydraAttribute.config.associated_model_name(type).constantize
-        end
+          def hydra_attribute_id(name)
+            klass.hydra_attribute(name).id
+          end
 
-        def hydra_ref_table(name)
-          hydra_ref_class(name).table_name
-        end
+          def quote_columns(columns)
+            columns.map do |column|
+              column = column.respond_to?(:to_sql) ? column.to_sql : column.to_s
+              if klass.hydra_attribute_names.include?(column)
+                join_alias = ref_alias(column, 'inner') # alias for inner join
+                join_alias = ref_alias(column, nil) unless relation.hydra_joins_aliases.include?(join_alias) # alias for left join
 
-        def hydra_ref_alias(name, value)
-          hydra_ref_table(name) + '_' + hydra_join_type(value).downcase + '_' + name
+                relation.joins_values += build_joins(column, nil) unless relation.hydra_joins_aliases.include?(join_alias)
+                prepend_table_name('value', join_alias)
+              else
+                prepend_table_name(column)
+              end
+            end
+          end
         end
 
-        def hydra_join_type(value)
-          value.nil? ? 'LEFT' : 'INNER'
+        private
+
+        def hydra_helper
+          @hydra_helper ||= Helper.new(self)
         end
       end
     end

data/lib/hydra_attribute/active_record/relation.rb

@@ -16,30 +16,7 @@ module HydraAttribute
         records = __old_exec_queries__
         return records if records.empty?
 
-        limit_values = select_values.any? || hydra_select_values.any?
-
-        if records.many?
-          if limit_values
-            hydra_attribute_types = hydra_select_values.map { |value| records.first.class.hydra_attributes[value] }.uniq
-          else
-            hydra_attribute_types = records.first.class.hydra_attribute_types
-          end
-
-          hydra_attribute_types.each do |type|
-            association = HydraAttribute.config.association(type)
-            unless records.first.association(association).loaded?
-              ::ActiveRecord::Associations::Preloader.new(records, association).run
-            end
-          end
-        end
-
-        if limit_values
-          records.each do |record| # force limit getter methods for hydra attributes
-            record.instance_variable_set(:@hydra_attribute_names, hydra_select_values)
-            record.instance_variable_get(:@attributes).delete('id') if @id_for_hydra_attributes
-          end
-        end
-
+        AssociationPreloader.run(self, records)
         records
       end
 

data/lib/hydra_attribute/active_record.rb

@@ -1,7 +1,21 @@
 module HydraAttribute
+
+  # ActiveRecord::Base extends this module.
   module ActiveRecord
-    def define_hydra_attributes(&block)
-      Builder.new(self).instance_eval(&block)
+
+    # Add EAV behavior to this model.
+    # Generate attribute and value associations.
+    def use_hydra_attributes
+      Builder.build(self)
+    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
+      end
     end
   end
 end