duck_record 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ddd659e371a6f19e0c6721e0db7c6b39d84d959
-  data.tar.gz: 2ddcf8b3f50ddc3954db3ce04e83d4dbd356a175
+  metadata.gz: edf615681e997320dd43475ac1b65efbf4a6355b
+  data.tar.gz: 2790953d7ec98a37866298eb4c445ed62e71f22c
 SHA512:
-  metadata.gz: 7bc31bc533d951a904ac72d7de80d7398281ad7d701bf3380ab845fd4da6b33f3f491a2f93d2a5599d8461429f501e9fc1822531686c6568c3ede57700206991
-  data.tar.gz: cb451b408a562925a2505b3a4282deaedd25d638251d2f49ae5f6d6808911f43a93887735f086a4435b93b177a27b7d74310931d9dd87c6915356857fc0555ba
+  metadata.gz: 5bb6d8c090cc556f4edf072de23146850001ebdea769ab6656eb129aec0e07500b2c66aafdca655dc6df3a6efcada0af47f071a48bc3a9d8ee3c1a42545025b5
+  data.tar.gz: a7ef53be7401e9612c332d2a2f812f92d1a8ed8145d63855ac2da2ce4de415b3e5ff0afbf49219dd9ec1a787dbf81746219932d373edcaede219990f92a0b0ad

data/README.md

@@ -9,10 +9,12 @@ Actually it's extract from Active Record.
 ```ruby
 class Book < DuckRecord::Base
   attribute :title,     :string
-  attribute :tags,      :string,   array:   true
   attribute :price,     :decimal,  default: 0
-  attribute :meta,      :json,     default: {}
   attribute :bought_at, :datetime, default: -> { Time.new } 
+
+  # some types that cheated from PG
+  attribute :tags,      :string,   array:   true
+  attribute :meta,      :json,     default: {}
   
   validates :title, presence: true
 end
@@ -44,7 +46,9 @@ $ gem install duck_record
 - `has_one`, `has_many`
 - refactor that original design for database
 - update docs
+- add useful methods
 - add tests 
+- let me known..
 
 ## Contributing
 

data/lib/duck_record/attribute.rb

@@ -1,6 +1,10 @@
 module DuckRecord
   class Attribute # :nodoc:
     class << self
+      def from_database(name, value, type)
+        FromDatabase.new(name, value, type)
+      end
+
       def from_user(name, value, type, original_attribute = nil)
         FromUser.new(name, value, type, original_attribute)
       end
@@ -64,16 +68,16 @@ module DuckRecord
       self.class.from_user(name, value, type, original_attribute || self)
     end
 
+    def with_value_from_database(value)
+      self.class.from_database(name, value, type)
+    end
+
     def with_cast_value(value)
       self.class.with_cast_value(name, value, type)
     end
 
     def with_type(type)
-      if changed_in_place?
-        with_value_from_user(value).with_type(type)
-      else
-        self.class.new(name, value_before_type_cast, type, original_attribute)
-      end
+      self.class.new(name, value_before_type_cast, type, original_attribute)
     end
 
     def type_cast(*)
@@ -104,38 +108,11 @@ module DuckRecord
       [self.class, name, value_before_type_cast, type].hash
     end
 
-    def init_with(coder)
-      @name = coder["name"]
-      @value_before_type_cast = coder["value_before_type_cast"]
-      @type = coder["type"]
-      @original_attribute = coder["original_attribute"]
-      @value = coder["value"] if coder.map.key?("value")
-    end
-
-    def encode_with(coder)
-      coder["name"] = name
-      coder["value_before_type_cast"] = value_before_type_cast if value_before_type_cast
-      coder["type"] = type if type
-      coder["original_attribute"] = original_attribute if original_attribute
-      coder["value"] = value if defined?(@value)
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
     attr_reader :original_attribute
     alias_method :assigned?, :original_attribute
 
-    def original_value_for_database
-      if assigned?
-        original_attribute.original_value_for_database
-      else
-        _original_value_for_database
-      end
-    end
-
-    private
     def initialize_dup(other)
       if defined?(@value) && @value.duplicable?
         @value = @value.dup
@@ -146,10 +123,28 @@ module DuckRecord
       assigned? && type.changed?(original_value, value, value_before_type_cast)
     end
 
+    def original_value_for_database
+      if assigned?
+        original_attribute.original_value_for_database
+      else
+        _original_value_for_database
+      end
+    end
+
     def _original_value_for_database
       type.serialize(original_value)
     end
 
+    class FromDatabase < Attribute # :nodoc:
+      def type_cast(value)
+        type.deserialize(value)
+      end
+
+      def _original_value_for_database
+        value_before_type_cast
+      end
+    end
+
     class FromUser < Attribute # :nodoc:
       def type_cast(value)
         type.cast(value)
@@ -172,7 +167,7 @@ module DuckRecord
 
     class Null < Attribute # :nodoc:
       def initialize(name)
-        super(name, nil, nil)
+        super(name, nil, Type::Value.new)
       end
 
       def type_cast(*)
@@ -183,9 +178,10 @@ module DuckRecord
         self.class.with_cast_value(name, nil, type)
       end
 
-      def with_value_from_user(value)
+      def with_value_from_database(value)
         raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
       end
+      alias_method :with_value_from_user, :with_value_from_database
     end
 
     class Uninitialized < Attribute # :nodoc:
@@ -211,11 +207,7 @@ module DuckRecord
       def initialized?
         false
       end
-
-      def with_type(type)
-        self.class.new(name, DuckRecord::Type::Value.new)
-      end
     end
-    private_constant :FromUser, :Null, :Uninitialized, :WithCastValue
+    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
   end
 end

data/lib/duck_record/attribute/user_provided_default.rb

@@ -3,9 +3,9 @@ require 'duck_record/attribute'
 module DuckRecord
   class Attribute # :nodoc:
     class UserProvidedDefault < FromUser # :nodoc:
-      def initialize(name, value, type, database_default)
+      def initialize(name, value, type, default)
         @user_provided_value = value
-        super(name, value, type, database_default)
+        super(name, value, type, default)
       end
 
       def value_before_type_cast

data/lib/duck_record/attribute_assignment.rb

@@ -61,7 +61,7 @@ module DuckRecord
         end
       end
       unless errors.empty?
-        error_descriptions = errors.map(&:message).join(",")
+        error_descriptions = errors.map(&:message).join(',')
         raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
       end
     end
@@ -70,7 +70,7 @@ module DuckRecord
       attributes = {}
 
       pairs.each do |(multiparameter_name, value)|
-        attribute_name = multiparameter_name.split("(").first
+        attribute_name = multiparameter_name.split('(').first
         attributes[attribute_name] ||= {}
 
         parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)

data/lib/duck_record/attribute_methods.rb

@@ -182,14 +182,7 @@ module DuckRecord
     def respond_to?(name, include_private = false)
       return false unless super
 
-      case name
-      when :to_partial_path
-        name = 'to_partial_path'.freeze
-      when :to_model
-        name = 'to_model'.freeze
-      else
-        name = name.to_s
-      end
+      name = name.to_s
 
       # If the result is true then check for the select case.
       # For queries selecting a subset of columns, return false for unselected columns.

data/lib/duck_record/attribute_methods/before_type_cast.rb

@@ -63,14 +63,14 @@ module DuckRecord
 
       private
 
-        # Handle *_before_type_cast for method_missing.
-        def attribute_before_type_cast(attribute_name)
-          read_attribute_before_type_cast(attribute_name)
-        end
+      # Handle *_before_type_cast for method_missing.
+      def attribute_before_type_cast(attribute_name)
+        read_attribute_before_type_cast(attribute_name)
+      end
 
-        def attribute_came_from_user?(attribute_name)
-          @attributes[attribute_name].came_from_user?
-        end
+      def attribute_came_from_user?(attribute_name)
+        @attributes[attribute_name].came_from_user?
+      end
     end
   end
 end

data/lib/duck_record/attribute_methods/dirty.rb

@@ -9,11 +9,6 @@ module DuckRecord
 
       include ActiveModel::Dirty
 
-      included do
-        class_attribute :partial_writes, instance_writer: false
-        self.partial_writes = true
-      end
-
       def initialize_dup(other) # :nodoc:
         super
         @attributes = self.class._default_attributes.map do |attr|
@@ -88,18 +83,6 @@ module DuckRecord
         mutation_tracker.forget_change(attr_name)
       end
 
-      def _update_record(*)
-        partial_writes? ? super(keys_for_partial_write) : super
-      end
-
-      def _create_record(*)
-        partial_writes? ? super(keys_for_partial_write) : super
-      end
-
-      def keys_for_partial_write
-        changed & self.class.column_names
-      end
-
       def store_original_attributes
         @attributes = @attributes.map(&:forgetting_assignment)
         @mutation_tracker = nil

data/lib/duck_record/attribute_methods/read.rb

@@ -25,7 +25,7 @@ module DuckRecord
         # Making it frozen means that it doesn't get duped when used to
         # key the @attributes in read_attribute.
         def define_method_attribute(name)
-          safe_name = name.unpack("h*".freeze).first
+          safe_name = name.unpack('h*'.freeze).first
           temp_method = "__temp__#{safe_name}"
 
           DuckRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name

data/lib/duck_record/attribute_mutation_tracker.rb

@@ -5,7 +5,6 @@ module DuckRecord
     def initialize(attributes)
       @attributes = attributes
       @forced_changes = Set.new
-      @deprecated_forced_changes = Set.new
     end
 
     def changed_values
@@ -32,7 +31,7 @@ module DuckRecord
     end
 
     def any_changes?
-      attr_names.any? { |attr| changed?(attr) } || deprecated_forced_changes.any?
+      attr_names.any? { |attr| changed?(attr) }
     end
 
     def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
@@ -61,15 +60,11 @@ module DuckRecord
       forced_changes << attr_name.to_s
     end
 
-    def deprecated_force_change(attr_name)
-      deprecated_forced_changes << attr_name.to_s
-    end
-
     # TODO Change this to private once we've dropped Ruby 2.2 support.
     # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-    attr_reader :attributes, :forced_changes, :deprecated_forced_changes
+    attr_reader :attributes, :forced_changes
 
     private
 
@@ -89,7 +84,7 @@ module DuckRecord
       {}
     end
 
-    def change_to_attribute(attr_name)
+    def change_to_attribute(_)
     end
 
     def any_changes?(*)

data/lib/duck_record/attribute_set.rb

@@ -1,4 +1,3 @@
-require 'duck_record/attribute_set/builder'
 require 'duck_record/attribute_set/yaml_encoder'
 
 module DuckRecord
@@ -88,12 +87,12 @@ module DuckRecord
     # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-      attr_reader :attributes
+    attr_reader :attributes
 
     private
 
-      def initialized_attributes
-        attributes.select { |_, attr| attr.initialized? }
-      end
+    def initialized_attributes
+      attributes.select { |_, attr| attr.initialized? }
+    end
   end
 end

data/lib/duck_record/attributes.rb

@@ -221,8 +221,7 @@ module DuckRecord
       def define_attribute(
         name,
         cast_type,
-        default: NO_DEFAULT_PROVIDED,
-        user_provided_default: true
+        default: NO_DEFAULT_PROVIDED
       )
         attribute_types[name] = cast_type
         define_default_attribute(name, default, cast_type)

data/lib/duck_record/core.rb

@@ -13,13 +13,7 @@ module DuckRecord
         super
       end
 
-      def initialize_find_by_cache # :nodoc:
-        @find_by_statement_cache = { true => {}.extend(Mutex_m), false => {}.extend(Mutex_m) }
-      end
-
       def inherited(child_class) # :nodoc:
-        # initialize cache at class definition for thread safety
-        child_class.initialize_find_by_cache
         super
       end
 
@@ -62,7 +56,10 @@ module DuckRecord
       init_internals
       initialize_internals_callback
 
-      assign_attributes(attributes) if attributes
+      if attributes
+        assign_attributes(attributes)
+        clear_changes_information
+      end
 
       yield self if block_given?
       _run_initialize_callbacks
@@ -83,7 +80,6 @@ module DuckRecord
     #   post.init_with(coder)
     #   post.title # => 'hello world'
     def init_with(coder)
-      coder = LegacyYamlAdapter.convert(self.class, coder)
       @attributes = self.class.yaml_encoder.decode(coder)
 
       init_internals
@@ -92,7 +88,6 @@ module DuckRecord
 
       yield self if block_given?
 
-      _run_find_callbacks
       _run_initialize_callbacks
 
       self
@@ -199,17 +194,17 @@ module DuckRecord
         if defined?(@attributes) && @attributes
           pp.seplist(self.class.attribute_names, proc { pp.text ',' }) do |attribute_name|
             attribute_value = read_attribute(attribute_name)
-            pp.breakable " "
+            pp.breakable ' '
             pp.group(1) do
               pp.text attribute_name
-              pp.text ":"
+              pp.text ':'
               pp.breakable
               pp.pp attribute_value
             end
           end
         else
-          pp.breakable " "
-          pp.text "not initialized"
+          pp.breakable ' '
+          pp.text 'not initialized'
         end
       end
     end
@@ -234,7 +229,7 @@ module DuckRecord
     end
 
     def init_internals
-      @readonly                 = false
+      @readonly = false
     end
 
     def initialize_internals_callback

data/lib/duck_record/inheritance.rb

@@ -1,4 +1,4 @@
-require "active_support/core_ext/hash/indifferent_access"
+require 'active_support/core_ext/hash/indifferent_access'
 
 module DuckRecord
   # == Single table inheritance
@@ -99,7 +99,7 @@ module DuckRecord
       # Returns the class type of the record using the current module as a prefix. So descendants of
       # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
       def compute_type(type_name)
-        if type_name.start_with?("::".freeze)
+        if type_name.start_with?('::'.freeze)
           # If the type is prefixed with a scope operator then we assume that
           # the type_name is an absolute reference.
           ActiveSupport::Dependencies.constantize(type_name)

data/lib/duck_record/model_schema.rb

@@ -8,10 +8,6 @@ module DuckRecord
 
     module ClassMethods
 
-      def attributes_builder # :nodoc:
-        @attributes_builder ||= AttributeSet::Builder.new(attribute_types)
-      end
-
       def attribute_types # :nodoc:
         load_schema
         @attribute_types ||= Hash.new

data/lib/duck_record/translation.rb

@@ -16,7 +16,7 @@ module DuckRecord
 
     # Set the i18n scope to overwrite ActiveModel.
     def i18n_scope #:nodoc:
-      :activerecord
+      :duck_record
     end
   end
 end

data/lib/duck_record/type.rb

@@ -47,6 +47,7 @@ module DuckRecord
     DateTime = ActiveModel::Type::DateTime
     Time = ActiveModel::Type::Time
     Date = ActiveModel::Type::Date
+    Value = ActiveModel::Type::Value
 
     register(:big_integer, Type::BigInteger, override: false)
     register(:binary, Type::Binary, override: false)

data/lib/duck_record/type/serialized.rb

@@ -43,21 +43,21 @@ module DuckRecord
 
       def assert_valid_value(value)
         if coder.respond_to?(:assert_valid_value)
-          coder.assert_valid_value(value, action: "serialize")
+          coder.assert_valid_value(value, action: 'serialize')
         end
       end
 
       private
 
-        def default_value?(value)
-          value == coder.load(nil)
-        end
+      def default_value?(value)
+        value == coder.load(nil)
+      end
 
-        def encoded(value)
-          unless default_value?(value)
-            coder.dump(value)
-          end
+      def encoded(value)
+        unless default_value?(value)
+          coder.dump(value)
         end
+      end
     end
   end
 end

data/lib/duck_record/version.rb

@@ -1,3 +1,3 @@
 module DuckRecord
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duck_record
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - jasl
@@ -52,8 +52,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: "It looks like Active Record and quacks like Active Record, it's Duck
-  Record! \n    Actually it's extract from Active Record."
+description: "It looks like Active Record and quacks like Active Record, but it can't
+  do persistence or querying,\n    it's Duck Record! \n    Actually it's extract from
+  Active Record.\n    Used for creating virtual models like ActiveType or ModelAttribute
+  does."
 email:
 - jasl9187@hotmail.com
 executables: []
@@ -74,7 +76,6 @@ files:
 - lib/duck_record/attribute_methods/write.rb
 - lib/duck_record/attribute_mutation_tracker.rb
 - lib/duck_record/attribute_set.rb
-- lib/duck_record/attribute_set/builder.rb
 - lib/duck_record/attribute_set/yaml_encoder.rb
 - lib/duck_record/attributes.rb
 - lib/duck_record/base.rb
@@ -122,5 +123,5 @@ rubyforge_project:
 rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
-summary: Active Record without persistence
+summary: Used for creating virtual models like ActiveType or ModelAttribute does
 test_files: []

data/lib/duck_record/attribute_set/builder.rb

@@ -1,124 +0,0 @@
-require 'duck_record/attribute'
-
-module DuckRecord
-  class AttributeSet # :nodoc:
-    class Builder # :nodoc:
-      attr_reader :types, :always_initialized, :default
-
-      def initialize(types, always_initialized = nil, &default)
-        @types = types
-        @always_initialized = always_initialized
-        @default = default
-      end
-
-      def build_from_user(values = {}, additional_types = {})
-        if always_initialized && !values.key?(always_initialized)
-          values[always_initialized] = nil
-        end
-
-        attributes = LazyAttributeHash.new(types, values, additional_types, &default)
-        AttributeSet.new(attributes)
-      end
-    end
-  end
-
-  class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :each_value, :fetch, to: :materialize
-
-    def initialize(types, values, additional_types, &default)
-      @types = types
-      @values = values
-      @additional_types = additional_types
-      @materialized = false
-      @delegate_hash = {}
-      @default = default || proc {}
-    end
-
-    def key?(key)
-      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
-    end
-
-    def [](key)
-      delegate_hash[key] || assign_default_value(key)
-    end
-
-    def []=(key, value)
-      if frozen?
-        raise RuntimeError, "Can't modify frozen hash"
-      end
-      delegate_hash[key] = value
-    end
-
-    def deep_dup
-      dup.tap do |copy|
-        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
-      end
-    end
-
-    def initialize_dup(_)
-      @delegate_hash = Hash[delegate_hash]
-      super
-    end
-
-    def select
-      keys = types.keys | values.keys | delegate_hash.keys
-      keys.each_with_object({}) do |key, hash|
-        attribute = self[key]
-        if yield(key, attribute)
-          hash[key] = attribute
-        end
-      end
-    end
-
-    def ==(other)
-      if other.is_a?(LazyAttributeHash)
-        materialize == other.materialize
-      else
-        materialize == other
-      end
-    end
-
-    def marshal_dump
-      materialize
-    end
-
-    def marshal_load(delegate_hash)
-      @delegate_hash = delegate_hash
-      @types = {}
-      @values = {}
-      @additional_types = {}
-      @materialized = true
-    end
-
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
-    protected
-
-      attr_reader :types, :values, :additional_types, :delegate_hash, :default
-
-      def materialize
-        unless @materialized
-          values.each_key { |key| self[key] }
-          types.each_key { |key| self[key] }
-          unless frozen?
-            @materialized = true
-          end
-        end
-        delegate_hash
-      end
-
-    private
-
-    def assign_default_value(name)
-      type = additional_types.fetch(name, types[name])
-      value_present = true
-      value = values.fetch(name) { value_present = false }
-
-      if value_present
-        delegate_hash[name] = Attribute.from_user(name, value, type)
-      elsif types.key?(name)
-        delegate_hash[name] = default.call(name) || Attribute.uninitialized(name, type)
-      end
-    end
-  end
-end