duck_record 0.0.16 → 0.0.18

data/lib/duck_record/attribute_assignment.rb

@@ -7,23 +7,23 @@ module DuckRecord
     include ActiveModel::ForbiddenAttributesProtection
 
     # Alias for ActiveModel::AttributeAssignment#assign_attributes. See ActiveModel::AttributeAssignment.
-    def attributes=(attributes, force_write_readonly: false)
-      assign_attributes(attributes, force_write_readonly: force_write_readonly)
+    def attributes=(attributes)
+      assign_attributes(attributes)
     end
 
-    def assign_attributes(new_attributes, force_write_readonly: false)
+    def assign_attributes(new_attributes)
       unless new_attributes.respond_to?(:stringify_keys)
         raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
       end
       return if new_attributes.nil? || new_attributes.empty?
 
       attributes = new_attributes.stringify_keys
-      _assign_attributes(sanitize_for_mass_assignment(attributes), force_write_readonly: force_write_readonly)
+      _assign_attributes(sanitize_for_mass_assignment(attributes))
     end
 
     private
 
-      def _assign_attributes(attributes, force_write_readonly: false)
+      def _assign_attributes(attributes)
         multi_parameter_attributes  = {}
         nested_parameter_attributes = {}
 
@@ -36,21 +36,21 @@ module DuckRecord
         end
 
         attributes.each do |k, v|
-          _assign_attribute(k, v, force_write_readonly: force_write_readonly)
+          _assign_attribute(k, v)
         end
 
         unless nested_parameter_attributes.empty?
-          assign_nested_parameter_attributes(nested_parameter_attributes, force_write_readonly: force_write_readonly)
+          assign_nested_parameter_attributes(nested_parameter_attributes)
         end
 
         unless multi_parameter_attributes.empty?
-          assign_multiparameter_attributes(multi_parameter_attributes, force_write_readonly: force_write_readonly)
+          assign_multiparameter_attributes(multi_parameter_attributes)
         end
       end
 
       # Assign any deferred nested attributes after the base attributes have been set.
-      def assign_nested_parameter_attributes(pairs, force_write_readonly: false)
-        pairs.each { |k, v| _assign_attribute(k, v, force_write_readonly: force_write_readonly) }
+      def assign_nested_parameter_attributes(pairs)
+        pairs.each { |k, v| _assign_attribute(k, v) }
       end
 
       # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
@@ -59,14 +59,13 @@ module DuckRecord
       # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
       # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
       # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
-      def assign_multiparameter_attributes(pairs, force_write_readonly: false)
+      def assign_multiparameter_attributes(pairs)
         execute_callstack_for_multiparameter_attributes(
-          extract_callstack_for_multiparameter_attributes(pairs),
-          force_write_readonly: force_write_readonly
+          extract_callstack_for_multiparameter_attributes(pairs)
         )
       end
 
-      def execute_callstack_for_multiparameter_attributes(callstack, force_write_readonly: false)
+      def execute_callstack_for_multiparameter_attributes(callstack)
         errors = []
         callstack.each do |name, values_with_empty_parameters|
           begin
@@ -75,7 +74,7 @@ module DuckRecord
             else
               values = values_with_empty_parameters
             end
-            send("#{name}=", values, force_write_readonly: force_write_readonly)
+            send("#{name}=", values)
           rescue => ex
             errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
           end
@@ -108,9 +107,9 @@ module DuckRecord
         multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
       end
 
-      def _assign_attribute(k, v, force_write_readonly: false)
+      def _assign_attribute(k, v)
         if respond_to?("#{k}=")
-          public_send("#{k}=", v, force_write_readonly: force_write_readonly)
+          public_send("#{k}=", v)
         else
           raise UnknownAttributeError.new(self, k)
         end

data/lib/duck_record/attribute_methods/write.rb

@@ -15,9 +15,9 @@ module DuckRecord
             DuckRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
             generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-            def __temp__#{safe_name}=(value, force_write_readonly: false)
+            def __temp__#{safe_name}=(value)
               name = ::DuckRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-              write_attribute(name, value, force_write_readonly: force_write_readonly)
+              write_attribute(name, value)
             end
             alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
             undef_method :__temp__#{safe_name}=
@@ -28,32 +28,35 @@ module DuckRecord
       # Updates the attribute identified by <tt>attr_name</tt> with the
       # specified +value+. Empty strings for Integer and Float columns are
       # turned into +nil+.
-      def write_attribute(attr_name, value, force_write_readonly: false)
-        name = if self.class.attribute_alias?(attr_name)
-                 self.class.attribute_alias(attr_name).to_s
-               else
-                 attr_name.to_s
-               end
+      def write_attribute(attr_name, value)
+        name =
+          if self.class.attribute_alias?(attr_name)
+            self.class.attribute_alias(attr_name).to_s
+          else
+            attr_name.to_s
+          end
 
-        write_attribute_with_type_cast(name, value, true, force_write_readonly: force_write_readonly)
+        if self.class.readonly_attributes.include?(name) && attr_readonly_enabled?
+          return
+        end
+
+        write_attribute_with_type_cast(name, value, true)
       end
 
-      def raw_write_attribute(attr_name, value, force_write_readonly: false) # :nodoc:
-        write_attribute_with_type_cast(attr_name, value, false, force_write_readonly: force_write_readonly)
+      def raw_write_attribute(attr_name, value) # :nodoc:
+        write_attribute_with_type_cast(attr_name, value, false)
       end
 
       private
 
         # Handle *= for method_missing.
-        def attribute=(attribute_name, value, force_write_readonly: false)
-          write_attribute(attribute_name, value, force_write_readonly: force_write_readonly)
+        def attribute=(attribute_name, value)
+          write_attribute(attribute_name, value)
         end
 
-        def write_attribute_with_type_cast(attr_name, value, should_type_cast, force_write_readonly: false)
+        def write_attribute_with_type_cast(attr_name, value, should_type_cast)
           attr_name = attr_name.to_s
 
-          return if !force_write_readonly && self.class.readonly_attributes.include?(attr_name)
-
           if should_type_cast
             @attributes.write_from_user(attr_name, value)
           else

data/lib/duck_record/base.rb

@@ -294,26 +294,6 @@ module DuckRecord #:nodoc:
     include NestedAttributes
     include Reflection
     include Serialization
-
-    def to_h(include_empty: true)
-      hash = serializable_hash
-
-      self.class.reflections.keys.each do |k|
-        records = send(k)
-        sub_hash =
-          if records.respond_to?(:to_ary)
-            records.to_ary.map { |a| a.to_h }
-          else
-            records.to_h
-          end
-
-        if include_empty || sub_hash.any?
-          hash[k] = sub_hash
-        end
-      end
-
-      hash
-    end
   end
 
   ActiveSupport.run_load_hooks(:duck_record, Base)

data/lib/duck_record/core.rb

@@ -63,16 +63,20 @@ module DuckRecord
       self.class.define_attribute_methods
       @attributes = self.class._default_attributes.deep_dup
 
+      disable_attr_readonly!
+
       init_internals
       initialize_internals_callback
 
       if attributes
-        assign_attributes(attributes, force_write_readonly: true)
+        assign_attributes(attributes)
         clear_changes_information
       end
 
       yield self if block_given?
       _run_initialize_callbacks
+
+      enable_attr_readonly!
     end
 
     # Initialize an empty model object from +coder+. +coder+ should be

data/lib/duck_record/nested_attributes.rb

@@ -356,7 +356,7 @@ module DuckRecord
           if method_defined?(:#{association_name}_attributes=)
             remove_method(:#{association_name}_attributes=)
           end
-          def #{association_name}_attributes=(attributes, force_write_readonly: false)
+          def #{association_name}_attributes=(attributes)
             assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
           end
         eoruby

data/lib/duck_record/nested_validate_association.rb

@@ -139,7 +139,7 @@ module DuckRecord
     end
 
     included do
-      Associations::Builder::Association.extensions << AssociationBuilderExtension
+      Associations::Builder::EmbedsAssociation.extensions << AssociationBuilderExtension
       mattr_accessor :index_nested_attribute_errors, instance_writer: false
       self.index_nested_attribute_errors = false
     end

data/lib/duck_record/readonly_attributes.rb

@@ -3,10 +3,23 @@ module DuckRecord
     extend ActiveSupport::Concern
 
     included do
+      attr_accessor :_attr_readonly_enabled
       class_attribute :_attr_readonly, instance_accessor: false
       self._attr_readonly = []
     end
 
+    def attr_readonly_enabled?
+      _attr_readonly_enabled
+    end
+
+    def enable_attr_readonly!
+      self._attr_readonly_enabled = true
+    end
+
+    def disable_attr_readonly!
+      self._attr_readonly_enabled = false
+    end
+
     module ClassMethods
       # Attributes listed as readonly will be used to create a new record but update operations will
       # ignore these fields.

data/lib/duck_record/reflection.rb

@@ -15,10 +15,10 @@ module DuckRecord
     def self.create(macro, name, options, ar)
       klass = \
         case macro
-        when :has_many
-          HasManyReflection
-        when :has_one
-          HasOneReflection
+        when :embeds_many
+          EmbedsManyReflection
+        when :embeds_one
+          EmbedsOneReflection
         else
           raise "Unsupported Macro: #{macro}"
         end
@@ -182,7 +182,7 @@ module DuckRecord
 
     # Holds all the metadata about an association as it was specified in the
     # Active Record class.
-    class AssociationReflection < MacroReflection #:nodoc:
+    class EmbedsAssociationReflection < MacroReflection #:nodoc:
       # Returns the target association's class.
       #
       #   class Author < ActiveRecord::Base
@@ -286,23 +286,23 @@ module DuckRecord
         end
     end
 
-    class HasManyReflection < AssociationReflection # :nodoc:
-      def macro; :has_many; end
+    class EmbedsManyReflection < EmbedsAssociationReflection # :nodoc:
+      def macro; :embeds_many; end
 
       def collection?; true; end
 
       def association_class
-        Associations::HasManyAssociation
+        Associations::EmbedsManyAssociation
       end
     end
 
-    class HasOneReflection < AssociationReflection # :nodoc:
-      def macro; :has_one; end
+    class EmbedsOneReflection < EmbedsAssociationReflection # :nodoc:
+      def macro; :embeds_one; end
 
       def has_one?; true; end
 
       def association_class
-        Associations::HasOneAssociation
+        Associations::EmbedsOneAssociation
       end
     end
   end

data/lib/duck_record/serialization.rb

@@ -8,24 +8,13 @@ module DuckRecord #:nodoc:
       self.include_root_in_json = false
     end
 
-    def serializable_hash(options = {})
-      options = (options || {}).reverse_merge except: Array(options[:except]).map(&:to_s)
-      super options
-    end
+    def serializable_hash(options = nil)
+      options = options.try(:dup) || {}
 
-    private
+      options[:except] = Array(options[:except]).map(&:to_s)
+      options[:include] = Array(_reflections.keys).map(&:to_s)
 
-    def read_attribute_for_serialization(key)
-      v = send(key)
-      if v.respond_to?(:serializable_hash)
-        v.serializable_hash
-      elsif v.respond_to?(:to_ary)
-        v.to_ary
-      elsif v.respond_to?(:to_hash)
-        v.to_hash
-      else
-        v
-      end
+      super(options)
     end
   end
 end

data/lib/duck_record/version.rb

@@ -1,3 +1,3 @@
 module DuckRecord
-  VERSION = "0.0.16"
+  VERSION = "0.0.18"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_record
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.18
 platform: ruby
 authors:
 - jasl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-17 00:00:00.000000000 Z
+date: 2017-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -83,17 +83,13 @@ files:
 - lib/core_ext/array_without_blank.rb
 - lib/duck_record.rb
 - lib/duck_record/associations.rb
-- lib/duck_record/associations/association.rb
-- lib/duck_record/associations/builder/association.rb
-- lib/duck_record/associations/builder/collection_association.rb
-- lib/duck_record/associations/builder/has_many.rb
-- lib/duck_record/associations/builder/has_one.rb
-- lib/duck_record/associations/builder/singular_association.rb
-- lib/duck_record/associations/collection_association.rb
-- lib/duck_record/associations/collection_proxy.rb
-- lib/duck_record/associations/has_many_association.rb
-- lib/duck_record/associations/has_one_association.rb
-- lib/duck_record/associations/singular_association.rb
+- lib/duck_record/associations/builder/embeds_association.rb
+- lib/duck_record/associations/builder/embeds_many.rb
+- lib/duck_record/associations/builder/embeds_one.rb
+- lib/duck_record/associations/embeds_association.rb
+- lib/duck_record/associations/embeds_many_association.rb
+- lib/duck_record/associations/embeds_many_proxy.rb
+- lib/duck_record/associations/embeds_one_association.rb
 - lib/duck_record/attribute.rb
 - lib/duck_record/attribute/user_provided_default.rb
 - lib/duck_record/attribute_assignment.rb
@@ -164,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Used for creating virtual models like ActiveType or ModelAttribute does

data/lib/duck_record/associations/builder/has_many.rb

@@ -1,7 +0,0 @@
-module DuckRecord::Associations::Builder # :nodoc:
-  class HasMany < CollectionAssociation #:nodoc:
-    def self.macro
-      :has_many
-    end
-  end
-end

data/lib/duck_record/associations/builder/has_one.rb

@@ -1,15 +0,0 @@
-module DuckRecord::Associations::Builder # :nodoc:
-  class HasOne < SingularAssociation #:nodoc:
-    def self.macro
-      :has_one
-    end
-
-    def self.define_validations(model, reflection)
-      super
-
-      if reflection.options[:required]
-        model.validates_presence_of reflection.name, message: :required
-      end
-    end
-  end
-end

data/lib/duck_record/associations/has_many_association.rb

@@ -1,11 +0,0 @@
-module DuckRecord
-  # = Active Record Has Many Association
-  module Associations
-    # This is the proxy that handles a has many association.
-    #
-    # If the association has a <tt>:through</tt> option further specialization
-    # is provided by its child HasManyThroughAssociation.
-    class HasManyAssociation < CollectionAssociation #:nodoc:
-    end
-  end
-end

data/lib/duck_record/associations/has_one_association.rb

@@ -1,17 +0,0 @@
-module DuckRecord
-  # = Active Record Has One Association
-  module Associations
-    class HasOneAssociation < SingularAssociation #:nodoc:
-      def replace(record)
-        self.target =
-          if record.is_a? klass
-            record
-          elsif record.respond_to?(:to_h)
-            build_record(record.to_h)
-          end
-      rescue
-        raise_on_type_mismatch!(record)
-      end
-    end
-  end
-end