duck_record 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edf615681e997320dd43475ac1b65efbf4a6355b
-  data.tar.gz: 2790953d7ec98a37866298eb4c445ed62e71f22c
+  metadata.gz: bc1667096dfb88fc6d2b74ea577440eb5bcf8fd0
+  data.tar.gz: 86a738d000265404c2309bf4d04ff6a5db11d446
 SHA512:
-  metadata.gz: 5bb6d8c090cc556f4edf072de23146850001ebdea769ab6656eb129aec0e07500b2c66aafdca655dc6df3a6efcada0af47f071a48bc3a9d8ee3c1a42545025b5
-  data.tar.gz: a7ef53be7401e9612c332d2a2f812f92d1a8ed8145d63855ac2da2ce4de415b3e5ff0afbf49219dd9ec1a787dbf81746219932d373edcaede219990f92a0b0ad
+  metadata.gz: 2e92f601db7fae6b7a687cb42caa647ba39ca2441f0174a6999feeb5a0d1537eab686c7297734981ca2bb77109b3eaf7f7a5cff7a1da63f2bff1ef6efe15f2a9
+  data.tar.gz: e61511a9b89654b61a1350d69a748e44cba5b4ef8fd3ef061667db04f12a1d57e00d1a6ac95dfa63a8c32ddf512d7b146c7432a1f0a7f9ea6ba7937dbd5c9977

data/README.md

@@ -7,19 +7,39 @@ 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
+  has_one :author, class_name: 'Person', validate: true
+  accepts_nested_attributes_for :author
+
+  has_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 } 
 
-  # some types that cheated from PG
-  attribute :tags,      :string,   array:   true
-  attribute :meta,      :json,     default: {}
-  
   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, 
@@ -43,12 +63,11 @@ $ gem install duck_record
 
 ## TODO
 
-- `has_one`, `has_many`
 - refactor that original design for database
 - update docs
 - add useful methods
 - add tests 
-- let me known..
+- let me know..
 
 ## Contributing
 

data/Rakefile

@@ -25,5 +25,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
 task default: :test

data/lib/duck_record/associations/association.rb

@@ -0,0 +1,86 @@
+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
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @target = nil
+      end
+
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+      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
+
+      # 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, attributes = nil) #:nodoc:
+        record.assign_attributes(attributes)
+      end
+
+      private
+
+      # 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 ActiveRecord::AssociationTypeMismatch, message
+          end
+        end
+      end
+
+      def build_record(attributes)
+        reflection.build_association(attributes) do |record|
+          initialize_attributes(record, attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# This is the parent Association class which defines the variables
+# used by all associations.
+#
+# The hierarchy is defined as follows:
+#  Association
+#    - SingularAssociation
+#      - BelongsToAssociation
+#      - HasOneAssociation
+#    - CollectionAssociation
+#      - HasManyAssociation
+
+module DuckRecord::Associations::Builder # :nodoc:
+  class Association #:nodoc:
+    class << self
+      attr_accessor :extensions
+    end
+    self.extensions = []
+
+    VALID_OPTIONS = [:class_name, :anonymous_class, :validate] # :nodoc:
+
+    def self.build(model, name, options, &block)
+      if model.dangerous_attribute_method?(name)
+        raise ArgumentError, "You tried to define an association named #{name} on the model #{model.name}, but " \
+                             "this will conflict with a method #{name} already defined by Active Record. " \
+                             "Please choose a different association name."
+      end
+
+      extension = define_extensions model, name, &block
+      reflection = create_reflection model, name, options, extension
+      define_accessors model, reflection
+      define_callbacks model, reflection
+      define_validations model, reflection
+      reflection
+    end
+
+    def self.create_reflection(model, name, options, extension = nil)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      validate_options(options)
+
+      DuckRecord::Reflection.create(macro, name, options, model)
+    end
+
+    def self.macro
+      raise NotImplementedError
+    end
+
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
+    end
+
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
+    end
+
+    def self.define_extensions(model, name)
+    end
+
+    def self.define_callbacks(model, reflection)
+      Association.extensions.each do |extension|
+        extension.build model, reflection
+      end
+    end
+
+    # Defines the setter and getter methods for the association
+    # class Post < ActiveRecord::Base
+    #   has_many :comments
+    # end
+    #
+    # Post.first.comments and Post.first.comments= methods are defined by this method...
+    def self.define_accessors(model, reflection)
+      mixin = model.generated_association_methods
+      name = reflection.name
+      define_readers(mixin, name)
+      define_writers(mixin, name)
+    end
+
+    def self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          association(:#{name}).reader(*args)
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
+        end
+      CODE
+    end
+
+    def self.define_validations(model, reflection)
+      # noop
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# This class is inherited by the has_many and has_many_and_belongs_to_many association classes
+
+require "duck_record/associations"
+
+module DuckRecord::Associations::Builder # :nodoc:
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add]
+
+    def self.valid_options(options)
+      super + [:before_add, :after_add]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      name    = reflection.name
+      options = reflection.options
+      CALLBACKS.each { |callback_name|
+        define_callback(model, callback_name, name, options)
+      }
+    end
+
+    def self.define_extensions(model, name)
+      if block_given?
+        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&Proc.new)
+        model.parent.const_set(extension_module_name, extension)
+      end
+    end
+
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
+
+      # TODO : why do i need method_defined? I think its because of the inheritance chain
+      model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
+      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+        case callback
+        when Symbol
+          ->(_method, owner, record) { owner.send(callback, record) }
+        when Proc
+          ->(_method, owner, record) { callback.call(owner, record) }
+        else
+          ->(method, owner, record) { callback.send(method, owner, record) }
+        end
+      end
+      model.send "#{full_callback_name}=", callbacks
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,15 @@
+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/builder/singular_association.rb

@@ -0,0 +1,22 @@
+# This class is inherited by the has_one and belongs_to association classes
+
+module DuckRecord::Associations::Builder # :nodoc:
+  class SingularAssociation < Association #:nodoc:
+    def self.define_accessors(model, reflection)
+      super
+      mixin = model.generated_association_methods
+      name = reflection.name
+
+      define_constructors(mixin, name) if reflection.constructable?
+    end
+
+    # Defines the (build|create)_association methods for belongs_to or has_one association
+    def self.define_constructors(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def build_#{name}(*args, &block)
+          association(:#{name}).build(*args, &block)
+        end
+      CODE
+    end
+  end
+end

data/lib/duck_record/associations/collection_association.rb

@@ -0,0 +1,187 @@
+module DuckRecord
+  module Associations
+    # = Active Record Association Collection
+    #
+    # CollectionAssociation is an abstract class that provides common stuff to
+    # ease the implementation of association proxies that represent
+    # collections. See the class hierarchy in Association.
+    #
+    #   CollectionAssociation:
+    #     HasManyAssociation => has_many
+    #       HasManyThroughAssociation + ThroughAssociation => has_many :through
+    #
+    # The CollectionAssociation class provides common methods to the collections
+    # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
+    # the +:through association+ option.
+    #
+    # You need to be careful with assumptions regarding the target: The proxy
+    # does not fetch records from the database until it needs them, but new
+    # ones created with +build+ are added to the target. So, the target may be
+    # non-empty and still lack children waiting to be read from the database.
+    # If you look directly to the database you cannot assume that's the entire
+    # collection because new records may have been added to the target, etc.
+    #
+    # If you need to work on all current children, new and existing records,
+    # +load_target+ and the +loaded+ flag are your friends.
+    class CollectionAssociation < Association #:nodoc:
+      # Implements the reader method, e.g. foo.items for Foo.has_many :items
+      def reader
+        @_reader ||= CollectionProxy.new(klass, self)
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(records)
+        replace(records)
+      end
+
+      def reset
+        super
+        @target = []
+      end
+
+      def build(attributes = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr, &block) }
+        else
+          add_to_target(build_record(attributes)) do |record|
+            yield(record) if block_given?
+          end
+        end
+      end
+
+      # Add +records+ to this association. Returns +self+ so method calls may
+      # be chained. Since << flattens its argument list and inserts each record,
+      # +push+ and +concat+ behave identically.
+      def concat(*records)
+        records = records.flatten
+        @target.concat records
+      end
+
+      # Removes all records from the association without calling callbacks
+      # on the associated records. It honors the +:dependent+ option. However
+      # if the +:dependent+ value is +:destroy+ then in that case the +:delete_all+
+      # deletion strategy for the association is applied.
+      #
+      # You can force a particular deletion strategy by passing a parameter.
+      #
+      # Example:
+      #
+      # @author.books.delete_all(:nullify)
+      # @author.books.delete_all(:delete_all)
+      #
+      # See delete for more info.
+      def delete_all
+        @target.clear
+      end
+
+      # Removes +records+ from this association calling +before_remove+ and
+      # +after_remove+ callbacks.
+      #
+      # This method is abstract in the sense that +delete_records+ has to be
+      # provided by descendants. Note this method does not imply the records
+      # are actually removed from the database, that depends precisely on
+      # +delete_records+. They are in any case removed from the collection.
+      def delete(*records)
+        return if records.empty?
+        @target = @target - records
+      end
+
+      # Deletes the +records+ and removes them from this association calling
+      # +before_remove+ , +after_remove+ , +before_destroy+ and +after_destroy+ callbacks.
+      #
+      # Note that this method removes records from the database ignoring the
+      # +:dependent+ option.
+      def destroy(*records)
+        return if records.empty?
+        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
+        delete_or_destroy(records, :destroy)
+      end
+
+      # Returns the size of the collection by executing a SELECT COUNT(*)
+      # query if the collection hasn't been loaded, and calling
+      # <tt>collection.size</tt> if it has.
+      #
+      # If the collection has been already loaded +size+ and +length+ are
+      # equivalent. If not and you are going to need the records anyway
+      # +length+ will take one less query. Otherwise +size+ is more efficient.
+      #
+      # This method is abstract in the sense that it relies on
+      # +count_records+, which is a method descendants have to provide.
+      def size
+        @target.size
+      end
+
+      def uniq
+        @target.uniq!
+      end
+
+      # Returns true if the collection is empty.
+      #
+      # If the collection has been loaded
+      # it is equivalent to <tt>collection.size.zero?</tt>. If the
+      # collection has not been loaded, it is equivalent to
+      # <tt>collection.exists?</tt>. If the collection has not already been
+      # loaded and you are going to fetch the records anyway it is better to
+      # check <tt>collection.length.zero?</tt>.
+      def empty?
+        @target.blank?
+      end
+
+      # Replace this collection with +other_array+. This will perform a diff
+      # and delete/add only records that have changed.
+      def replace(other_array)
+        @target = other_array
+      end
+
+      def include?(record)
+        @target.include?(record)
+      end
+
+      def add_to_target(record, skip_callbacks = false, &block)
+        index = @target.index(record)
+
+        replace_on_target(record, index, skip_callbacks, &block)
+      end
+
+      def replace_on_target(record, index, skip_callbacks)
+        callback(:before_add, record) unless skip_callbacks
+
+        begin
+          if index
+            record_was = target[index]
+            target[index] = record
+          else
+            target << record
+          end
+
+          yield(record) if block_given?
+        rescue
+          if index
+            target[index] = record_was
+          else
+            target.delete(record)
+          end
+
+          raise
+        end
+
+        callback(:after_add, record) unless skip_callbacks
+
+        record
+      end
+
+      private
+
+      def callback(method, record)
+        callbacks_for(method).each do |callback|
+          callback.call(method, owner, record)
+        end
+      end
+
+      def callbacks_for(callback_name)
+        full_callback_name = "#{callback_name}_for_#{reflection.name}"
+        owner.class.send(full_callback_name)
+      end
+    end
+  end
+end