ar_doc_store 1.0.5 → 2.0.0

data/lib/ar_doc_store/attribute_types/boolean_attribute.rb

@@ -1,25 +0,0 @@
-module ArDocStore
-  module AttributeTypes
-
-    class BooleanAttribute < BaseAttribute
-      def build
-        key = attribute.to_sym
-        model.class_eval do
-          store_accessor json_column, key
-          define_method "#{key}?".to_sym, -> { public_send(key) == true }
-          define_method "#{key}=".to_sym, -> (value) {
-            res = ArDocStore.convert_boolean(value)
-            write_store_attribute(json_column, key, res)
-          }
-          add_ransacker(key, 'bool')
-        end
-      end
-
-      def type
-        :boolean
-      end
-
-    end
-
-  end
-end

data/lib/ar_doc_store/attribute_types/datetime_attribute.rb

@@ -1,17 +0,0 @@
-module ArDocStore
-  module AttributeTypes
-    class DatetimeAttribute < BaseAttribute
-      def type
-        :datetime
-      end
-
-      def load
-        :to_time
-      end
-
-      def dump
-        :to_s
-      end
-    end
-  end
-end

data/lib/ar_doc_store/attribute_types/embeds_many_attribute.rb

@@ -1,165 +0,0 @@
-module ArDocStore
-
-  class EmbeddedCollection < Array
-    attr_accessor :parent
-  end
-
-  module AttributeTypes
-
-    class EmbedsManyAttribute < BaseAttribute
-
-      def build
-        assn_name = attribute.to_sym
-        class_name = options[:class_name] || attribute.to_s.classify
-        model.store_accessor model.json_column, assn_name
-        create_reader_for assn_name, class_name
-        create_writer_for assn_name, class_name
-        create_build_method_for assn_name, class_name
-        create_ensure_method_for assn_name
-        create_embeds_many_attributes_method(class_name, assn_name)
-        create_embeds_many_validation(assn_name)
-      end
-
-      private
-
-      def add_method(method, block)
-        model.class_eval do
-          define_method method, block
-        end
-      end
-
-      def create_reader_for(assn_name, class_name)
-        add_method assn_name.to_sym, -> {
-          ivar = "@#{assn_name}"
-          instance_variable_get(ivar) || begin
-            my_class_name = class_name.constantize
-            items = read_store_attribute(json_column, assn_name)
-            if items.is_a?(Array) || items.is_a?(ArDocStore::EmbeddedCollection)
-              items = ArDocStore::EmbeddedCollection.new items.map { |item| item.is_a?(my_class_name) ? item : my_class_name.build(item) }
-            else
-              items ||= ArDocStore::EmbeddedCollection.new
-            end
-            instance_variable_set ivar, (items)
-            items.parent = self
-            items.map {|item| item.parent = self }
-            items
-          end
-        }
-      end
-      def create_writer_for(assn_name, class_name)
-        add_method "#{assn_name}=".to_sym, -> (values) {
-          if values && values.respond_to?(:map)
-            items = ArDocStore::EmbeddedCollection.new values.map { |item|
-              my_class_name = class_name.constantize
-              item = item.is_a?(my_class_name) ? item : my_class_name.new(item)
-              item.id
-              item.parent = self
-              item
-            }
-          else
-            items = []
-          end
-          items.parent = self
-          instance_variable_set "@#{assn_name}", write_store_attribute(json_column, assn_name, items)
-        }
-      end
-
-      def create_build_method_for(assn_name, class_name)
-        add_method "build_#{assn_name.to_s.singularize}", -> (attributes=nil) {
-          assns = self.public_send assn_name
-          item = class_name.constantize.build attributes
-          item.parent = self
-          assns << item
-          public_send "#{assn_name}=", assns
-          item
-        }
-      end
-
-      def create_ensure_method_for(assn_name)
-        method = -> { public_send "build_#{assn_name.to_s.singularize}" if self.public_send(assn_name).blank? }
-        add_method "ensure_#{assn_name.to_s.singularize}", method
-        add_method "ensure_#{assn_name}", method
-      end
-
-      def create_embeds_many_attributes_method(class_name, assn_name)
-        add_method "#{assn_name}_attributes=", -> (values) {
-          return if values.blank?
-          # if it's a single item then wrap it in an array but how to tell?
-
-          if values.respond_to?(:each)
-            if values.respond_to?(:values)
-              values = values.values
-            end
-          else
-            values = [values]
-          end
-          models = public_send assn_name
-          public_send "#{assn_name}=", AssignEmbedsManyAttributes.new(self, class_name, assn_name, models, values).models
-        }
-      end
-
-      def create_embeds_many_validation(assn_name)
-        model.class_eval do
-          validate_method = "validate_embedded_record_for_#{assn_name}".to_sym
-          define_method validate_method, -> { validate_embeds_many assn_name }
-          validate validate_method
-        end
-      end
-
-
-    end
-
-    class AssignEmbedsManyAttributes
-      attr_reader :models, :assn_name, :parent, :class_name
-      def initialize(parent, class_name, assn_name, models, values)
-        @parent, @class_name, @assn_name, @models, @values = parent, class_name, assn_name, models, values
-        values.each { |value|
-          value = value.symbolize_keys
-          if value.key?(:id)
-            process_existing_model(value)
-          else
-            next if values.all?(&:nil?)
-            add(value)
-          end
-        }
-      end
-
-      private
-
-      attr_writer :models, :values
-      attr_reader :values, :assn_name
-
-      def process_existing_model(value)
-        return false unless value.key?(:id)
-        model = find_model_by_value(value)
-        model && destroy_or_update(model, value) or add(value)
-      end
-
-      def destroy_or_update(model, value)
-        destroy(model, value) or update_attributes(model, value)
-      end
-
-      def add(value)
-        models << class_name.constantize.new(value)
-      end
-
-      def destroy(model, value)
-        wants_to_die?(value) && models.delete(model)
-      end
-
-      def update_attributes(model, value)
-        model.attributes = value
-      end
-
-      def wants_to_die?(value)
-        value.key?(:_destroy) && ArDocStore.convert_boolean(value[:_destroy])
-      end
-
-      def find_model_by_value(value)
-        models.detect { |item| item.id == value[:id] }
-      end
-    end
-
-
-  end
-end

data/lib/ar_doc_store/attribute_types/string_attribute.rb

@@ -1,17 +0,0 @@
-module ArDocStore
-  module AttributeTypes
-    
-    class StringAttribute < BaseAttribute
-      def conversion
-        :to_s
-      end
-
-      def predicate
-        'text'
-      end
-
-    end
-
-  end
-end
-

data/lib/ar_doc_store/attribute_types/uuid_attribute.rb

@@ -1,30 +0,0 @@
-require 'securerandom'
-
-module ArDocStore
-  module AttributeTypes
-
-    class UuidAttribute < BaseAttribute
-      def build
-        key = attribute.to_sym
-        model.class_eval do
-          store_accessor json_column, key
-          define_method key, -> {
-            value = read_store_attribute(json_column, key)
-            unless value
-              value = SecureRandom.uuid
-              write_store_attribute json_column, key, value
-            end
-            value
-          }
-          define_method "#{key}=".to_sym, -> (value) {
-            write_store_attribute(json_column, key, value)
-          }
-          add_ransacker(key, 'text')
-        end
-      end
-
-
-    end
-
-  end
-end

data/test/attribute_types/datetime_attribute_test.rb

@@ -1,35 +0,0 @@
-require_relative './../test_helper'
-
-class DatetimeAttributeTest < MiniTest::Test
-
-  def test_attribute_on_model_init
-    approved_at = Time.new(1984, 3, 6)
-    po = PurchaseOrder.new approved_at: approved_at
-    assert approved_at == po.approved_at
-  end
-
-  def test_attribute_on_existing_model
-    approved_at = Time.new(1984, 3, 6)
-    po = PurchaseOrder.new
-    po.approved_at = approved_at
-    assert approved_at == po.approved_at
-    assert po.approved_at_changed?
-  end
-
-  def test_question_mark_method
-    approved_at = Time.new(1984, 3, 6)
-    po = PurchaseOrder.new approved_at: approved_at
-    assert_equal true, po.approved_at?
-  end
-
-  def test_conversion
-    approved_at = Time.new(1984, 3, 6)
-    po = PurchaseOrder.new approved_at: approved_at.to_s
-    assert_kind_of Time, po.approved_at
-  end
-
-  def test_no_op
-    po = PurchaseOrder.new
-    assert_nil po.approved_at
-  end
-end

data/test/attribute_types/integer_attribute_test.rb

@@ -1,33 +0,0 @@
-require_relative './../test_helper'
-
-class IntegerAttributeTest < MiniTest::Test
-  
-  def test_string_attribute_on_model_init
-    b = Building.new stories: 5
-    assert_equal 5, b.stories
-  end
-
-  def test_string_attribute_on_existing_model
-    b = Building.new
-    b.stories = 5
-    assert_equal 5, b.stories
-    assert b.stories_changed?
-  end
-  
-  def test_question_mark_method
-    b = Building.new stories: 5
-    assert_equal true, b.stories?
-  end
-  
-  def test_type_conversion_on_init
-    b = Building.new stories: '5'
-    assert_equal 5, b.stories
-  end
-  
-  def test_type_conversion_on_existing
-    b = Building.new 
-    b.stories = '5'
-    assert_equal 5, b.stories
-  end
-  
-end

data/test/originals/dirty_attributes_test.rb

@@ -1,35 +0,0 @@
-require_relative './../test_helper'
-
-class DirtyAttributeTest < MiniTest::Test
-
-  def test_on_model
-    b = Building.new name: 'Foo!'
-    # This used to work but started failing. AR behavior is to make it true.
-    # send :clear_changes_information not working yields undefined method.
-    # assert !b.name_changed?
-    b.name = 'Bar.'
-    assert_equal 'Bar.', b.name
-    assert b.name_changed?
-    # Somehow this worked at one point, but should only work when the record is loaded via instantiate:
-    # assert_equal 'Foo!', b.name_was
-  end
-
-  #This test fails here but passes elsewhere.
-  def test_on_embedded_model
-    b = Building.new
-    r = b.build_restroom restroom_type: 'dirty'
-    assert !r.restroom_type_changed?
-    r.restroom_type = 'nasty'
-    assert r.restroom_type_changed?
-    assert_equal 'dirty', r.restroom_type_was
-    assert_equal 'nasty', r.restroom_type
-  end
-
-  def test_id_does_not_change_on_init
-    b = Building.new
-    r = b.build_restroom
-    assert !r.id_changed?
-    assert !r.changes.keys.include?('id')
-  end
-
-end

data/test/originals/embedded_model_attribute_test.rb

@@ -1,23 +0,0 @@
-require_relative './../test_helper'
-
-class EmbeddedModelAttributeTest < MiniTest::Test
-  
-  def test_can_set_attribute_on_embedded_model_init
-    b = Route.new route_surface: 'test'
-    assert_equal 'test', b.route_surface
-  end
-  
-  def test_can_set_attribute_on_existing_embedded_model
-    b = Route.new
-    b.route_surface = 'test'
-    assert_equal 'test', b.route_surface
-  end
-  
-  def test_can_set_enumeration_created_with_enumerates
-    door = Door.new
-    door.door_type = %w{sliding push}
-    assert_equal %w{sliding push}, door.door_type
-  end
-
-end
-

data/test/originals/embedding_test.rb

@@ -1,82 +0,0 @@
-require_relative './../test_helper'
-
-class EmbeddingTest < MiniTest::Test
-  
-  def test_can_build_embedded_model
-    restroom = Restroom.new
-    door = restroom.build_door
-    assert door.is_a?(Door)
-  end
-  
-  def test_ensure_door_returns_existing_door
-    restroom = Restroom.new
-    restroom.build_door
-    restroom.door.open_handle = %w{knob}
-    restroom.ensure_door
-    assert_equal %w{knob}, restroom.door.open_handle
-  end
-  
-  def test_attributes_equals_sets_attributes
-    restroom = Restroom.new door_attributes: { clear_distance: 5, opening_force: 13, clear_space: 43 }
-    assert_equal 5, restroom.door.clear_distance
-    restroom.door_attributes = { _destroy: '1' }
-    assert_nil restroom.door.clear_distance
-  end
-  
-  def test_attributes_equals_sets_partial_attributes
-    restroom = Restroom.new door_attributes: { clear_distance: 5, opening_force: 13, clear_space: 43 }
-    restroom.door_attributes = { clear_distance: 7 }
-    assert_equal 7, restroom.door.clear_distance
-    assert_equal 13, restroom.door.opening_force
-  end
-  
-  def test_embeds_many_attributes_equals_sets_partial_attributes
-    building = Building.new
-    building.restrooms << Restroom.new(door_attributes: { clear_distance: 5, opening_force: 13, clear_space: 43 })
-    building.restrooms << Restroom.new(door_attributes: { clear_distance: 6, opening_force: 14, clear_space: 44 })
-    building.restrooms << Restroom.new(door_attributes: { clear_distance: 7, opening_force: 15, clear_space: 45 })
-    restrooms_attributes = {
-      a1: { id: building.restrooms[0].id, door_attributes: { clear_distance: 10 } },
-      a2: { id: building.restrooms[1].id, _destroy: true },
-      a3: { id: building.restrooms[2].id, door_attributes: { clear_distance: 1 } }
-    }
-    building.restrooms_attributes = restrooms_attributes
-    assert_equal 2, building.restrooms.size
-    assert_equal 10, building.restrooms.first.door.clear_distance
-    assert_equal 15, building.restrooms.last.door.opening_force
-    assert_equal 1, building.restrooms.last.door.clear_distance
-    assert_nil building.restrooms.detect {|restroom| restroom.id == restrooms_attributes[:a2][:id] }
-  end
-  
-  def test_attributes_method_embeds_many_does_not_clobber_existing_embeds_that_are_not_in_array
-    building = Building.new
-    building.restrooms << Restroom.new(door_attributes: { clear_distance: 5, opening_force: 13, clear_space: 43 })
-    building.restrooms << Restroom.new(door_attributes: { clear_distance: 6, opening_force: 14, clear_space: 44 })
-    building.restrooms << Restroom.new(door_attributes: { clear_distance: 7, opening_force: 15, clear_space: 45 })
-    restrooms_attributes = {
-      a1: { id: building.restrooms[0].id, door_attributes: { clear_distance: 10 } },
-    }
-    building.restrooms_attributes = restrooms_attributes
-    assert_equal 3, building.restrooms.size
-    assert_equal 10, building.restrooms.first.door.clear_distance
-    assert_equal 15, building.restrooms.last.door.opening_force
-  end
-  
-  def test_attribute_validity_of_embedded_model_from_model
-    b = Building.new
-    r = Restroom.new
-    b.restrooms << r
-    assert !b.valid?
-  end
-
-  def test_model_with_no_attributes
-    item = ThingWithEmptyModel.new
-    item.build_empty_model
-    assert item.empty_model.is_a?(EmptyModel)
-  end
-
-  def test_model_subclassing
-    assert_equal EmbeddableB.virtual_attributes.size, 3
-  end
-
-end