hydra_attribute 0.4.2 → 0.5.0.rc1

data/features/step_definitions/query_methods.rb

@@ -1,48 +0,0 @@
-When /^filter "([^"]+)" by:$/ do |klass, table|
-  condition = table.hashes.each_with_object({}) { |item, hash| hash[item[:field].to_sym] = type_cast_value(item[:value]) }
-  @records  = Object.const_get(klass).where(condition)
-end
-
-When /^filter "([^"]+)" records by "([^"]+)"$/ do |klass, attribute|
-  @records = Object.const_get(klass)
-  step %(filter records by "#{attribute}")
-end
-
-When /^filter records by "([^"]+)"$/ do |attribute|
-  name, value = type_cast_attribute(attribute)
-  @records = @records.where(name => value)
-end
-
-When /^group "([^"]+)" by "([^"]+)"$/ do |klass, attributes|
-  @records = Object.const_get(klass)
-  step %(group by "#{attributes}")
-end
-
-When /^group by "([^"]+)"$/ do |attributes|
-  @records = @records.group(attributes.split)
-end
-
-When /^(order|reorder) "([^"]+)" records by "([^"]+)"$/ do |sort_method, klass, attributes|
-  @records = Object.const_get(klass)
-  step %(#{sort_method} records by "#{attributes}")
-end
-
-When /^(order|reorder) records by "([^"]+)"$/ do |sort_method, attributes|
-  reverse  = false
-  fields   = attributes.split.inject([]) do |items, attribute|
-    name, direction = attribute.split('=')
-    reverse = true if direction == 'desc'
-    items << name.to_sym
-  end
-
-  @records = @records.send(sort_method, fields)
-  @records = @records.reverse_order if reverse
-end
-
-When /^reverse order records$/ do
-  @records = @records.reverse_order
-end
-
-When /^"([^"]+)" select only the following columns "([^"]+)"$/ do |klass, columns|
-  @records = Object.const_get(klass).select(columns.split(/\s+/).map(&:to_sym))
-end

data/features/step_definitions/record_steps.rb

@@ -1,93 +0,0 @@
-When /^load all "([^"]+)" records$/ do |klass|
-  @records = klass.constantize.all
-end
-
-When /^select (first|last) "([^"]+)" record$/ do |method, klass|
-  @record = klass.constantize.send(method)
-end
-
-When /^assign attributes as "([^"]+)":$/ do |format, table|
-  Array.wrap(table.send(format)).each do |hash|
-    @record.assign_attributes(type_cast_hash(hash))
-  end
-end
-
-When /^(save|destroy) record$/ do |action|
-  @record.send(action)
-end
-
-When /^keep "([^"]+)" attribute$/ do |attribute|
-  @keep ||= {}
-  @keep[attribute] = @record.send(attribute)
-end
-
-Then /^update attributes as "([^"]+)":$/ do |role, table|
-  @record.update_attributes(type_cast_hash(table.rows_hash), as: role.to_sym)
-end
-
-Then /^record should be nil$/ do
-  @record.should be_nil
-end
-
-Then /^attribute "([^"]+)" (should(?:\snot)?) be the same$/ do |attribute, behavior|
-  method = behavior.sub(/\s/, '_')
-  @keep[attribute].send(method) == @record.send(attribute)
-end
-
-Then /^record (read attribute(?: before type cast)?) "([^"]+)" and value should be "([^"]+)"$/ do |method, attribute, value|
-  method = method.gsub(/\s+/, '_')
-  @record.send(method, attribute).should == type_cast_value(value)
-end
-
-Then /^"(first|last)" record should have "([^"]+)"$/ do |method, attribute|
-  type_cast_attributes(attribute).each do |(name, value)|
-    @records.send(method).send(name).should == value
-  end
-end
-
-Then /^records should have the following attributes:$/ do |table|
-  table.hashes.each do |hash|
-    record = @records.detect { |r| r.send(hash[:field]) == type_cast_value(hash[:value]) }
-    record.should_not be_nil
-  end
-end
-
-Then /^records should have only the following "([^"]+)" names$/ do |attributes|
-  @records.each do |record|
-    record.attributes.keys.should =~ attributes.split(/\s+/)
-  end
-end
-
-Then /^records should raise "([^"]+)" when call the following "([^"]+)"$/ do |error_class, methods|
-  @records.each do |record|
-    methods.split(/\s+/).each do |method|
-      lambda { record.send(method) }.should raise_error(error_class.constantize)
-    end
-  end
-end
-
-Then /^total records should be "([^"]+)"$/ do |count|
-  @records.to_a.should have(count.to_i).records
-end
-
-Then /^total "([^"]+)" records should be "([^"]+)"$/ do |klass, count|
-  @records = klass.constantize.scoped
-  step %(total records should be "#{count}")
-end
-
-Then /^records "(should|should_not)" have loaded associations:$/ do |should, table|
-  table.hashes.each do |hash|
-    @records.each do |record|
-      record.association(hash[:association].to_sym).send(should, be_loaded)
-    end
-  end
-end
-
-Then /^"([^"]+)" records "(should|should_not)" have loaded associations:$/ do |klass, should, table|
-  table.hashes.each do |hash|
-    records = @records.select { |record| record.class.name == klass }
-    records.each do |record|
-      record.association(hash[:association].to_sym).send(should, be_loaded)
-    end
-  end
-end

data/features/support/env.rb

@@ -1,38 +0,0 @@
-require 'active_record'
-require 'hydra_attribute'
-require 'database_cleaner'
-
-ActiveSupport.on_load(:active_record) do
-  self.default_timezone = :utc
-  unless ActiveRecord::VERSION::STRING.start_with?('3.1.') # @COMPATIBILITY with 3.1.x. active_record 3.1 doesn't have "mass_assignment_sanitizer" method
-    self.mass_assignment_sanitizer = :strict
-  end
-
-  ActiveRecord::Migration.send(:include, HydraAttribute::ActiveRecord::Migration)
-end
-
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-DatabaseCleaner.strategy = :truncation
-
-class Migration < ActiveRecord::Migration
-  def up
-    create_hydra_entity :products do |t|
-      t.string :name
-      t.timestamps
-    end
-  end
-
-  def down
-  end
-end
-
-Migration.new.up
-
-Before do
-  redefine_hydra_entity('Product')
-  DatabaseCleaner.start
-end
-
-After do
-  DatabaseCleaner.clean
-end

data/features/support/world.rb

@@ -1,61 +0,0 @@
-module HydraAttribute
-  module Cucumber
-    module World
-      def type_cast_value(schema)
-        return schema unless schema.is_a?(String)
-        type, value = schema.gsub(/(^\[)|(\]$)/, '').split(':', 2)
-        return schema if schema == type && value.nil?
-
-        case type
-        when 'int'   then type_cast_value(value).to_i
-        when 'float' then type_cast_value(value).to_f
-        when 'bool'  then ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(type_cast_value(value))
-        when 'nil'   then nil
-        when 'date'  then ActiveSupport::TimeZone.new('UTC').parse(type_cast_value(value))
-        when 'sym'   then type_cast_value(value).to_sym
-        when 'array' then value.split(',').map { |v| type_cast_value(v) }
-        when 'eval'  then eval(type_cast_value(value))
-        when 'str'   then type_cast_value(value).to_s
-        else value
-        end
-      end
-
-      def type_cast_attribute(attribute)
-        name, schema = attribute.split('=')
-        [name, type_cast_value(schema)]
-      end
-
-      def type_cast_attributes(attributes)
-        # 'a=[b c] c=a c=[v abc]' => ["a=[b c]", "c=a", "c=[v abc]"]
-        attributes.gsub(/\s+(\w+=)/, '<###>\1').split('<###>').each_with_object({}) do |attribute, hash|
-          name, value = type_cast_attribute(attribute)
-          hash[name]  = value
-        end
-      end
-
-      def type_cast_hash(hash)
-        hash.delete_if{ |_, v| v.blank? }.each do |key, value|
-          hash[key] = type_cast_value(value)
-        end
-      end
-
-      def redefine_hydra_entity(klass)
-        ::ActiveSupport::Dependencies.clear
-
-        Object.send(:remove_const, klass.to_sym) if Object.const_defined?(klass.to_sym)
-
-        ::HydraAttribute::SUPPORTED_BACKEND_TYPES.each do |type|
-          class_name = "Hydra#{type.capitalize}#{klass}".to_sym
-          ::HydraAttribute.send(:remove_const, class_name) if ::HydraAttribute.const_defined?(class_name)
-        end
-
-        Object.const_set(klass.to_sym, Class.new(::ActiveRecord::Base))
-        klass.to_s.constantize.send(:accessible_attributes_configs).values.each(&:clear)
-        klass.to_s.constantize.attr_accessible :name, :hydra_set_id
-        klass.to_s.constantize.send(:include, ::HydraAttribute::ActiveRecord)
-      end
-    end
-  end
-end
-
-World(HydraAttribute::Cucumber::World)

data/lib/hydra_attribute/active_record/association.rb

@@ -1,113 +0,0 @@
-module HydraAttribute
-  module ActiveRecord
-    class Association < ::ActiveRecord::Associations::HasManyAssociation
-
-      def find_model(hydra_attribute_id)
-        load_target unless loaded?
-
-        hydra_set_target.detect do |model|
-          model.hydra_attribute_id == hydra_attribute_id
-        end
-      end
-
-      def find_model_or_build(options = {})
-        find_model(options[:hydra_attribute_id]) || build(options)
-      end
-
-      def build(attributes = {}, options = {}, &block)
-        return if hydra_attribute_ids.exclude?(attributes[:hydra_attribute_id])
-        return if target.any? { |model| model.hydra_attribute_id == attributes[:hydra_attribute_id] }
-
-        super
-      end
-
-      def all_models
-        unless @full_loaded
-          (hydra_attribute_ids - target.map(&:hydra_attribute_id)).each do |hydra_attribute_id|
-            build(hydra_attribute_id: hydra_attribute_id)
-          end
-          @full_loaded = true
-        end
-        hydra_set_target
-      end
-
-      def save
-        changed = false
-        all_models.each do |model|
-          model.entity_id = owner.id
-          model.save
-          changed = true unless model.previous_changes.blank?
-        end
-        changed
-      end
-
-      def lock!(white_list = [])
-        @white_list = Array(white_list)
-        loaded!
-      end
-
-      def hydra_attributes
-        if @white_list
-          @hydra_attributes ||= owner.class.hydra_set_attributes_for_backend_type(owner.hydra_set_id, reflection.backend_type)
-        else
-          owner.class.hydra_set_attributes_for_backend_type(owner.hydra_set_id, reflection.backend_type)
-        end
-      end
-
-      def hydra_attribute_ids
-        if @white_list
-          @hydra_attribute_ids ||= owner.class.hydra_set_attribute_ids_for_backend_type(owner.hydra_set_id, reflection.backend_type) & @white_list
-        else
-          owner.class.hydra_set_attribute_ids_for_backend_type(owner.hydra_set_id, reflection.backend_type)
-        end
-      end
-
-      def hydra_attribute_names
-        if @white_list
-          hydra_attributes.map(&:name)
-        else
-          owner.class.hydra_set_attribute_names_for_backend_type(owner.hydra_set_id, reflection.backend_type)
-        end
-      end
-
-      def hydra_set_target
-        @hydra_set_target ||= target.select do |model|
-          hydra_attribute_ids.include?(model.hydra_attribute_id)
-        end
-      end
-
-      def clear_cache!
-        @hydra_attributes    = nil
-        @hydra_attribute_ids = nil
-        @full_loaded         = nil
-        @hydra_set_target    = nil
-      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(options, _)
-          reflection.klass.new do |record|
-            unless options.has_key?(:value)
-              options[:value] = owner.class.hydra_attribute(options[:hydra_attribute_id]).default_value
-            end
-
-            record.send :write_attribute, 'id', options[:id]
-            record.send :write_attribute, 'entity_id', owner.id
-            record.send :write_attribute, 'hydra_attribute_id', options[:hydra_attribute_id]
-            record.send :write_attribute, 'value', options[:value]
-
-            hydra_set_target << record unless hydra_set_target.include?(record)
-          end
-        end
-    end
-  end
-end

data/lib/hydra_attribute/active_record/reflection.rb

@@ -1,16 +0,0 @@
-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 ||= SUPPORTED_BACKEND_TYPES.find { |type| type == klass.model_name.demodulize.underscore.split('_')[1] }
-      end
-    end
-  end
-end

data/lib/hydra_attribute/association_builder.rb

@@ -1,69 +0,0 @@
-module HydraAttribute
-  class AssociationBuilder
-    attr_reader :klass, :type
-
-    def initialize(klass, type)
-      @klass, @type = klass, type
-    end
-
-    class << self
-      def build(klass, type)
-        new(klass, type).build
-      end
-
-      def model_name(klass, type)
-        "Hydra#{type.to_s.capitalize}#{klass.model_name}"
-      end
-
-      def class_name(klass, type)
-        "::HydraAttribute::#{model_name(klass, type)}"
-      end
-
-      def table_name(klass, type)
-        "hydra_#{type}_#{klass.table_name}"
-      end
-
-      def association_name(type)
-        "hydra_#{type}_values".to_sym
-      end
-    end
-
-    def build
-      create_value_model
-      add_association
-    end
-
-    def create_value_model
-      value_model = ::HydraAttribute.const_set(model_name, Class.new(::ActiveRecord::Base))
-      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.class_eval <<-EOS, __FILE__, __LINE__ + 1
-        def hydra_attribute_name
-          #{klass.model_name}.hydra_attribute(hydra_attribute_id).name
-        end
-      EOS
-    end
-
-    def add_association
-      klass.has_many association_name, class_name: class_name, foreign_key: :entity_id, autosave: false
-    end
-
-    def model_name
-      self.class.model_name(klass, type)
-    end
-
-    def class_name
-      self.class.class_name(klass, type)
-    end
-
-    def table_name
-      self.class.table_name(klass, type)
-    end
-
-    def association_name
-      self.class.association_name(type)
-    end
-  end
-end