active_data 0.3.0 → 1.0.0

data/lib/active_data/model/attributes/collection.rb

@@ -0,0 +1,17 @@
+module ActiveData
+  module Model
+    module Attributes
+      class Collection < Attribute
+        def read
+          @value ||= normalize(read_before_type_cast.map do |value|
+            enumerize(typecast(value))
+          end)
+        end
+
+        def read_before_type_cast
+          @value_before_type_cast ||= Array.wrap(@value_cache).map { |value| defaultize(value) }
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/dictionary.rb

@@ -0,0 +1,26 @@
+module ActiveData
+  module Model
+    module Attributes
+      class Dictionary < Attribute
+        delegate :keys, to: :reflection
+
+        def read
+          @value ||= begin
+            hash = read_before_type_cast
+            hash = hash.stringify_keys.slice(*keys) if keys.present?
+
+            normalize(Hash[hash.map do |key, value|
+              [key, enumerize(typecast(value))]
+            end].with_indifferent_access).with_indifferent_access
+          end
+        end
+
+        def read_before_type_cast
+          @value_before_type_cast ||= Hash[(@value_cache.presence || {}).map do |key, value|
+            [key, defaultize(value)]
+          end].with_indifferent_access
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module ActiveData
+  module Model
+    module Attributes
+      class Localized < Attribute
+        def read
+          @value ||= Hash[read_before_type_cast.map do |locale, value|
+            [locale.to_s, normalize(enumerize(typecast(value)))]
+          end]
+        end
+
+        def read_before_type_cast
+          @value_before_type_cast ||= Hash[(@value_cache.presence || {}).map do |locale, value|
+            [locale.to_s, defaultize(value)]
+          end]
+        end
+
+        def write_locale value, locale
+          pollute do
+            write(read.merge(locale.to_s => value))
+          end
+        end
+
+        def read_locale locale
+          read[owner.class.fallbacks(locale).detect do |fallback|
+            read[fallback.to_s]
+          end.to_s]
+        end
+
+        def read_locale_before_type_cast locale
+          read_before_type_cast[owner.class.fallbacks(locale).detect do |fallback|
+            read_before_type_cast[fallback.to_s]
+          end.to_s]
+        end
+
+        def locale_query locale
+          value = read_locale(locale)
+          !(value.respond_to?(:zero?) ? value.zero? : value.blank?)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reference_many.rb

@@ -0,0 +1,21 @@
+module ActiveData
+  module Model
+    module Attributes
+      class ReferenceMany < ReferenceOne
+        def read_before_type_cast
+          variable_cache(:value_before_type_cast) do
+            Array.wrap(@value_cache)
+          end
+        end
+
+      private
+
+        def type_casted_value
+          variable_cache(:value) do
+            read_before_type_cast.map { |id| typecast(id) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reference_one.rb

@@ -0,0 +1,42 @@
+module ActiveData
+  module Model
+    module Attributes
+      class ReferenceOne < Base
+        def write value
+          pollute do
+            previous = type_casted_value
+            result = write_value value
+            if (!value.nil? && type_casted_value.nil?) || type_casted_value != previous
+              association.reset
+            end
+            result
+          end
+        end
+
+        def read
+          if association.target
+            association.identify
+          else
+            type_casted_value
+          end
+        end
+
+        def read_before_type_cast
+          @value_cache
+        end
+
+      private
+
+        def type_casted_value
+          variable_cache(:value) do
+            typecast(read_before_type_cast)
+          end
+        end
+
+        def association
+          @association ||= owner.association(reflection.association)
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/attribute.rb

@@ -0,0 +1,55 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class Attribute < Base
+          def self.build target, generated_methods, name, *args, &block
+            attribute = super(target, generated_methods, name, *args, &block)
+            generate_methods name, generated_methods
+            attribute
+          end
+
+          def self.generate_methods name, target
+            target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                attribute('#{name}').read
+              end
+
+              def #{name}= value
+                attribute('#{name}').write(value)
+              end
+
+              def #{name}?
+                attribute('#{name}').query
+              end
+
+              def #{name}_before_type_cast
+                attribute('#{name}').read_before_type_cast
+              end
+
+              def #{name}_default
+                attribute('#{name}').default
+              end
+
+              def #{name}_values
+                attribute('#{name}').enum.to_a
+              end
+            RUBY
+          end
+
+          def defaultizer
+            @defaultizer ||= options[:default]
+          end
+
+          def enumerizer
+            @enumerizer ||= options[:enum] || options[:in]
+          end
+
+          def normalizers
+            @normalizers ||= Array.wrap(options[:normalize] || options[:normalizer] || options[:normalizers])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/base.rb

@@ -0,0 +1,62 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class Base
+          attr_reader :name, :options
+          class << self
+            def build target, generated_methods, name, *args, &block
+              options = args.extract_options!
+              options.merge!(type: args.first) if args.first
+              options.merge!(default: block) if block
+              new(name, options)
+            end
+
+            def generate_methods name, target
+            end
+
+            def attribute_class
+              @attribute_class ||= "ActiveData::Model::Attributes::#{name.demodulize}".constantize
+            end
+          end
+
+          def initialize name, options = {}
+            @name = name.to_s
+            @options = options
+          end
+
+          def build_attribute owner, raw_value = nil
+            attribute = self.class.attribute_class.new(name, owner)
+            attribute.write_value(raw_value) if raw_value
+            attribute
+          end
+
+          def type
+            @type ||= case options[:type]
+            when Proc
+              options[:type].call
+            when Class
+              options[:type]
+            when nil
+              raise "Type is not specified for `#{name}`"
+            else
+              options[:type].to_s.camelize.constantize
+            end
+          end
+
+          def typecaster
+            @typecaster ||= ActiveData.typecaster(type.ancestors.grep(Class))
+          end
+
+          def readonly
+            @readonly ||= options[:readonly]
+          end
+
+          def inspect_reflection
+            "#{name}: #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/collection.rb

@@ -0,0 +1,10 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class Collection < Attribute
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/dictionary.rb

@@ -0,0 +1,13 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class Dictionary < Attribute
+          def keys
+            @keys ||= Array.wrap(options[:keys]).map(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/localized.rb

@@ -0,0 +1,43 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class Localized < Attribute
+          def self.build target, generated_methods, name, *args, &block
+            attribute = super(target, generated_methods, name, *args, &block)
+            generate_methods name, generated_methods
+            attribute
+          end
+
+          def self.generate_methods name, target
+            target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}_translations
+                attribute('#{name}').read
+              end
+
+              def #{name}_translations= value
+                attribute('#{name}').write(value)
+              end
+
+              def #{name}
+                attribute('#{name}').read_locale(self.class.locale)
+              end
+
+              def #{name}= value
+                attribute('#{name}').write_locale(value, self.class.locale)
+              end
+
+              def #{name}?
+                attribute('#{name}').locale_query(self.class.locale)
+              end
+
+              def #{name}_before_type_cast
+                attribute('#{name}').read_locale_before_type_cast(self.class.locale)
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/reference_many.rb

@@ -0,0 +1,10 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class ReferenceMany < ReferenceOne
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/reference_one.rb

@@ -0,0 +1,58 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class ReferenceOne < Base
+          TYPES = {
+            integer: Integer,
+            float: Float,
+            decimal: BigDecimal,
+            datetime: Time,
+            timestamp: Time,
+            time: Time,
+            date: Date,
+            text: String,
+            string: String,
+            binary: String,
+            boolean: Boolean
+          }
+
+          def self.build target, generated_methods, name, *args, &block
+            options = args.extract_options!
+            generate_methods name, generated_methods
+            type_proc = -> {
+              reflection = target.reflect_on_association(options[:association])
+              column = reflection.klass.columns_hash[reflection.primary_key.to_s]
+              TYPES[column.type]
+            }
+            new(name, options.reverse_merge(type: type_proc))
+          end
+
+          def self.generate_methods name, target
+            target.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                attribute('#{name}').read
+              end
+
+              def #{name}= value
+                attribute('#{name}').write(value)
+              end
+
+              def #{name}?
+                attribute('#{name}').query
+              end
+
+              def #{name}_before_type_cast
+                attribute('#{name}').read_before_type_cast
+              end
+            RUBY
+          end
+
+          def association
+            @association ||= options[:association].to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_data/model/attributes/reflections/represents.rb

@@ -0,0 +1,55 @@
+module ActiveData
+  module Model
+    module Attributes
+      module Reflections
+        class Represents < Attribute
+          def self.build target, generated_methods, name, *args, &block
+            options = args.extract_options!
+
+            reference = target.reflect_on_association(options[:of]) if target.respond_to?(:reflect_on_association)
+            reference ||= target.reflect_on_attribute(options[:of]) if target.respond_to?(:reflect_on_attribute)
+            if reference
+              options[:of] = reference.name
+              target.validates_nested options[:of]
+            end
+
+            super(target, generated_methods, name, *args, options, &block)
+          end
+
+          def initialize name, options
+            super
+            raise ArgumentError, "Undefined reference for `#{name}`" if reference.blank?
+          end
+
+          def type
+            Object
+          end
+
+          def reference
+            @reference ||= options[:of].to_s
+          end
+
+          def column
+            @column ||= options[:column].presence.try(:to_s) || name
+          end
+
+          def reader
+            @reader ||= options[:reader].presence.try(:to_s) || column
+          end
+
+          def reader_before_type_cast
+            @reader_before_type_cast ||= "#{reader}_before_type_cast"
+          end
+
+          def writer
+            @writer ||= "#{options[:writer].presence || column}="
+          end
+
+          def inspect_reflection
+            "#{name}: (represents)"
+          end
+        end
+      end
+    end
+  end
+end