hydra_attribute 0.4.2 → 0.5.0.rc1

data/.gitignore

@@ -1,3 +1,4 @@
+.DS_Store
 *.gem
 *.rbc
 .bundle
@@ -18,4 +19,4 @@ tmp
 .idea
 .rvmrc
 bin/
-gemfiles
+gemfiles/*.lock

data/.travis.yml

@@ -1,9 +1,10 @@
 language: ruby
 rvm:
   - 1.9.3
-
-before_install: bundle && rake appraisal:gemfiles
-
+  - 2.0.0
 gemfile:
-  - gemfiles/3.1.gemfile
-  - gemfiles/3.2.gemfile
+  - gemfiles/activerecord-3.2.gemfile
+env:
+  - DB=sqlite
+  - DB=mysql
+  - DB=postgresql

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+**0.5.0 (...)**
+* Cache all hydra attributes per request
+* Add support of `decimal` backend type
+* Add `id` to `hydra_attribute_sets` table
+* Use new index name pattern `*_idx` instead of `*_index`
+
 **0.4.2 (January 20, 2013)**
 * Fixed bug in `count` method which added unnecessary columns to query [#2](https://github.com/kostyantyn/hydra_attribute/issues/2)
 

data/Gemfile

@@ -1,3 +1,3 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -1,4 +1,4 @@
-# hydra_attribute [![Gem Version](https://fury-badge.herokuapp.com/rb/hydra_attribute.png)](http://badge.fury.io/rb/hydra_attribute) [![Build Status](https://secure.travis-ci.org/kostyantyn/hydra_attribute.png)](http://travis-ci.org/kostyantyn/hydra_attribute)
+# hydra_attribute [![Gem Version](https://fury-badge.herokuapp.com/rb/hydra_attribute.png)](http://badge.fury.io/rb/hydra_attribute) [![Build Status](https://travis-ci.org/kostyantyn/hydra_attribute.png?branch=value_model_optimization)](https://travis-ci.org/kostyantyn/hydra_attribute)
 
 [Wiki](https://github.com/kostyantyn/hydra_attribute/wiki) | [RDoc](http://rdoc.info/github/kostyantyn/hydra_attribute)
 
@@ -12,7 +12,7 @@ Until the first major version is released:
 
 ## Requirements
 * ruby >= 1.9.2
-* active_record ~> 3.1
+* active_record ~> 3.2
 
 ## Installation
 
@@ -82,7 +82,7 @@ Creating method accepts the following options:
 * **name**. The **required** parameter. Any string is allowed.   
 * **backend_type**. The **required** parameter. One of the following strings is allowed: `string`, `text`, `integer`, `float`, `boolean` and `datetime`.
 * **default_value**. The **optional** parameter. Any value is allowed. `nil` is default.
-* **white_list**. The **optional** parameter. Should be `true` or `flase`. `false` is default. If `white_list: true` is passed, this attribute will be added to white list and will be allowed for mass-assignment. This parameter is in black list for creation by default so if you want to pass it, you have to pass the role `as: :admin` too.
+* **white_list**. The **optional** parameter. Should be `true` or `false`. `false` is default. If `white_list: true` is passed, this attribute will be added to white list and will be allowed for mass-assignment. This parameter is in black list for creation by default so if you want to pass it, you have to pass the role `as: :admin` too.
 
   ```ruby
     Product.hydra_attributes.create({name: 'title', backend_type: 'string', white_list: true}, as: :admin)

data/Rakefile

@@ -1,12 +1,7 @@
 #!/usr/bin/env rake
 require 'bundler/gem_tasks'
-require 'appraisal'
 require 'rspec/core/rake_task'
-require 'cucumber/rake/task'
 
-RSpec::Core::RakeTask.new('spec')
-Cucumber::Rake::Task.new(:features) do |t|
-  t.cucumber_opts = '--format pretty'
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task default: [:features, :spec]
+task default: [:spec]

data/gemfiles/activerecord-3.2.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 3.2.0'
+
+gemspec path: '../'

data/hydra_attribute.gemspec

@@ -8,18 +8,17 @@ Gem::Specification.new do |gem|
   gem.description           = 'hydra_attribute is an implementation of EAV pattern for ActiveRecord models.'
   gem.homepage              = 'https://github.com/kostyantyn/hydra_attribute'
   gem.files                 = `git ls-files`.split("\n")
-  gem.test_files            = `git ls-files -- Appraisals {spec,features,gemfiles}/*`.split("\n")
-  gem.name                  = "hydra_attribute"
+  gem.test_files            = `git ls-files -- {spec,features,gemfiles}/*`.split("\n")
+  gem.name                  = 'hydra_attribute'
   gem.require_paths         = %w(lib)
   gem.required_ruby_version = Gem::Requirement.new('>= 1.9.2')
   gem.version               = HydraAttribute::VERSION
 
-  gem.add_dependency('activerecord', '~> 3.1')
+  gem.add_dependency('activerecord', '~> 3.2')
 
-  gem.add_development_dependency('rspec')
-  gem.add_development_dependency('cucumber')
+  gem.add_development_dependency('rspec', '~> 2.13')
   gem.add_development_dependency('sqlite3')
-  gem.add_development_dependency('database_cleaner')
-  gem.add_development_dependency('appraisal')
+  gem.add_development_dependency('mysql2')
+  gem.add_development_dependency('pg')
   gem.add_development_dependency('rake')
 end

data/lib/hydra_attribute.rb

@@ -1,5 +1,7 @@
+require 'active_record'
+
 module HydraAttribute
-  SUPPORTED_BACKEND_TYPES = %w(string text integer float boolean datetime).freeze
+  SUPPORTED_BACKEND_TYPES = %w[string text integer float decimal boolean datetime].freeze
 
   class << self
     def config
@@ -9,32 +11,29 @@ module HydraAttribute
     def setup
       yield config
     end
+
+    def identity_map
+      Thread.current[:hydra_attribute] ||= IdentityMap.new
+    end
+
+    def cache(key, value = nil, &block)
+      identity_map.cache(key, value, &block)
+    end
   end
 
 end
 
 require 'hydra_attribute/version'
 require 'hydra_attribute/configuration'
-require 'hydra_attribute/association_builder'
-require 'hydra_attribute/builder'
 require 'hydra_attribute/migrator'
-require 'hydra_attribute/memoizable'
+require 'hydra_attribute/identity_map'
+require 'hydra_attribute/model'
 require 'hydra_attribute/hydra_attribute'
 require 'hydra_attribute/hydra_set'
-require 'hydra_attribute/entity_callbacks'
-require 'hydra_attribute/hydra_set_methods'
-require 'hydra_attribute/hydra_value_methods'
-require 'hydra_attribute/hydra_attribute_methods'
-require 'hydra_attribute/hydra_methods'
+require 'hydra_attribute/hydra_attribute_set'
+require 'hydra_attribute/hydra_value'
+require 'hydra_attribute/hydra_entity'
+require 'hydra_attribute/hydra_entity_attribute_association'
 require 'hydra_attribute/active_record'
-require 'hydra_attribute/active_record/scoping'
-require 'hydra_attribute/active_record/reflection'
-require 'hydra_attribute/active_record/association'
-require 'hydra_attribute/active_record/association_preloader'
-require 'hydra_attribute/active_record/migration'
-require 'hydra_attribute/active_record/relation'
-require 'hydra_attribute/active_record/relation/calculations'
-require 'hydra_attribute/active_record/relation/query_methods'
-require 'hydra_attribute/active_record/attribute_methods'
 
 require 'hydra_attribute/railtie' if defined?(Rails)

data/lib/hydra_attribute/active_record.rb

@@ -1,29 +1,50 @@
+require 'hydra_attribute/active_record/attribute_methods'
+require 'hydra_attribute/active_record/migration'
+require 'hydra_attribute/active_record/relation'
+require 'hydra_attribute/active_record/scoping'
+require 'hydra_attribute/active_record/mass_assignment_security'
+
 module HydraAttribute
   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
+    extend ActiveSupport::Concern
 
-      unless base.base_class.equal?(base)
-        raise %(HydraAttribute::ActiveRecord module should be included to base class "#{base.base_class}" instead of "#{base}")
+    included do
+      unless ancestors.include?(::ActiveRecord::Base)
+        raise %(Cannot include HydraAttribute::ActiveRecord module because "#{self}" is not inherited from ActiveRecord::Base)
       end
 
-      super
-
-      base.extend(ClassMethods)
-      Builder.build(base)
+      unless base_class.equal?(self)
+        raise %(HydraAttribute::ActiveRecord module should be included to the base class "#{base_class}" instead of "#{self}")
+      end
     end
 
+    include ::HydraAttribute::HydraEntity
+    include ::HydraAttribute::ActiveRecord::Scoping
+    include ::HydraAttribute::ActiveRecord::AttributeMethods
+    include ::HydraAttribute::ActiveRecord::MassAssignmentSecurity
+
     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)
+      def inspect
+        if hydra_attributes.any?
+          inspection = hydra_attributes.map do |hydra_attribute|
+            "#{hydra_attribute.name}: #{hydra_attribute.backend_type}"
+          end
+          super.sub(/\)$/, ", #{inspection.join(', ')})")
         else
           super
         end
       end
     end
 
+    def inspect
+      if hydra_attributes.any?
+        inspection = hydra_attributes.keys.map do |name|
+          "#{name}: #{attribute_for_inspect(name)}"
+        end
+        super.sub(/>$/, ", #{inspection.join(', ')}>")
+      else
+        super
+      end
+    end
   end
 end

data/lib/hydra_attribute/active_record/association_preloader.rb

@@ -6,7 +6,6 @@ module HydraAttribute
       def initialize(relation, records = [])
         @relation = relation
         @records  = records
-        prepared_records # lock attributes
       end
 
       def self.run(relation, records)
@@ -16,41 +15,69 @@ module HydraAttribute
       def run
         return if records.blank?
 
-        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?
+        prepared_records.keys.each_slice(in_clause_length || records.length) do |entity_ids|
+          grouped_hydra_attribute_ids.each do |backend_type, hydra_attribute_ids|
+            next if hydra_attribute_ids.blank? # entity doesn't have any hydra attributes for the current backend type
 
+            # set values from database
+            database_entity_and_hydra_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)
+              ::ActiveRecord::Base.connection.select_all("SELECT id, entity_id, hydra_attribute_id, value FROM hydra_#{backend_type}_#{klass.table_name} WHERE entity_id IN (#{entity_ids.join(', ')}) AND hydra_attribute_id IN (#{attribute_ids.join(', ')})").each do |attributes|
+                # PostgreSQL driver doesn't convert values, it returns them as strings
+                id                 = attributes['id'].to_i
+                entity_id          = attributes['entity_id'].to_i
+                hydra_attribute_id = attributes['hydra_attribute_id'].to_i
+
+                assign_hydra_value_options(id: id, entity_id: entity_id, hydra_attribute_id: hydra_attribute_id, value: attributes['value'])
+                (database_entity_and_hydra_attribute_ids[entity_id] ||= []) << hydra_attribute_id
+              end
+            end
+
+            # set nil if attribute's value is not saved into the database
+            # these values are not persisted
+            entity_ids.each do |entity_id|
+              missing_hydra_attribute_ids = hydra_attribute_ids - Array(database_entity_and_hydra_attribute_ids[entity_id])
+              missing_hydra_attribute_ids.each do |missing_hydra_attribute_id|
+                assign_hydra_value_options(entity_id: entity_id, hydra_attribute_id: missing_hydra_attribute_id, value: nil)
               end
             end
           end
         end
       end
 
+      def assign_hydra_value_options(options = {})
+        entity = prepared_records[options[:entity_id]]
+        assoc  = entity.hydra_attribute_association
+
+        if entity.hydra_set_id
+          assoc.hydra_value_options = options.symbolize_keys if entity.hydra_set.has_hydra_attribute_id?(options[:hydra_attribute_id])
+        else
+          assoc.hydra_value_options = options.symbolize_keys
+        end
+      end
+
       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
+            record.hydra_attribute_association.lock_values
             hash[record.id] = record
           end
         end
 
-        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
+        def grouped_hydra_attribute_ids
+          @grouped_hydra_attribute_ids ||= begin
+            hydra_attributes = ::HydraAttribute::HydraAttribute.all_by_entity_type(klass.model_name)
+            if attribute_limit?
+              map = hydra_attributes.map(&:backend_type).each_with_object({}) { |backend_type, hash| hash[backend_type] = [] }
+              relation.hydra_select_values.each_with_object(map) do |name, grouped_ids|
+                hydra_attribute = hydra_attributes.find { |attr| attr.name == name }
+                grouped_ids[hydra_attribute.backend_type] << hydra_attribute.id
+              end
+            else
+              hydra_attributes.each_with_object({}) do |hydra_attribute, hash|
+                (hash[hydra_attribute.backend_type] ||= []) << hydra_attribute.id
+              end
             end
-          else
-            klass.hydra_attribute_ids_by_backend_type
           end
         end
 
@@ -58,14 +85,6 @@ module HydraAttribute
           relation.select_values.any? or relation.hydra_select_values.any?
         end
 
-        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
-
-        def association_builder
-          AssociationBuilder
-        end
-
         def connection
           relation.connection
         end

data/lib/hydra_attribute/active_record/attribute_methods.rb

@@ -3,156 +3,45 @@ 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/
-
-      included do
-        @hydra_attribute_methods_mutex = Mutex.new
+      # Returns type casted attributes
+      #
+      # @return [Hash]
+      def attributes
+        super.merge(hydra_attributes)
       end
 
-      module ClassMethods
-        def hydra_attribute_methods_generated?
-          base_class.instance_variable_get(:@hydra_attribute_methods_generated) || base_class.instance_variable_set(:@hydra_attribute_methods_generated, false)
-        end
-
-        def generated_hydra_attribute_methods
-          return base_class.instance_variable_get(:@generated_hydra_attribute_methods) if base_class.instance_variable_defined?(:@generated_hydra_attribute_methods)
-
-          mod = Module.new
-          base_class.send(:include, mod)
-          base_class.instance_variable_set(:@generated_hydra_attribute_methods, mod)
-        end
-
-        def define_hydra_attribute_methods
-          base_class.instance_variable_get(:@hydra_attribute_methods_mutex).synchronize do
-            return if hydra_attribute_methods_generated?
-            hydra_attributes.each { |hydra_attribute| define_hydra_attribute_method(hydra_attribute) }
-            base_class.instance_variable_set(:@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 hydra_set_id? and self.class.hydra_set_attribute_ids(hydra_set_id).exclude?(#{hydra_attribute.id})
-                  raise MissingAttributeInHydraSetError, %(Hydra attribute "#{hydra_attribute.name}" does not exist in hydra set "\#{self.class.hydra_set(hydra_set_id).name}")
-                end
-
-                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
-          base_class.instance_variable_set(:@hydra_attribute_methods_generated, false)
-
-          clear_hydra_method_cache!
-        end
-
-        def undefine_attribute_methods
-          reset_hydra_attribute_methods!
-          super
-        end
-
-        def inspect
-          attr_list  = columns.map { |c| "#{c.name}: #{c.type}" }
-          attr_list += hydra_attributes.map { |a| "#{a.name}: #{a.backend_type}" }
-          "#{name}(#{attr_list.join(', ')})"
-        end
+      # Returns attributes before type casting
+      #
+      # @return [Hash]
+      def attributes_before_type_cast
+        super.merge(hydra_attributes_before_type_cast)
       end
 
-      def respond_to?(name, include_private = false)
-        self.class.define_hydra_attribute_methods unless self.class.hydra_attribute_methods_generated?
-
-        # @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 self.class.hydra_attribute_names.include?(attr_name)
-          self.class.hydra_set_attribute_names(hydra_set_id).include?(attr_name)
+      # Read type cast attribute value by its name
+      #
+      # @param [String,Symbol] name
+      # @return [Hash]
+      def read_attribute(name)
+        name = name.to_s
+        if hydra_attributes.has_key?(name)
+          hydra_attributes[name]
         else
           super
         end
       end
 
-      def attributes
-        hydra_value_models.each_with_object(super) do |model, attributes|
-          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.hydra_attribute_name] = model.read_attribute_before_type_cast('value')
-        end
-      end
-
-      %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_set_attribute_names(hydra_set_id).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 inspect
-        attrs = hydra_value_models.map { |model| "#{model.hydra_attribute_name}: #{model.attribute_for_inspect('value')}" }
-        super.gsub(/>$/, ", #{attrs.join(', ')}>")
+      # Assigns attributes to the model
+      #
+      # @param [Hash] new_attributes
+      # @param [Hash] options
+      # @return [NilClass]
+      def assign_attributes(new_attributes, options = {})
+        if new_attributes[:hydra_set_id]
+          # set :hydra_set_id attribute as a last attribute to avoid HydraAttribute::HydraSet::MissingAttributeInHydraSetError error
+          new_attributes[:hydra_set_id] = new_attributes.delete(:hydra_set_id)
+        end
+        super
       end
-
-      private
-        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