hydra_attribute 0.1.0

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

@@ -0,0 +1,162 @@
+module HydraAttribute
+  module ActiveRecord
+    module Relation
+      module QueryMethods
+        extend ActiveSupport::Concern
+
+        MULTI_VALUE_METHODS = [:hydra_joins_aliases, :hydra_select_values]
+
+        included do
+          attr_writer *MULTI_VALUE_METHODS
+
+          MULTI_VALUE_METHODS.each do |value|
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def #{value}; @#{value} ||= [] end
+            EOS
+          end
+
+          alias_method_chain :where, :hydra_attribute
+        end
+
+        def where_with_hydra_attribute(opts, *rest)
+          return self if opts.blank?
+
+          if opts.is_a?(Hash)
+            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
+              else
+                relation.where_without_hydra_attribute(name => value)
+              end
+            end
+          else
+            where_without_hydra_attribute(opts, *rest)
+          end
+        end
+
+        def build_arel
+          @order_values = build_order_values_for_arel(@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_order_values_for_arel(@reorder_value.uniq.reject(&:blank?))
+          end
+
+          @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) }
+
+          # 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
+          end
+
+          super
+        end
+
+        class Helper
+          attr_reader :relation, :klass, :connection
+
+          def initialize(relation)
+            @relation, @klass, @connection = relation, relation.klass, relation.connection
+          end
+
+          def attr_eq_column?(attr, column)
+            attr, column = attr.to_s, column.to_s
+            [
+              column,
+              "#{klass.table_name}.#{column}",
+              "#{klass.table_name}.#{connection.quote_column_name(column)}",
+              "#{klass.quoted_table_name}.#{column}",
+              "#{klass.quoted_table_name}.#{connection.quote_column_name(column)}"
+            ].include?(attr)
+          end
+
+          def prepend_table_name(column)
+            case column
+            when Symbol, String
+              if column.to_s.include?('.') or column.to_s.include?(')')
+                column
+              else
+                klass.quoted_table_name + '.' + connection.quote_column_name(column.to_s)
+              end
+            else
+              column
+            end
+          end
+        end
+
+        private
+
+        def hydra_attr_helper
+          @hydra_attr_helper ||= Helper.new(self)
+        end
+
+        def build_order_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
+
+              @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
+          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 build_hydra_where_options(name, value)
+          {hydra_ref_alias(name, value) => {value: value}}
+        end
+
+        def hydra_ref_class(name)
+          type = klass.hydra_attributes[name]
+          HydraAttribute.config.associated_model_name(type).constantize
+        end
+
+        def hydra_ref_table(name)
+          hydra_ref_class(name).table_name
+        end
+
+        def hydra_ref_alias(name, value)
+          hydra_ref_table(name) + '_' + hydra_join_type(value).downcase + '_' + name
+        end
+
+        def hydra_join_type(value)
+          value.nil? ? 'LEFT' : 'INNER'
+        end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/active_record/scoping.rb

@@ -0,0 +1,15 @@
+module HydraAttribute
+  module ActiveRecord
+    module Scoping
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def scoped(options = nil)
+          relation = super(options)
+          relation.singleton_class.send(:include, Relation) unless relation.is_a?(Relation)
+          relation
+        end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/association_builder.rb

@@ -0,0 +1,40 @@
+module HydraAttribute
+  class AssociationBuilder
+
+    def initialize(klass, type)
+      @klass, @type = klass, type
+    end
+
+    def build
+      create_associated_model
+      add_association_for_class
+    end
+
+    private
+
+    def create_associated_model
+      const = config.associated_const_name(@type)
+      unless namespace.const_defined?(const)
+        klass = namespace.const_set(const, Class.new(::ActiveRecord::Base))
+        klass.table_name = config.table_name(@type)
+        klass.attr_accessible :name, :value
+        klass.belongs_to :entity, polymorphic: true, touch: true, autosave: true
+      end
+    end
+
+    def add_association_for_class
+      assoc = config.association(@type)
+      unless @klass.reflect_on_association(assoc)
+        @klass.has_many assoc, as: :entity, class_name: config.associated_model_name(@type), autosave: true, dependent: :destroy
+      end
+    end
+
+    def config
+      HydraAttribute.config
+    end
+
+    def namespace
+      config.use_module_for_associated_models ? HydraAttribute : Object
+    end
+  end
+end

data/lib/hydra_attribute/attribute_builder.rb

@@ -0,0 +1,57 @@
+module HydraAttribute
+  class AttributeBuilder
+    NAME_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
+    CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
+
+    attr_reader :klass, :name, :type
+
+    def initialize(klass, name, type)
+      @klass, @name, @type = klass, name.to_s, type
+    end
+
+    def build
+      define_attribute_methods
+      save_attribute
+    end
+
+    private
+
+    def define_attribute_methods
+      m = Module.new
+      @klass.attribute_method_matchers.each do |matcher|
+        current = matcher.method_name(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
+
+        body = "hydra_attribute_model('#{name}', :#{type}).#{send}"
+        if current.end_with?('=')
+          body = "v = #{body}; @hydra_attribute_names << '#{name}' unless @hydra_attribute_names.include?('#{name}'); v"
+        else
+          body.insert(0, "missing_attribute('#{name}', caller) unless @hydra_attribute_names.include?('#{name}'); ")
+        end
+
+        m.class_eval <<-EOS, __FILE__, __LINE__ + 1
+          #{defn}
+            #{body}
+          end
+        EOS
+      end
+      klass.send :include, m
+    end
+
+    def save_attribute
+      klass.instance_variable_get(:@hydra_attributes)[name] = type
+    end
+  end
+end

data/lib/hydra_attribute/attribute_proxy.rb

@@ -0,0 +1,16 @@
+module HydraAttribute
+  module AttributeProxy
+    def use_proxy_to_hydra_attribute(symbol)
+      module_eval <<-EOS, __FILE__, __LINE__ + 1
+        def #{symbol}(attr_name)
+          if self.class.hydra_attribute_names.include?(attr_name)
+            type = self.class.hydra_attributes[attr_name]
+            hydra_attribute_model(attr_name, type).#{symbol}('value')
+          else
+            super
+          end
+        end
+      EOS
+    end
+  end
+end

data/lib/hydra_attribute/builder.rb

@@ -0,0 +1,25 @@
+module HydraAttribute
+  class Builder
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass
+      @klass.class_eval do
+        include ActiveRecord::Scoping
+        include ActiveRecord::AttributeMethods
+      end
+    end
+
+    SUPPORT_TYPES.each do |type|
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
+        def #{type}(*attributes)
+          AssociationBuilder.new(klass, :#{type}).build
+
+          attributes.each do |attribute|
+            AttributeBuilder.new(klass, attribute, :#{type}).build
+          end
+        end
+      EOS
+    end
+  end
+end

data/lib/hydra_attribute/configuration.rb

@@ -0,0 +1,47 @@
+module HydraAttribute
+  class Configuration
+    def self.add_setting(name, default_value)
+      attr_writer name
+
+      define_method name do
+        instance_variable_set("@#{name}", default_value) unless instance_variable_defined?("@#{name}")
+        instance_variable_get("@#{name}")
+      end
+
+      define_method "#{name}?" do
+        send(name).present?
+      end
+    end
+
+    add_setting :table_prefix,                     'hydra_'
+    add_setting :association_prefix,               'hydra_'
+    add_setting :use_module_for_associated_models, true
+
+    def table_name(type)
+      "#{table_prefix}#{type}_attributes".to_sym
+    end
+
+    def association(type)
+      "#{association_prefix}#{type}_attributes".to_sym
+    end
+
+    # Return string for compatibility with ActiveRecord 3.1.x
+    def associated_model_name(type)
+      klass = associated_const_name(type).to_s
+      klass = "HydraAttribute::#{klass}" if use_module_for_associated_models?
+      klass
+    end
+
+    def associated_const_name(type)
+      "#{type.to_s.titlecase}Attribute".to_sym
+    end
+
+    def relation_execute_method
+      if ::ActiveRecord::VERSION::MINOR > 1
+        :exec_queries
+      else
+        :to_a
+      end
+    end
+  end
+end

data/lib/hydra_attribute/migration.rb

@@ -0,0 +1,27 @@
+module HydraAttribute
+  class Migration
+    def initialize(migration)
+      @migration = migration
+    end
+
+    def migrate
+      SUPPORT_TYPES.each do |type|
+        table_name = HydraAttribute.config.table_name(type)
+        @migration.create_table table_name do |t|
+          t.integer :entity_id
+          t.string  :entity_type
+          t.string  :name
+          t.send type, :value
+        end
+
+        @migration.add_index table_name, [:entity_id, :entity_type, :name], unique: true, name: "index_#{table_name}_on_attribute"
+      end
+    end
+
+    def rollback
+      SUPPORT_TYPES.each do |type|
+        @migration.drop_table HydraAttribute.config.table_name(type)
+      end
+    end
+  end
+end

data/lib/hydra_attribute/railtie.rb

@@ -0,0 +1,9 @@
+module HydraAttribute
+  class Railtie < Rails::Railtie
+    initializer 'hydra_attribute.active_record' do
+      ActiveSupport.on_load :active_record do
+        extend ::HydraAttribute::ActiveRecord
+      end
+    end
+  end
+end

data/lib/hydra_attribute/version.rb

@@ -0,0 +1,3 @@
+module HydraAttribute
+  VERSION = '0.1.0'
+end

data/spec/hydra_attribute/active_record/relation/query_methods_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+describe HydraAttribute::ActiveRecord::Relation::QueryMethods do
+  let(:relation_class) do
+    mock(
+      :hydra_attributes      => {'code' => :string},
+      :hydra_attribute_names => ['code'],
+      :hydra_attribute_types => [:string]
+    )
+  end
+
+  let(:relation) { mock(klass: relation_class, where: nil) }
+
+  before do
+    relation.singleton_class.send :include, ::ActiveRecord::QueryMethods
+    relation.singleton_class.send :include, HydraAttribute::ActiveRecord::Relation::QueryMethods
+  end
+
+  describe '#where' do
+    let(:relation) do
+      mock_relation = mock(klass: relation_class)
+      mock_relation.instance_variable_set(:@where_values, [])
+      mock_relation.instance_variable_set(:@joins_values, [])
+      mock_relation.stub(:build_hydra_joins_values)  { |name, value| ["join-#{name}-#{value}"]  }
+      mock_relation.stub(:build_hydra_where_options) { |name, value| ["where-#{name}-#{value}"] }
+      mock_relation.stub(:build_where)               { |value, *rest| ["#{value} #{rest}"] }
+      mock_relation
+    end
+
+    before do
+      module HydraAttribute
+        class StringAttribute
+          def self.table_name
+            'hydra_string_attributes'
+          end
+        end
+      end
+    end
+
+    after do
+      HydraAttribute.send :remove_const, :StringAttribute
+    end
+
+    describe 'first param is Hash' do
+      let(:params) { {'title' => 1} }
+
+      describe 'hash has not hydra attribute' do
+        it 'should call rails native "where" method' do
+          object = relation.where(params)
+          object.where_values.should        == ['{"title"=>1} [[]]']
+          object.joins_values.should        == []
+          object.hydra_joins_aliases.should == []
+        end
+      end
+
+      describe 'hash has hydra attribute' do
+        let(:params) { {'title' => 1, 'code' => 2, 'name' => 3} }
+
+        it 'should call both native and overwritten "where" method' do
+          copy_relation = relation.where(params)
+          copy_relation.where_values.should        == ['{"title"=>1} [[]]', 'where-code-2 []', '{"name"=>3} [[]]']
+          copy_relation.joins_values.should        == ['join-code-2']
+          copy_relation.hydra_joins_aliases.should == ['hydra_string_attributes_inner_code']
+        end
+      end
+    end
+
+    describe 'first param is not Hash' do
+      let(:params) { 'name = 1' }
+
+      it 'should call rails native "where" method' do
+        copy_relation = relation.where(params)
+        copy_relation.where_values.should        == ['name = 1 [[]]']
+        copy_relation.joins_values.should        == []
+        copy_relation.hydra_joins_aliases.should == []
+      end
+    end
+  end
+
+  describe '#build_arel' do
+    let(:arel) { mock.as_null_object }
+
+    let(:relation) do
+      mock_relation = mock(klass: relation_class, where: nil, build_select: nil)
+      mock_relation.stub_chain(:table, :from).and_return(arel)
+      mock_relation.instance_variable_set(:@joins_values, [])
+      mock_relation.instance_variable_set(:@order_values, [])
+      mock_relation.instance_variable_set(:@where_values, [])
+      mock_relation.instance_variable_set(:@having_values, [])
+      mock_relation.instance_variable_set(:@group_values, [])
+      mock_relation.instance_variable_set(:@select_values, [])
+      mock_relation
+    end
+
+    it 'should update @order_values before generate the arel object' do
+      relation.stub(build_order_values_for_arel: %w(build_order))
+      relation.build_arel.should == arel
+      relation.instance_variable_get(:@order_values).should == %w(build_order)
+    end
+  end
+
+  describe '#build_order_values_for_arel' do
+    let(:connection) do
+      conn = mock
+      conn.stub(:quote_column_name) { |column| column.to_s        }
+      conn.stub(:quote)             { |value| %Q("#{value.to_s}") }
+      conn.stub(:quote_table_name)  { |table| table.to_s          }
+      conn
+    end
+
+    let(:relation_class) do
+      mock(connection: connection, quoted_table_name: 'product', hydra_attribute_names: %w(code title price))
+    end
+
+    let(:relation) do
+      mock_relation = mock(klass: relation_class, connection: connection)
+      mock_relation.stub(where: mock_relation)
+      mock_relation.stub(:hydra_ref_alias)          { |name, value| "#{name}_#{value}"        }
+      mock_relation.stub(:build_hydra_joins_values) { |name, value| ["#{name}_#{value}_join"] }
+      mock_relation.instance_variable_set(:@joins_values, [])
+      mock_relation.instance_variable_set(:@hydra_joins_aliases, %w(code_inner title_))
+      mock_relation
+    end
+
+    describe 'collection has not hydra attributes' do
+      it 'should return the same collection' do
+        relation.send(:build_order_values_for_arel, %w(name zone)).should == %w(product.name product.zone)
+        relation.joins_values.should == []
+      end
+    end
+
+    describe 'collection has hydra attributes' do
+      it 'should change hydra attributes and join hydra tables' do
+        relation.send(:build_order_values_for_arel, %w(name code title price)).should == %w(product.name code_inner.value title_.value price_.value)
+        relation.joins_values.should == %w(price__join)
+      end
+    end
+  end
+
+  describe '#build_hydra_joins_values' do
+    let(:connection) do
+      conn = mock
+      conn.stub(:quote_column_name) { |column| column.to_s        }
+      conn.stub(:quote)             { |value| %Q("#{value.to_s}") }
+      conn.stub(:quote_table_name)  { |table| table.to_s          }
+      conn
+    end
+
+    let(:relation_class) do
+      mock(
+        :connection         => connection,
+        :base_class         => mock(name: 'BaseClass'),
+        :quoted_primary_key => 'id',
+        :quoted_table_name  => 'hydra_string_attributes'
+      )
+    end
+
+    let(:relation) do
+      mock_relation = mock(klass: relation_class)
+      mock_relation.stub(where: mock_relation)
+      mock_relation.stub(:hydra_ref_alias) { |name, value| "#{name}_#{value}" }
+      mock_relation.stub(:hydra_ref_table) { |name| "table_#{name}"           }
+      mock_relation
+    end
+
+    describe 'value is nil' do
+      let(:value) { nil }
+      let(:sql)   { 'LEFT JOIN table_name AS name_ ON hydra_string_attributes.id = name_.entity_id AND name_.entity_type = "BaseClass" AND name_.name = "name"' }
+
+      it 'should return array with one SQL query element' do
+        relation.send(:build_hydra_joins_values, :name, value).should == [sql]
+      end
+    end
+
+    describe 'value is not nil' do
+      let(:value) { 'value' }
+      let(:sql)   { 'INNER JOIN table_name AS name_value ON hydra_string_attributes.id = name_value.entity_id AND name_value.entity_type = "BaseClass" AND name_value.name = "name"' }
+
+      it 'should return array with one SQL query element' do
+        relation.send(:build_hydra_joins_values, :name, value).should == [sql]
+      end
+    end
+  end
+
+  describe '#build_hydra_where_options' do
+    before do
+      module HydraAttribute
+        class StringAttribute
+          def self.table_name
+            'hydra_string_attributes'
+          end
+        end
+      end
+    end
+
+    after { HydraAttribute.send :remove_const, :StringAttribute }
+
+    it 'should create where options with table namespace' do
+      relation.send(:build_hydra_where_options, 'code', 'abc').should == {'hydra_string_attributes_inner_code' => { value: 'abc' }}
+    end
+  end
+
+  describe '#hydra_ref_class' do
+    before do
+      module HydraAttribute
+        class StringAttribute
+          def self.table_name
+            'hydra_string_attributes'
+          end
+        end
+      end
+    end
+
+    after { HydraAttribute.send :remove_const, :StringAttribute }
+
+    it 'should return class by attribute name' do
+      relation.send(:hydra_ref_class, 'code').should == HydraAttribute::StringAttribute
+    end
+  end
+
+  describe '#hydra_ref_table' do
+    before do
+      module HydraAttribute
+        class StringAttribute
+          def self.table_name
+            'hydra_string_attributes'
+          end
+        end
+      end
+    end
+
+    after { HydraAttribute.send :remove_const, :StringAttribute }
+
+    it 'should return table name' do
+      relation.send(:hydra_ref_table, 'code').should == 'hydra_string_attributes'
+    end
+  end
+
+  describe '#hydra_ref_alias' do
+    before do
+      module HydraAttribute
+        class StringAttribute
+          def self.table_name
+            'hydra_string_attributes'
+          end
+        end
+      end
+    end
+
+    after { HydraAttribute.send :remove_const, :StringAttribute }
+
+    describe 'value is nil' do
+      let(:value) { nil }
+
+      it 'should return generated alias name' do
+        relation.send(:hydra_ref_alias, 'code', value).should == 'hydra_string_attributes_left_code'
+      end
+    end
+
+    describe 'value is not nil' do
+      let(:value) { '' }
+
+      it 'should return generated alias name' do
+        relation.send(:hydra_ref_alias, 'code', value).should == 'hydra_string_attributes_inner_code'
+      end
+    end
+  end
+
+  describe '#hydra_join_type' do
+    describe 'value is nil' do
+      let(:value) { nil }
+
+      it 'should return "LEFT"' do
+        relation.send(:hydra_join_type, value).should == 'LEFT'
+      end
+    end
+
+    describe 'value is not nil' do
+      let(:value) { '' }
+
+      it 'should return "INNER"' do
+        relation.send(:hydra_join_type, value).should == 'INNER'
+      end
+    end
+  end
+end