duck_record 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a40d7265442d33cb9b0523abc991f2425c3d87ff
-  data.tar.gz: 266ba229695849261a975fd2924cc9837a095671
+  metadata.gz: 1dab749c33860b97f56557d60be5eb235afe659f
+  data.tar.gz: fc755f0d4c244a248a9a030ae5354e3d2dc2645b
 SHA512:
-  metadata.gz: 363119060b6e6191f6fe401a121c6548b2ca3ae28f5875a95db30aaffbb29d952c8baa0a6a37f3deb4085a24389af87c4b698eb950bcf9b9a46c1761a1a82721
-  data.tar.gz: bc7e1560401aa6afebc76066457085b1b0898e04b69feff43cf7d4ae72693bfe164022c604575752463941360b4ca8bed5ff868d90ad4e7bf0764bc92570c1bd
+  metadata.gz: 79d0c5715448f98ff7702253d5b26f6338fb5f51faec2b36e8a2c7151f5f13989919518b887e1dd94712f59ca4e742dd975ac96a5dfa170f3d17dc15a09b0e01
+  data.tar.gz: 57b4d1113ea3accb7672f3fdd834f23d5e5934fc4b4e21400e640fe7b5fa458ff300dbb84068fad889fbe90bc235ee8166ec6c52e86449847153bc428e39cba9

data/lib/duck_record.rb

@@ -11,10 +11,13 @@ module DuckRecord
   extend ActiveSupport::Autoload
 
   autoload :Attribute
+  autoload :AttributeDecorators
   autoload :Base
   autoload :Callbacks
   autoload :Core
+  autoload :Enum
   autoload :Inheritance
+  autoload :Persistence
   autoload :ModelSchema
   autoload :NestedAttributes
   autoload :ReadonlyAttributes
@@ -32,6 +35,11 @@ module DuckRecord
     autoload :NestedValidateAssociation
   end
 
+  module Coders
+    autoload :YAMLColumn, "duck_record/coders/yaml_column"
+    autoload :JSON, "duck_record/coders/json"
+  end
+
   module AttributeMethods
     extend ActiveSupport::Autoload
 
@@ -39,6 +47,7 @@ module DuckRecord
       autoload :BeforeTypeCast
       autoload :Dirty
       autoload :Read
+      autoload :Serialization
       autoload :Write
     end
   end

data/lib/duck_record/attribute_decorators.rb

@@ -0,0 +1,89 @@
+module DuckRecord
+  module AttributeDecorators # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attribute_type_decorations, instance_accessor: false # :internal:
+      self.attribute_type_decorations = TypeDecorator.new
+    end
+
+    module ClassMethods # :nodoc:
+      # This method is an internal API used to create class macros such as
+      # +serialize+, and features like time zone aware attributes.
+      #
+      # Used to wrap the type of an attribute in a new type.
+      # When the schema for a model is loaded, attributes with the same name as
+      # +column_name+ will have their type yielded to the given block. The
+      # return value of that block will be used instead.
+      #
+      # Subsequent calls where +column_name+ and +decorator_name+ are the same
+      # will override the previous decorator, not decorate twice. This can be
+      # used to create idempotent class macros like +serialize+
+      def decorate_attribute_type(column_name, decorator_name, &block)
+        matcher = ->(name, _) { name == column_name.to_s }
+        key = "_#{column_name}_#{decorator_name}"
+        decorate_matching_attribute_types(matcher, key, &block)
+      end
+
+      # This method is an internal API used to create higher level features like
+      # time zone aware attributes.
+      #
+      # When the schema for a model is loaded, +matcher+ will be called for each
+      # attribute with its name and type. If the matcher returns a truthy value,
+      # the type will then be yielded to the given block, and the return value
+      # of that block will replace the type.
+      #
+      # Subsequent calls to this method with the same value for +decorator_name+
+      # will replace the previous decorator, not decorate twice. This can be
+      # used to ensure that class macros are idempotent.
+      def decorate_matching_attribute_types(matcher, decorator_name, &block)
+        reload_schema_from_cache
+        decorator_name = decorator_name.to_s
+
+        # Create new hashes so we don't modify parent classes
+        self.attribute_type_decorations = attribute_type_decorations.merge(decorator_name => [matcher, block])
+      end
+
+      private
+
+      def load_schema!
+        super
+        attribute_types.each do |name, type|
+          decorated_type = attribute_type_decorations.apply(name, type)
+          define_attribute(name, decorated_type)
+        end
+      end
+    end
+
+    class TypeDecorator # :nodoc:
+      delegate :clear, to: :@decorations
+
+      def initialize(decorations = {})
+        @decorations = decorations
+      end
+
+      def merge(*args)
+        TypeDecorator.new(@decorations.merge(*args))
+      end
+
+      def apply(name, type)
+        decorations = decorators_for(name, type)
+        decorations.inject(type) do |new_type, block|
+          block.call(new_type)
+        end
+      end
+
+      private
+
+      def decorators_for(name, type)
+        matching(name, type).map(&:last)
+      end
+
+      def matching(name, type)
+        @decorations.values.select do |(matcher, _)|
+          matcher.call(name, type)
+        end
+      end
+    end
+  end
+end

data/lib/duck_record/attribute_methods/serialization.rb

@@ -0,0 +1,66 @@
+module DuckRecord
+  module AttributeMethods
+    module Serialization
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # If you have an attribute that needs to be saved to the database as an
+        # object, and retrieved as the same object, then specify the name of that
+        # attribute using this method and it will be handled automatically. The
+        # serialization is done through YAML. If +class_name+ is specified, the
+        # serialized object must be of that class on assignment and retrieval.
+        # Otherwise SerializationTypeMismatch will be raised.
+        #
+        # Empty objects as <tt>{}</tt>, in the case of +Hash+, or <tt>[]</tt>, in the case of
+        # +Array+, will always be persisted as null.
+        #
+        # Keep in mind that database adapters handle certain serialization tasks
+        # for you. For instance: +json+ and +jsonb+ types in PostgreSQL will be
+        # converted between JSON object/array syntax and Ruby +Hash+ or +Array+
+        # objects transparently. There is no need to use #serialize in this
+        # case.
+        #
+        # For more complex cases, such as conversion to or from your application
+        # domain objects, consider using the ActiveRecord::Attributes API.
+        #
+        # ==== Parameters
+        #
+        # * +attr_name+ - The field name that should be serialized.
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
+        #   or a class name that the object type should be equal to.
+        #
+        # ==== Example
+        #
+        #   # Serialize a preferences attribute.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences
+        #   end
+        #
+        #   # Serialize preferences using JSON as coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, JSON
+        #   end
+        #
+        #   # Serialize preferences as Hash using YAML coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, Hash
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object)
+          # When ::JSON is used, force it to go through the Active Support JSON encoder
+          # to ensure special objects (e.g. Active Record models) are dumped correctly
+          # using the #as_json hook.
+          coder = if class_name_or_coder == ::JSON
+            Coders::JSON
+          elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+            class_name_or_coder
+          else
+            Coders::YAMLColumn.new(attr_name, class_name_or_coder)
+          end
+          decorate_attribute_type(attr_name, :serialize) do |type|
+            Type::Serialized.new(type, coder)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/duck_record/attributes.rb

@@ -6,8 +6,8 @@ module DuckRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :attributes_to_define, instance_accessor: false # :internal:
-      self.attributes_to_define = {}
+      class_attribute :attributes_to_define_after_schema_loads, instance_accessor: false # :internal:
+      self.attributes_to_define_after_schema_loads = {}
     end
 
     module ClassMethods
@@ -193,9 +193,10 @@ module DuckRecord
       # methods in ActiveModel::Type::Value for more details.
       def attribute(name, cast_type = Type::Value.new, **options)
         name = name.to_s
+        reload_schema_from_cache
 
-        self.attributes_to_define =
-          attributes_to_define.merge(
+        self.attributes_to_define_after_schema_loads =
+          attributes_to_define_after_schema_loads.merge(
             name => [cast_type, options]
           )
       end
@@ -229,7 +230,7 @@ module DuckRecord
 
       def load_schema! # :nodoc:
         super
-        attributes_to_define.each do |name, (type, options)|
+        attributes_to_define_after_schema_loads.each do |name, (type, options)|
           if type.is_a?(Symbol)
             type = DuckRecord::Type.lookup(type, **options.except(:default))
           end

data/lib/duck_record/base.rb

@@ -274,8 +274,10 @@ module DuckRecord #:nodoc:
     extend ActiveSupport::DescendantsTracker
 
     extend Translation
+    extend Enum
 
     include Core
+    include Persistence
     include ReadonlyAttributes
     include ModelSchema
     include Inheritance
@@ -283,6 +285,7 @@ module DuckRecord #:nodoc:
     include ActiveModel::Conversion
     include Validations
     include Attributes
+    include AttributeDecorators
     include DefineCallbacks
     include AttributeMethods
     include Callbacks
@@ -292,14 +295,6 @@ module DuckRecord #:nodoc:
     include Reflection
     include Serialization
 
-    def persisted?
-      false
-    end
-
-    def new_record?
-      true
-    end
-
     def to_h(include_empty: true)
       hash = serializable_hash
 

data/lib/duck_record/coders/json.rb

@@ -0,0 +1,13 @@
+module DuckRecord
+  module Coders # :nodoc:
+    class JSON # :nodoc:
+      def self.dump(obj)
+        ActiveSupport::JSON.encode(obj)
+      end
+
+      def self.load(json)
+        ActiveSupport::JSON.decode(json) unless json.blank?
+      end
+    end
+  end
+end

data/lib/duck_record/coders/yaml_column.rb

@@ -0,0 +1,48 @@
+require "yaml"
+
+module DuckRecord
+  module Coders # :nodoc:
+    class YAMLColumn # :nodoc:
+      attr_accessor :object_class
+
+      def initialize(attr_name, object_class = Object)
+        @attr_name = attr_name
+        @object_class = object_class
+        check_arity_of_constructor
+      end
+
+      def dump(obj)
+        return if obj.nil?
+
+        assert_valid_value(obj, action: "dump")
+        YAML.dump obj
+      end
+
+      def load(yaml)
+        return object_class.new if object_class != Object && yaml.nil?
+        return yaml unless yaml.is_a?(String) && /^---/.match?(yaml)
+        obj = YAML.load(yaml)
+
+        assert_valid_value(obj, action: "load")
+        obj ||= object_class.new if object_class != Object
+
+        obj
+      end
+
+      def assert_valid_value(obj, action:)
+        unless obj.nil? || obj.is_a?(object_class)
+          raise SerializationTypeMismatch,
+            "can't #{action} `#{@attr_name}`: was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+        end
+      end
+
+      private
+
+        def check_arity_of_constructor
+          load(nil)
+        rescue ArgumentError
+          raise ArgumentError, "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
+        end
+    end
+  end
+end

data/lib/duck_record/core.rb

@@ -45,7 +45,8 @@ module DuckRecord
         if abstract_class?
           "#{super}(abstract)"
         else
-          super
+          attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
+          "#{super}(#{attr_list})"
         end
       end
     end

data/lib/duck_record/enum.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/deep_dup"
+
+module DuckRecord
+  module Enum
+    def self.extended(base) # :nodoc:
+      base.class_attribute(:defined_enums, instance_writer: false)
+      base.defined_enums = {}
+    end
+
+    def inherited(base) # :nodoc:
+      base.defined_enums = defined_enums.deep_dup
+      super
+    end
+
+    class EnumType < ActiveModel::Type::Value # :nodoc:
+      delegate :type, to: :subtype
+
+      def initialize(name, mapping, subtype)
+        @name = name
+        @mapping = mapping
+        @subtype = subtype
+      end
+
+      def cast(value)
+        return if value.blank?
+
+        if mapping.has_key?(value)
+          value.to_s
+        elsif mapping.has_value?(value)
+          mapping.key(value)
+        else
+          assert_valid_value(value)
+        end
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        mapping.key(subtype.deserialize(value))
+      end
+
+      def serialize(value)
+        mapping.fetch(value, value)
+      end
+
+      def assert_valid_value(value)
+        unless value.blank? || mapping.has_key?(value) || mapping.has_value?(value)
+          raise ArgumentError, "'#{value}' is not a valid #{name}"
+        end
+      end
+
+      private
+
+      attr_reader :name, :mapping, :subtype
+    end
+
+    def enum(definitions)
+      klass = self
+      enum_prefix = definitions.delete(:_prefix)
+      enum_suffix = definitions.delete(:_suffix)
+      definitions.each do |name, values|
+        # statuses = { }
+        enum_values = ActiveSupport::HashWithIndifferentAccess.new
+        name        = name.to_sym
+
+        # def self.statuses() statuses end
+        detect_enum_conflict!(name, name.to_s.pluralize, true)
+        klass.singleton_class.send(:define_method, name.to_s.pluralize) { enum_values }
+
+        detect_enum_conflict!(name, name)
+        detect_enum_conflict!(name, "#{name}=")
+
+        attr = attribute_alias?(name) ? attribute_alias(name) : name
+        decorate_attribute_type(attr, :enum) do |subtype|
+          EnumType.new(attr, enum_values, subtype)
+        end
+
+        _enum_methods_module.module_eval do
+          pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
+          pairs.each do |value, i|
+            if enum_prefix == true
+              prefix = "#{name}_"
+            elsif enum_prefix
+              prefix = "#{enum_prefix}_"
+            end
+            if enum_suffix == true
+              suffix = "_#{name}"
+            elsif enum_suffix
+              suffix = "_#{enum_suffix}"
+            end
+
+            value_method_name = "#{prefix}#{value}#{suffix}"
+            enum_values[value] = i
+
+            # def active?() status == 0 end
+            klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
+            define_method("#{value_method_name}?") { self[attr] == value.to_s }
+          end
+        end
+        defined_enums[name.to_s] = enum_values
+      end
+    end
+
+    private
+    def _enum_methods_module
+      @_enum_methods_module ||= begin
+        mod = Module.new
+        include mod
+        mod
+      end
+    end
+
+    ENUM_CONFLICT_MESSAGE = \
+        "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
+        "this will generate a %{type} method \"%{method}\", which is already defined " \
+        "by %{source}."
+
+    def detect_enum_conflict!(enum_name, method_name, klass_method = false)
+      if klass_method && dangerous_class_method?(method_name)
+        raise_conflict_error(enum_name, method_name, type: "class")
+      elsif !klass_method && dangerous_attribute_method?(method_name)
+        raise_conflict_error(enum_name, method_name)
+      elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
+        raise_conflict_error(enum_name, method_name, source: "another enum")
+      end
+    end
+
+    def raise_conflict_error(enum_name, method_name, type: "instance", source: "Active Record")
+      raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+        enum: enum_name,
+        klass: name,
+        type: type,
+        method: method_name,
+        source: source
+      }
+    end
+  end
+end

data/lib/duck_record/errors.rb

@@ -53,6 +53,10 @@ module DuckRecord
     end
   end
 
+  # Raised when unserialized object's type mismatches one specified for serializable field.
+  class SerializationTypeMismatch < DuckRecordError
+  end
+
   # Raised when there are multiple errors while doing a mass assignment through the
   # {DuckRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=]
   # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError

data/lib/duck_record/model_schema.rb

@@ -9,7 +9,7 @@ module DuckRecord
     module ClassMethods
       def attribute_types # :nodoc:
         load_schema
-        @attribute_types ||= Hash.new
+        @attribute_types ||= Hash.new(Type.default_value)
       end
 
       def yaml_encoder # :nodoc:
@@ -42,7 +42,7 @@ module DuckRecord
       private
 
         def schema_loaded?
-          defined?(@loaded) && @loaded
+          defined?(@schema_loaded) && @schema_loaded
         end
 
         def load_schema
@@ -52,7 +52,19 @@ module DuckRecord
         end
 
         def load_schema!
-          @loaded = true
+          @schema_loaded = true
+        end
+
+        def reload_schema_from_cache
+          @attribute_types = nil
+          @default_attributes = nil
+          @attributes_builder = nil
+          @schema_loaded = false
+          @attribute_names = nil
+          @yaml_encoder = nil
+          direct_descendants.each do |descendant|
+            descendant.send(:reload_schema_from_cache)
+          end
         end
     end
   end

data/lib/duck_record/persistence.rb

@@ -0,0 +1,39 @@
+module DuckRecord
+  # = DuckRecord \Persistence
+  module Persistence
+    extend ActiveSupport::Concern
+
+    def persisted?
+      false
+    end
+
+    def destroyed?
+      false
+    end
+
+    def new_record?
+      true
+    end
+
+    # Returns an instance of the specified +klass+ with the attributes of the
+    # current record. This is mostly useful in relation to single-table
+    # inheritance structures where you want a subclass to appear as the
+    # superclass. This can be used along with record identification in
+    # Action Pack to allow, say, <tt>Client < Company</tt> to do something
+    # like render <tt>partial: @client.becomes(Company)</tt> to render that
+    # instance using the companies/company partial instead of clients/client.
+    #
+    # Note: The new instance will share a link to the same attributes as the original class.
+    # Therefore the sti column value will still be the same.
+    # Any change to the attributes on either instance will affect both instances.
+    # If you want to change the sti column as well, use #becomes! instead.
+    def becomes(klass)
+      became = klass.new
+      became.instance_variable_set("@attributes", @attributes)
+      became.instance_variable_set("@mutation_tracker", @mutation_tracker) if defined?(@mutation_tracker)
+      became.instance_variable_set("@changed_attributes", attributes_changed_by_setter)
+      became.errors.copy!(errors)
+      became
+    end
+  end
+end

data/lib/duck_record/type.rb

@@ -41,6 +41,10 @@ module DuckRecord
       def lookup(*args, **kwargs) # :nodoc:
         registry.lookup(*args, **kwargs)
       end
+
+      def default_value # :nodoc:
+        @default_value ||= Value.new
+      end
     end
 
     Helpers = ActiveModel::Type::Helpers

data/lib/duck_record/version.rb

@@ -1,3 +1,3 @@
 module DuckRecord
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_record
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - jasl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-04 00:00:00.000000000 Z
+date: 2017-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -97,10 +97,12 @@ files:
 - lib/duck_record/attribute.rb
 - lib/duck_record/attribute/user_provided_default.rb
 - lib/duck_record/attribute_assignment.rb
+- lib/duck_record/attribute_decorators.rb
 - lib/duck_record/attribute_methods.rb
 - lib/duck_record/attribute_methods/before_type_cast.rb
 - lib/duck_record/attribute_methods/dirty.rb
 - lib/duck_record/attribute_methods/read.rb
+- lib/duck_record/attribute_methods/serialization.rb
 - lib/duck_record/attribute_methods/write.rb
 - lib/duck_record/attribute_mutation_tracker.rb
 - lib/duck_record/attribute_set.rb
@@ -108,14 +110,18 @@ files:
 - lib/duck_record/attributes.rb
 - lib/duck_record/base.rb
 - lib/duck_record/callbacks.rb
+- lib/duck_record/coders/json.rb
+- lib/duck_record/coders/yaml_column.rb
 - lib/duck_record/core.rb
 - lib/duck_record/define_callbacks.rb
+- lib/duck_record/enum.rb
 - lib/duck_record/errors.rb
 - lib/duck_record/inheritance.rb
 - lib/duck_record/locale/en.yml
 - lib/duck_record/model_schema.rb
 - lib/duck_record/nested_attributes.rb
 - lib/duck_record/nested_validate_association.rb
+- lib/duck_record/persistence.rb
 - lib/duck_record/readonly_attributes.rb
 - lib/duck_record/reflection.rb
 - lib/duck_record/serialization.rb
@@ -158,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Used for creating virtual models like ActiveType or ModelAttribute does