tallty_duck_record 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45f98d3af5325759f0a61afac5487e16fadcec80c6f0516f68ddbb7d4d0beddd
+  data.tar.gz: f4e17fdbb154b415ced973b7dcaf4546cc0264378b5d54b97bc5d784b005c99b
+SHA512:
+  metadata.gz: 6b599f24166fc44208e16e07ff8563f952bd9cc4d01561e21f7980cedb669d4c71107e4b2529372f5a765daab03c89f2b10108aec1cf533cda8ef0bc2fc414d8
+  data.tar.gz: e09ccf3f1a5a0b400c1000738aea0a2bb21ba0980128eb873323fc69eb7d28adcf5c40484d038a9ef2c31b7f0b1e87c68a2d2d62bd7ed6c8b85bbfa69e474491

data/MIT-LICENSE

@@ -0,0 +1,41 @@
+Copyright 2017 Jun Jiang
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Copyright (c) 2004-2017 David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+Duck Record
+====
+
+It looks like Active Record and quacks like Active Record, it's Duck Record! 
+Actually it's extract from Active Record.
+
+## Usage
+
+```ruby
+class Person < DuckRecord::Base
+  attribute :name, :string
+  attribute :age, :integer
+
+  validates :name, presence: true
+end
+
+class Comment < DuckRecord::Base
+  attribute :content, :string
+
+  validates :content, presence: true
+end
+
+class Book < DuckRecord::Base
+  embeds_one :author, class_name: 'Person', validate: true
+  accepts_nested_attributes_for :author
+
+  embeds_many :comments, validate: true
+  accepts_nested_attributes_for :comments
+
+  attribute :title,     :string
+  attribute :tags,      :string,   array:   true
+  attribute :price,     :decimal,  default: 0
+  attribute :meta,      :json,     default: {}
+  attribute :bought_at, :datetime, default: -> { Time.new } 
+
+  validates :title, presence: true
+end
+```
+
+then use these models like a Active Record model,
+but remember that can't be persisting!
+
+## Installation
+ 
+Since Duck Record is under early development, 
+I suggest you fetch the gem through GitHub. 
+ 
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'duck_record', github: 'jasl/duck_record'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install duck_record
+```
+
+## TODO
+
+- refactor that original design for database
+- update docs
+- add useful methods
+- add tests 
+- let me know..
+
+## Contributing
+
+- Fork the project.
+- Make your feature addition or bug fix.
+- Add tests for it. This is important so I don't break it in a future version unintentionally.
+- Commit, do not mess with Rakefile or version (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+- Send me a pull request. Bonus points for topic branches.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "DuckRecord"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/lib/core_ext/array_without_blank.rb

@@ -0,0 +1,46 @@
+class ArrayWithoutBlank < Array
+  def self.new(*several_variants)
+    arr = super
+    arr.reject!(&:blank?)
+    arr
+  end
+
+  def initialize_copy(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def replace(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def push(obj, *smth)
+    return self if obj.blank?
+    super
+  end
+
+  def insert(*args)
+    super *args.reject(&:blank?)
+  end
+
+  def []=(index, obj)
+    return self[index] if obj.blank?
+    super
+  end
+
+  def concat(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def +(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def <<(obj)
+    return self if obj.blank?
+    super
+  end
+
+  def to_ary
+    Array.new(self)
+  end
+end

data/lib/duck_record.rb

@@ -0,0 +1,65 @@
+require "active_support"
+require "active_support/rails"
+require "active_model"
+
+require "core_ext/array_without_blank"
+
+require "duck_record/type"
+require "duck_record/attribute_set"
+
+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
+  autoload :Reflection
+  autoload :Serialization
+  autoload :Translation
+  autoload :Validations
+
+  eager_autoload do
+    autoload :DuckRecordError, "duck_record/errors"
+
+    autoload :Associations
+    autoload :AttributeAssignment
+    autoload :AttributeMethods
+    autoload :NestedValidateAssociation
+  end
+
+  module Coders
+    autoload :YAMLColumn, "duck_record/coders/yaml_column"
+    autoload :JSON, "duck_record/coders/json"
+  end
+
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BeforeTypeCast
+      autoload :Dirty
+      autoload :Read
+      autoload :Serialization
+      autoload :Write
+    end
+  end
+
+  def self.eager_load!
+    super
+
+    DuckRecord::Associations.eager_load!
+    DuckRecord::AttributeMethods.eager_load!
+  end
+end
+
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.dirname(__FILE__) + "/duck_record/locale/en.yml"
+end

data/lib/duck_record/associations.rb

@@ -0,0 +1,130 @@
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/string/conversions"
+require "active_support/core_ext/module/remove_method"
+require "duck_record/errors"
+
+module DuckRecord
+  class AssociationNotFoundError < ConfigurationError #:nodoc:
+    def initialize(record = nil, association_name = nil)
+      if record && association_name
+        super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
+      else
+        super("Association was not found.")
+      end
+    end
+  end
+
+  # See ActiveRecord::Associations::ClassMethods for documentation.
+  module Associations # :nodoc:
+    extend ActiveSupport::Autoload
+    extend ActiveSupport::Concern
+
+    # These classes will be loaded when associations are created.
+    # So there is no need to eager load them.
+    autoload :EmbedsAssociation
+    autoload :EmbedsManyProxy
+
+    autoload :Association
+    autoload :SingularAssociation
+    autoload :CollectionAssociation
+    autoload :ForeignAssociation
+    autoload :CollectionProxy
+    autoload :ThroughAssociation
+
+    module Builder #:nodoc:
+      autoload :Association,           "duck_record/associations/builder/association"
+      autoload :SingularAssociation,   "duck_record/associations/builder/singular_association"
+      autoload :CollectionAssociation, "duck_record/associations/builder/collection_association"
+
+      autoload :EmbedsOne,  "duck_record/associations/builder/embeds_one"
+      autoload :EmbedsMany, "duck_record/associations/builder/embeds_many"
+
+      autoload :BelongsTo, "duck_record/associations/builder/belongs_to"
+      autoload :HasOne,    "duck_record/associations/builder/has_one"
+      autoload :HasMany,   "duck_record/associations/builder/has_many"
+    end
+
+    eager_autoload do
+      autoload :EmbedsManyAssociation
+      autoload :EmbedsOneAssociation
+
+      autoload :BelongsToAssociation
+      autoload :HasOneAssociation
+      autoload :HasOneThroughAssociation
+      autoload :HasManyAssociation
+      autoload :HasManyThroughAssociation
+    end
+
+    # Returns the association instance for the given name, instantiating it if it doesn't already exist
+    def association(name) #:nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        unless reflection = self.class._reflect_on_association(name)
+          raise AssociationNotFoundError.new(self, name)
+        end
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+
+    def association_cached?(name) # :nodoc
+      @association_cache.key?(name)
+    end
+
+    def initialize_dup(*) # :nodoc:
+      @association_cache = {}
+      super
+    end
+
+    private
+      # Clears out the association cache.
+      def clear_association_cache
+        @association_cache.clear if persisted?
+      end
+
+      def init_internals
+        @association_cache = {}
+        super
+      end
+
+      # Returns the specified association instance if it exists, +nil+ otherwise.
+      def association_instance_get(name)
+        @association_cache[name]
+      end
+
+      # Set the specified association instance.
+      def association_instance_set(name, association)
+        @association_cache[name] = association
+      end
+
+      module ClassMethods
+        def embeds_many(name, options = {}, &extension)
+          reflection = Builder::EmbedsMany.build(self, name, nil, options, &extension)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def embeds_one(name, options = {})
+          reflection = Builder::EmbedsOne.build(self, name, nil, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def belongs_to(name, scope = nil, options = {})
+          reflection = Builder::BelongsTo.build(self, name, scope, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def has_one(name, scope = nil, options = {})
+          reflection = Builder::HasOne.build(self, name, scope, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def has_many(name, scope = nil, options = {}, &extension)
+          reflection = Builder::HasMany.build(self, name, scope, options, &extension)
+          Reflection.add_reflection self, name, reflection
+        end
+      end
+  end
+end

data/lib/duck_record/associations/association.rb

@@ -0,0 +1,271 @@
+require "active_support/core_ext/array/wrap"
+
+module DuckRecord
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation + ForeignAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasManyAssociation + ForeignAssociation
+    #         HasManyThroughAssociation + ThroughAssociation
+    class Association #:nodoc:
+      attr_reader :owner, :target, :reflection
+
+      delegate :options, to: :reflection
+
+      def initialize(owner, reflection)
+        reflection.check_validity!
+
+        @owner, @reflection = owner, reflection
+
+        reset
+        reset_scope
+      end
+
+      # Returns the name of the table of the associated class:
+      #
+      #   post.comments.aliased_table_name # => "comments"
+      #
+      def aliased_table_name
+        klass.table_name
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+        @stale_state = nil
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded = true
+        @stale_state = stale_state
+      end
+
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # stale_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scope
+        target_scope.merge!(association_scope)
+      end
+
+      # The scope for this association.
+      #
+      # Note that the association_scope is merged into the target_scope only when the
+      # scope method is called. This is because at that point the call may be surrounded
+      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
+      # actually gets built.
+      def association_scope
+        return unless klass
+
+        @association_scope ||= ActiveRecord::Associations::AssociationScope.scope(self)
+      rescue ArgumentError
+        @association_scope ||= ActiveRecord::Associations::AssociationScope.scope(self, klass.connection)
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        record
+      end
+
+      # Remove the inverse association, if possible
+      def remove_inverse_instance(_record); end
+
+      # Returns the class of the target. belongs_to polymorphic overrides this to look at the
+      # polymorphic_type field on the owner.
+      def klass
+        reflection.klass
+      end
+
+      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+      # through association's scope)
+      def target_scope
+        ActiveRecord::AssociationRelation.create(klass, self).merge!(klass.all)
+      rescue ArgumentError
+        ActiveRecord::AssociationRelation.create(klass, klass.arel_table, klass.predicate_builder, self).merge!(klass.all)
+      end
+
+      def extensions
+        extensions = klass.default_extensions | reflection.extensions
+
+        if scope = reflection.scope
+          extensions |= klass.unscoped.instance_exec(owner, &scope).extensions
+        end
+
+        extensions
+      end
+
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # ActiveRecord::RecordNotFound is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      def load_target
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+
+      def interpolate(sql, record = nil)
+        if sql.respond_to?(:to_proc)
+          owner.instance_exec(record, &sql)
+        else
+          sql
+        end
+      end
+
+      # We can't dump @reflection since it contains the scope proc
+      def marshal_dump
+        ivars = (instance_variables - [:@reflection]).map { |name| [name, instance_variable_get(name)] }
+        [@reflection.name, ivars]
+      end
+
+      def marshal_load(data)
+        reflection_name, ivars = data
+        ivars.each { |name, val| instance_variable_set(name, val) }
+        @reflection = @owner.class._reflect_on_association(reflection_name)
+      end
+
+      def initialize_attributes(record, except_from_scope_attributes = nil) #:nodoc:
+        except_from_scope_attributes ||= {}
+        skip_assign = [reflection.foreign_key, reflection.type].compact
+        assigned_keys = record.changed_attribute_names_to_save
+        assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
+        attributes = create_scope.except(*(assigned_keys - skip_assign))
+        record.assign_attributes(attributes)
+      end
+
+      def create(attributes = {}, &block)
+        _create_record(attributes, &block)
+      end
+
+      def create!(attributes = {}, &block)
+        _create_record(attributes, true, &block)
+      end
+
+      private
+
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        def creation_attributes
+          attributes = {}
+
+          if (reflection.has_one? || reflection.collection?) && !options[:through]
+            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+
+            if reflection.options[:as]
+              attributes[reflection.type] = owner.class.base_class.name
+            end
+          end
+
+          attributes
+        end
+
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          creation_attributes.each { |key, value| record[key] = value }
+        end
+
+        # Returns true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key). If the owner is a new record then foreign_key must
+        # be present in order to load target.
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to.
+        def foreign_key_present?
+          false
+        end
+
+        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch!(record)
+          unless record.is_a?(reflection.klass)
+            fresh_class = reflection.class_name.safe_constantize
+            unless fresh_class && record.is_a?(fresh_class)
+              message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, "\
+                "got #{record.inspect} which is an instance of #{record.class}(##{record.class.object_id})"
+              raise DuckRecord::AssociationTypeMismatch, message
+            end
+          end
+        end
+
+        # Returns true if record contains the foreign_key
+        def foreign_key_for?(record)
+          record.has_attribute?(reflection.foreign_key)
+        end
+
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when stale_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns +nil+ by default.
+        def stale_state
+        end
+
+        def build_record(attributes)
+          reflection.build_association(attributes) do |record|
+            initialize_attributes(record, attributes)
+          end
+        end
+
+        # Returns true if statement cache should be skipped on the association reader.
+        def skip_statement_cache?
+          reflection.has_scope? ||
+            scope.eager_loading? ||
+            klass.scope_attributes? ||
+            reflection.source_reflection.active_record.try(:default_scopes)&.any?
+        end
+    end
+  end
+end