associates 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1de008a6d97d2dbf9f02295947c05d758d519191
+  data.tar.gz: 53485eb8cab825705f024869bd53c78417c441c4
+SHA512:
+  metadata.gz: 0153eb8ef6935fc08ec4de4a53d126bf441d1500b1e32662d16203f806eb43cdf5f7a995d0763ef1fe09218fa9abeb1be9e23c1a0384217c02504f8b98749cd8
+  data.tar.gz: 2a37522a4e24f6ca6c3971d147c8d02c4d736e6e930e611e7b74f1c10163440c3b92eb08564dbf81098402f9a8b5eebbbfbb76adbd5d33397c2afcc01c7b726d

data/lib/associates.rb

@@ -0,0 +1,175 @@
+require 'active_support/concern'
+
+require 'associates/version'
+require 'associates/persistence'
+require 'associates/validations'
+
+module Associates
+  extend ActiveSupport::Concern
+
+  included do
+    include ActiveModel::Model
+    include Persistence
+    include Validations
+
+    class_attribute :associates, instance_writer: false
+    self.associates = Array.new
+  end
+
+  BLACKLISTED_ATTRIBUTES = ['id', 'updated_at', 'created_at', 'deleted_at']
+
+  Item = Struct.new(:name, :klass, :attribute_names, :dependent_names, :options)
+
+  module ClassMethods
+
+    # Defines an associated model
+    #
+    # @example
+    #   class User
+    #     include Associates
+    #
+    #     associate :user, only: :username
+    #   end
+    #
+    # @param model [Symbol, Class]
+    # @param [Hash] options
+    # @option options [Symbol, Array] :only Only generate methods for the given attributes
+    #
+    # @option options [Symbol, Array] :except Generate all the model's methods except
+    #   for the given attributes
+    #
+    # @option options [Symbol] :depends_on Specify one or more associate name on
+    #   which the current associate model depends to be valid. Allow to automatically
+    #   setup `belongs_to` associations between models
+    #
+    # @option options [String, Class] :class_name Specify the class name of the associate.
+    #   Use it only if that name can’t be inferred from the associate's name
+    #
+    # @option options [Boolean] :delegate (true) Wether or not to delegate the associate's
+    #   attributes getter and setters methods to the associate instance
+    def associate(model, options = {})
+      options = {
+        delegate: true
+      }.merge(options)
+
+      associate = build_associate(model, options)
+      self.associates << associate
+
+      define_associate_delegation(associate) if options[:delegate]
+      define_associate_instance_setter_method(associate)
+      define_associate_instance_getter_method(associate)
+    end
+
+
+    private
+
+    # Builds an associate
+    #
+    # @param model [Symbol, Class]
+    # @param options [Hash]
+    # @return [Item]
+    def build_associate(model, options = {})
+      model_name             = model.to_s.underscore
+      model_klass            = (options[:class_name] || model).to_s.classify.constantize
+      dependent_models_names = extract_attributes(options[:depends_on]) || []
+      dependent_models_names = dependent_models_names.map(&:to_s)
+
+      if options[:only]
+        attribute_names = extract_attributes(options[:only])
+      else
+        excluded = BLACKLISTED_ATTRIBUTES.to_a
+
+        if options[:except]
+          excluded += extract_attributes(options[:except]).map(&:to_s)
+        end
+
+        attribute_names = model_klass.attribute_names.reject { |name| excluded.include?(name) }
+      end
+
+      # Ensure associate name don't clash with already declared ones
+      if associates.map(&:name).include?(model_name)
+        raise NameError, "already defined associate name '#{model_name}' for #{name}(#{object_id})"
+      end
+
+      # Ensure associate attribute names don't clash with already declared ones
+      if options[:delegate]
+        attribute_names.each do |attribute_name|
+          if associates.map(&:attribute_names).include?(attribute_name)
+            raise NameError, "already defined attribute name '#{attribute_name}' for #{name}(#{object_id})"
+          end
+        end
+      end
+
+      # Ensure associate dependent names exists
+      dependent_models_names.each do |dependent_name|
+        unless associates.map(&:name).include?(dependent_name)
+          raise NameError, "undefined associated model '#{dependent_name}' for #{name}(#{object_id})"
+        end
+      end
+
+      Item.new(model_name, model_klass, attribute_names, dependent_models_names, options)
+    end
+
+    # Define associated model attribute methods delegation
+    #
+    # @param associate [Item]
+    def define_associate_delegation(associate)
+      methods = [associate.attribute_names, associate.attribute_names.map { |attr| "#{attr}=" }].flatten
+      send(:delegate, *methods, to: associate.name)
+    end
+
+    # Define associated model instance setter method
+    #
+    # @example
+    #
+    #   @association.user = User.new
+    #
+    # @param associate [Item]
+    def define_associate_instance_setter_method(associate)
+      define_method "#{associate.name}=" do |object|
+        unless object.is_a?(associate.klass)
+          raise ArgumentError, "#{associate.klass}(##{associate.klass.object_id}) expected, got #{object.class}(##{object.class.object_id})"
+        end
+
+        instance = instance_variable_set("@#{associate.name}", object)
+
+        depending = associates.select { |_associate| _associate.dependent_names.include?(associate.name) }
+        depending.each do |_associate|
+          send(_associate.name).send("#{associate.name}=", instance)
+        end
+
+        instance
+      end
+    end
+
+    # Define associated model instance getter method
+    #
+    # @example
+    #
+    #   @association.user
+    #
+    # @param associate [Item]
+    def define_associate_instance_getter_method(associate)
+      define_method associate.name do
+        instance = instance_variable_get("@#{associate.name}") || instance_variable_set("@#{associate.name}", associate.klass.new)
+
+        depending = associates.select { |_associate| _associate.dependent_names.include?(associate.name) }
+        depending.each do |_associate|
+          existing = send(_associate.name).send(associate.name)
+          send(_associate.name).send("#{associate.name}=", instance) unless existing
+        end
+
+        instance
+      end
+    end
+
+    # Allow to accept single or multiple elements as arguments. Ensures a collection
+    # is always returned when there is one or more elements.
+    #
+    # @return [Nil, Array]
+    def extract_attributes(object)
+      return nil if object.blank?
+      object.is_a?(Enumerable) ? object : [object]
+    end
+  end
+end

data/lib/associates/persistence.rb

@@ -0,0 +1,35 @@
+require 'active_record'
+
+module Associates
+  module Persistence
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+    end
+
+    # Persists each associated model
+    #
+    # @return [Boolean] Wether or not all models are valid and persited
+    def save(*args)
+      return false unless valid?
+
+      ActiveRecord::Base.transaction do
+        begin
+          associates.all? do |associate|
+            send(associate.name).send(:save!, *args)
+          end
+        rescue ActiveRecord::RecordInvalid
+          false
+        end
+      end
+    end
+
+    # @return [True, ActiveRecord::RecordInvalid]
+    def save!
+      save || raise(ActiveRecord::RecordInvalid)
+    end
+  end
+end

data/lib/associates/validations.rb

@@ -0,0 +1,41 @@
+module Associates
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :valid?, :associates
+    end
+
+    module ClassMethods
+    end
+
+    # Runs the model validations plus the associated models validations and
+    # merges each messages in the errors hash
+    #
+    # @return [Boolean]
+    def valid_with_associates?(context = nil)
+      # Model validations
+      valid_without_associates?(context)
+
+      # Associated models validations
+      self.class.associates.each do |associate|
+        model = send(associate.name)
+        model.valid?(context)
+
+        model.errors.each_entry do |attribute, message|
+          # Do not include association presence validation errors
+          if associate.dependent_names.include?(attribute.to_s)
+            next
+          elsif respond_to?(attribute)
+            errors.add(attribute, message)
+          else
+            errors.add(:base, model.errors.full_messages_for(attribute))
+          end
+        end
+      end
+
+      errors.messages.values.each(&:uniq!)
+      errors.none?
+    end
+  end
+end

data/lib/associates/version.rb

@@ -0,0 +1,3 @@
+module Associates
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: associates
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Philippe Dionne
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDfDCCAmSgAwIBAgIBATANBgkqhkiG9w0BAQUFADBCMRQwEgYDVQQDDAtkaW9u
+  bmUucGhpbDEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYD
+  Y29tMB4XDTEzMDMwOTEzMjMzNVoXDTE0MDMwOTEzMjMzNVowQjEUMBIGA1UEAwwL
+  ZGlvbm5lLnBoaWwxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixk
+  ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALtGK2NoFyVX
+  seKlfHb8nuhBy8rw1nP3JVHWoyqalLs0t3axUWe6sDCgQXAOL3FtkfYPYlyX6X4s
+  FggcSySUt0PvGdas0ym/lW+sfGT6gXDBKbPvkWFNtpXaIJ8FLhqnJR2m57b8R6pf
+  VMBDka95N80Xu9NQrAesF+wW/c6ZiAON2VDsWabZEfj146y7ZvviB7pZHlPznI4W
+  GVfOk0MCl0Q60Jyk7WwNec+NA9rG7vE/dWdGOKfxU6ZJnC6drC3kBsBKkRZs+GRh
+  6XoCAsrKbRwb/ZI3A1S/J9yvq/NQ1B/U3CisBFht+CbdspeXVUDx5dffDVxnxdo/
+  w2R3wJMvD2MCAwEAAaN9MHswCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFA+69dGxvFtLxJ+aH8l4UO9yy853MCAGA1UdEQQZMBeBFWRpb25uZS5waGls
+  QGdtYWlsLmNvbTAgBgNVHRIEGTAXgRVkaW9ubmUucGhpbEBnbWFpbC5jb20wDQYJ
+  KoZIhvcNAQEFBQADggEBAD7Vpuym0VvnXOydoCBkv/w8u32Njigt3bF3i/P91108
+  aDvORUymYrPxaBe+AsSJUkJB0MHywJdMc4MF3YISelCvUFGza8LYvvUIgyVKFom+
+  TN8WCPZLo4mYaYo4sStkF/G5v8I3ruZObr7o/f20xG5r8E4ND2GEGTeFJhgpMcHO
+  Ir1uYn/LLeGG5g2EAKCdYy2XoohtcSPYApbeFQgWOGKoioQVRCDG3cHmakfVAV5M
+  DuNlzvjhWtPDwE5mYO5x5XquWQuENw78urt1aioNrIe0/15dHpDoIEDILa6zU46B
+  XDtp1YxdeVGIBuNoP1vjDSvNKYj0pMjRAEPrqK39jKE=
+  -----END CERTIFICATE-----
+date: 2013-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+description: Associate multiple models together and make them behave as one.
+email:
+- dionne.phil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/associates.rb
+- lib/associates/persistence.rb
+- lib/associates/validations.rb
+- lib/associates/version.rb
+homepage: https://github.com/phildionne/associates
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: Associate multiple models together and make them behave as one.
+test_files: []
+has_rdoc: