active_data 0.3.0 → 1.0.0

data/lib/active_data/model/extensions/date.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module Date
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            value.to_date rescue nil
-          end
-        end
-      end
-    end
-  end
-end
-
-Date.send :include, ActiveData::Model::Extensions::Date

data/lib/active_data/model/extensions/date_time.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module DateTime
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            value.to_datetime rescue nil
-          end
-        end
-      end
-    end
-  end
-end
-
-DateTime.send :include, ActiveData::Model::Extensions::DateTime

data/lib/active_data/model/extensions/float.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module Float
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            Float(value) rescue nil if value
-          end
-        end
-      end
-    end
-  end
-end
-
-Float.send :include, ActiveData::Model::Extensions::Float

data/lib/active_data/model/extensions/hash.rb

@@ -1,22 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module Hash
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            case value
-            when ::Hash then
-              value
-            else
-              nil
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-Hash.send :include, ActiveData::Model::Extensions::Hash

data/lib/active_data/model/extensions/integer.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module Integer
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            Float(value).to_i rescue nil if value
-          end
-        end
-      end
-    end
-  end
-end
-
-Integer.send :include, ActiveData::Model::Extensions::Integer

data/lib/active_data/model/extensions/localized.rb

@@ -1,22 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module Localized
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            case value
-            when ::Hash then
-              value.stringify_keys
-            else
-              nil
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-Localized.send :include, ActiveData::Model::Extensions::Localized

data/lib/active_data/model/extensions/object.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module Object
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            value
-          end
-        end
-      end
-    end
-  end
-end
-
-Object.send :include, ActiveData::Model::Extensions::Object

data/lib/active_data/model/extensions/string.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module String
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            value.to_s if value.present?
-          end
-        end
-      end
-    end
-  end
-end
-
-String.send :include, ActiveData::Model::Extensions::String

data/lib/active_data/model/extensions/time.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Model
-    module Extensions
-      module Time
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def active_data_type_cast value
-            value.to_time rescue nil
-          end
-        end
-      end
-    end
-  end
-end
-
-Time.send :include, ActiveData::Model::Extensions::Time

data/lib/active_data/model/localizable.rb

@@ -1,31 +0,0 @@
-module ActiveData
-  module Model
-    module Localizable
-      extend ActiveSupport::Concern
-
-      included do
-      end
-
-      module ClassMethods
-        def fallbacks locale
-          ::I18n.respond_to?(:fallbacks) ? ::I18n.fallbacks[locale] : [locale]
-        end
-
-        def locale
-          I18n.locale
-        end
-      end
-
-      def read_localized_attribute name, locale = self.class.locale
-        translations = read_attribute(name.to_s)
-        translations[self.class.fallbacks(locale).detect { |fallback| translations[fallback.to_s] }.to_s]
-      end
-      alias_method :read_localized_attribute_before_type_cast, :read_localized_attribute
-
-      def write_localized_attribute name, value, locale = self.class.locale
-        translations = read_attribute(name.to_s)
-        write_attribute(name, translations.merge(locale.to_s => value))
-      end
-    end
-  end
-end

data/lib/active_data/model/nested_attributes.rb

@@ -1,58 +0,0 @@
-module ActiveData
-  module Model
-    module NestedAttributes
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-
-        def nested_attributes? association_name
-          method_defined?(:"#{association_name}_attributes=")
-        end
-
-        def accepts_nested_attributes_for *attr_names
-          attr_names.each do |association_name|
-            reflection = reflect_on_association association_name
-            type = (reflection.collection? ? :collection : :one_to_one)
-
-            class_eval <<-EOS, __FILE__, __LINE__ + 1
-              if method_defined?(:#{association_name}_attributes=)
-                remove_method(:#{association_name}_attributes=)
-              end
-              def #{association_name}_attributes=(attributes)
-                assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
-              end
-            EOS
-          end
-        end
-
-      end
-
-      def assign_nested_attributes_for_collection_association(association_name, attributes_collection, assignment_opts = {})
-        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
-          raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
-        end
-
-        if attributes_collection.is_a? Hash
-          keys = attributes_collection.keys
-          attributes_collection = if keys.include?('id') || keys.include?(:id)
-            Array.wrap(attributes_collection)
-          else
-            attributes_collection.values
-          end
-        end
-
-        reflection = self.class.reflect_on_association association_name
-
-        send "#{association_name}=", attributes_collection
-      end
-
-      def assign_nested_attributes_for_one_to_one_association(association_name, attributes, assignment_opts = {})
-        unless attributes.is_a?(Hash)
-          raise ArgumentError, "Hash expected, got #{attributes.class.name} (#{attributes.inspect})"
-        end
-
-        send "#{association_name}=", attributes
-      end
-    end
-  end
-end

data/lib/active_data/model/parameterizable.rb

@@ -1,29 +0,0 @@
-module ActiveData
-  module Model
-    module Parameterizable
-      extend ActiveSupport::Concern
-
-      def to_params options = nil
-        hash = serializable_hash options
-
-        self.class.association_names.each do |association_name|
-          if self.class.nested_attributes? association_name
-            records = send(association_name)
-            hash["#{association_name}_attributes"] = if records.is_a?(Enumerable)
-              attributes = {}
-              records.each_with_index do |a, i|
-                key = a.has_attribute?(:id) && a.id? ? a.id : i
-                attributes[key.to_s] = a.serializable_hash
-              end
-              attributes
-            else
-              records.serializable_hash
-            end
-          end
-        end
-
-        hash
-      end
-    end
-  end
-end

data/lib/active_data/validations.rb

@@ -1,7 +0,0 @@
-require 'active_data/validations/associated'
-
-module ActiveData
-  module Validations
-    extend ActiveSupport::Concern
-  end
-end

data/lib/active_data/validations/associated.rb

@@ -1,17 +0,0 @@
-module ActiveData
-  module Validations
-    class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
-      def validate_each(record, attribute, value)
-        if Array.wrap(value).reject { |r| r.respond_to?(:valid?) && r.valid?(record.validation_context) }.any?
-          record.errors.add(attribute, :invalid, options.merge(:value => value))
-        end
-      end
-    end
-
-    module ClassMethods
-      def validates_associated(*attr_names)
-        validates_with AssociatedValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end

data/spec/lib/active_data/model/attributable_spec.rb

@@ -1,191 +0,0 @@
-# encoding: UTF-8
-require 'spec_helper'
-
-describe ActiveData::Model::Attributable do
-
-  let(:klass) do
-    Class.new do
-      include ActiveData::Model::Attributable
-      attr_reader :name
-
-      attribute :hello
-      attribute :string, type: String, default_blank: true, default: ->(record){ record.name }
-      attribute :count, type: Integer, default: 10
-      attribute(:calc, type: Integer) { 2 + 3 }
-      attribute :enum, type: Integer, in: [1, 2, 3]
-      attribute :foo, type: Boolean, default: false
-
-      def initialize name = nil
-        @attributes = self.class.initialize_attributes
-        @name = name
-      end
-    end
-  end
-
-  context do
-    subject { klass.new('world') }
-    specify { klass.enum_values.should == [1, 2, 3] }
-    its(:attributes) { should ==  { hello: nil, count: 10, calc: 5, enum: nil, string: 'world', foo: false }  }
-    its(:present_attributes) { should ==  { count: 10, calc: 5, string: 'world', foo: false }  }
-    its(:name) { should == 'world' }
-    its(:hello) { should be_nil }
-    its(:count) { should == 10 }
-    its(:calc) { should == 5 }
-    specify { expect { subject.hello = 'worlds' } .to change { subject.hello } .from(nil).to('worlds') }
-    specify { expect { subject.count = 20 } .to change { subject.count } .from(10).to(20) }
-    specify { expect { subject.calc = 15 } .to change { subject.calc } .from(5).to(15) }
-  end
-
-  context 'calculating default values' do
-    let(:klass) do
-      Class.new do
-        include ActiveData::Model::Attributable
-
-        attribute(:rand, type: String) { SecureRandom.uuid }
-
-        def initialize
-          @attributes = self.class.initialize_attributes
-        end
-      end
-    end
-
-    subject { klass.new }
-    specify { subject.rand.should == subject.rand }
-    specify { subject.rand.should_not == klass.new.rand }
-  end
-
-  context 'default_blank' do
-    let(:klass) do
-      Class.new do
-        include ActiveData::Model::Attributable
-
-        attribute :string1, type: String, default_blank: true, default: 'default'
-        attribute :string2, type: String, default: 'default'
-
-        def initialize attributes = {}
-          @attributes = self.class.initialize_attributes
-          self.attributes = attributes
-        end
-      end
-    end
-
-    specify { klass.new.string1.should == 'default' }
-    specify { klass.new.string2.should == 'default' }
-    specify { klass.new(string1: '').string1.should == 'default' }
-    specify { klass.new(string2: '').string2.should == '' }
-    specify { klass.new(string1: 'hello').string1.should == 'hello' }
-    specify { klass.new(string2: 'hello').string2.should == 'hello' }
-  end
-
-  context 'default_blank with boolean' do
-    let(:klass) do
-      Class.new do
-        include ActiveData::Model::Attributable
-
-        attribute :boolean1, type: Boolean, default_blank: true, default: true
-        attribute :boolean2, type: Boolean, default: true
-        attribute :boolean3, type: Boolean, default_blank: true, default: false
-        attribute :boolean4, type: Boolean, default: false
-
-        def initialize attributes = {}
-          @attributes = self.class.initialize_attributes
-          self.attributes = attributes
-        end
-      end
-    end
-
-    specify { klass.new.boolean1.should == true }
-    specify { klass.new.boolean2.should == true }
-    specify { klass.new.boolean3.should == false }
-    specify { klass.new.boolean4.should == false }
-    specify { klass.new(boolean1: '').boolean1.should == true }
-    specify { klass.new(boolean2: '').boolean2.should == true }
-    specify { klass.new(boolean3: '').boolean3.should == false }
-    specify { klass.new(boolean4: '').boolean4.should == false }
-    specify { klass.new(boolean1: false).boolean1.should == false }
-    specify { klass.new(boolean2: false).boolean2.should == false }
-    specify { klass.new(boolean3: false).boolean3.should == false }
-    specify { klass.new(boolean4: false).boolean4.should == false }
-    specify { klass.new(boolean1: true).boolean1.should == true }
-    specify { klass.new(boolean2: true).boolean2.should == true }
-    specify { klass.new(boolean3: true).boolean3.should == true }
-    specify { klass.new(boolean4: true).boolean4.should == true }
-  end
-
-  context 'attribute caching' do
-    subject { klass.new('world') }
-
-    context do
-      before do
-        subject.send(:attributes_cache).should_not_receive(:[])
-      end
-
-      specify { subject.hello }
-    end
-
-    context do
-      before do
-        subject.hello
-        subject.send(:attributes_cache).should_receive(:[]).with(:hello).once
-      end
-
-      specify { subject.hello }
-    end
-
-    context 'attribute cache reset' do
-      before do
-        subject.hello = 'blabla'
-        subject.hello
-        subject.hello = 'newnewnew'
-      end
-
-      specify { subject.hello.should == 'newnewnew' }
-    end
-  end
-
-  context 'inheritance' do
-    let!(:ancestor) do
-      Class.new do
-        include ActiveData::Model::Attributable
-        attribute :foo
-      end
-    end
-
-    let!(:descendant1) do
-      Class.new ancestor do
-        attribute :bar
-      end
-    end
-
-    let!(:descendant2) do
-      Class.new ancestor do
-        attribute :baz
-        attribute :moo
-      end
-    end
-
-    specify { ancestor._attributes.keys.should == [:foo] }
-    specify { ancestor.instance_methods.should include :foo, :foo= }
-    specify { ancestor.instance_methods.should_not include :bar, :bar=, :baz, :baz= }
-    specify { descendant1._attributes.keys.should == [:foo, :bar] }
-    specify { descendant1.instance_methods.should include :foo, :foo=, :bar, :bar= }
-    specify { descendant1.instance_methods.should_not include :baz, :baz= }
-    specify { descendant2._attributes.keys.should == [:foo, :baz, :moo] }
-    specify { descendant2.instance_methods.should include :foo, :foo=, :baz, :baz=, :moo, :moo= }
-    specify { descendant2.instance_methods.should_not include :bar, :bar= }
-  end
-
-  context '#write_attributes' do
-    subject { klass.new('world') }
-
-    specify { expect { subject.write_attributes(strange: 'value') }.to raise_error NoMethodError }
-
-    context do
-      before { subject.write_attributes('hello' => 'blabla', count: 20) }
-      specify do
-        subject.attributes.should == { hello: 'blabla', count: 20, calc: 5, enum: nil, string: 'world', foo: false }
-      end
-    end
-  end
-
-end