relation_builder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a7965b9fa26cb3ba5dfe81e8d31d91c4b10b872
+  data.tar.gz: 80e5e297a97bb39f0c80beba994829fca037c026
+SHA512:
+  metadata.gz: 317cdd2b155b97d52e459e8d7e862278eee786b9ae5f10b728de3a936a157a4c55bcae495671de10b0a15ef6f4df4aa538c95e9b7861c5da27c9c04824142c43
+  data.tar.gz: 8212149aff8c94d530f5b41f93b2bc16a9f4515e26b6fb32dd21e53a4122238a330e9998aebd338ed24903fd3bf63112fca28b6bce377df935be8142cb732b17

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea/*
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in relation_builder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Ivan Zabrovskiy
+
+MIT License
+
+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,102 @@
+# RelationBuilder
+
+This is a gem for easy build of nested relations through options of initialize
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'relation_builder'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install relation_builder
+
+## Usage
+
+### Examples
+
+Old style of initialize several nested objects:
+
+```ruby
+building = Building.new(params)
+flat = Flat.new
+room = Room.new
+bathroom = Bathroom.new
+flat.rooms << room
+flat.bathroom = bathroom
+building.flats << flat
+```
+
+Initializing with relation_builder:
+
+```ruby
+building = Building.new(params, auto_build_relations: {flats: [:rooms, :bathroom]})
+```
+
+### How to install?
+
+In additions to `gem instal` you need to
+
+```ruby
+include RelationBuilder::InitializeOptions
+```
+
+into all models involved in nested build.
+
+## Strategy of relations build
+
+There is two strategy: "nested" and "build". They can be specified by passing
+`build_strategy: :build/:nested` into options of initialize.
+Bydefault using `:nested` strategy.
+
+### 'Nested' strategy
+
+It use [nested_attributes](http://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html)
+for build nested relations. If you have semifiled params. For example, in params you have attributes for building,
+flat and room. And suppose that in any case you want to have a bathroom. So you can say same thig as in previous
+ example:
+
+```ruby
+building = Building.new(params, auto_build_relations: {flat: [:room, :bathroom]})
+```
+
+Here you keep all attributes of nested models extracted from params.
+And additionally in any case for each flat you get a bathroom.
+
+### 'Build' strategy
+
+It based on simple build association. It cat be useful if you doesn't want to have a deal with
+[nested_attributes](http://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html).
+This strategy has same syntax with `auto_build_relations` key, but have several restrictions.
+
+Positive moments:
+
+* you can build a relations for [ActiveRecord](http://www.rubydoc.info/gems/activerecord/) and
+for [Mongoid](https://github.com/mongoid/mongoid).
+
+Negative moments:
+
+* this strategy can't build rest of nesting relation, only full chain, i.e. this strategy is incompatible with
+[nested_attributes](http://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html).
+
+## Purpose
+
+One of aim of this gem is easy way to deal with [formtastic](https://github.com/justinfrench/formtastic) form.
+If you want to make a form with several nested object you must initialize all objects before send them
+into the form. Otherwise you can't see any fields of nested object on the form. For many nested obeject it can be
+annoying.
+
+## Contributing
+
+1. Fork it ( https://github.com/Loriowar/relation_builder/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/relation_builder/ext_deep_merge.rb

@@ -0,0 +1,27 @@
+module RelationBuilder
+  module ExtDeepMerge
+    # Alternative for native method of Hash
+    # It call block for any coincide keys even if values is Hash too
+    def ext_deep_merge(other_hash, &block)
+      dup.ext_deep_merge!(other_hash, &block)
+    end
+
+    # Same as +ext_deep_merge+, but modifies +self+.
+    def ext_deep_merge!(other_hash, &block)
+      other_hash.each_pair do |current_key, other_value|
+        this_value = self[current_key]
+        self[current_key] =
+            if block_given? && key?(current_key)
+              block.call(current_key, this_value, other_value)
+            else
+              if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+                this_value.ext_deep_merge(other_value, &block)
+              else
+                other_value
+              end
+            end
+      end
+      self
+    end
+  end
+end

data/lib/relation_builder/initialize_options.rb

@@ -0,0 +1,157 @@
+module RelationBuilder
+  module InitializeOptions
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :initialize, :build_relation
+    end
+
+  private
+
+    # Chain initialize method for support additional options
+    def initialize_with_build_relation(new_attributes = nil, options = {})
+      # relation build strategy:
+      #   nested - using nested_attributes
+      #   build  - using standard build method
+      nested_build_strategy = options[:build_strategy] || :nested
+      processed_attributes = new_attributes || {}
+      auto_build_relation_list = options.delete(:auto_build_relations)
+
+      if nested_build_strategy == :nested && auto_build_relation_list.present?
+        nested_relations_attributes = create_nested_options(auto_build_relation_list)
+        processed_attributes = nested_deep_merge(processed_attributes, nested_relations_attributes)
+      end
+
+      # store return value to save default behaviour of initialize
+      ret_val = initialize_without_build_relation(processed_attributes, options)
+
+      if nested_build_strategy == :build && auto_build_relation_list.present?
+        if auto_build_relation_list.is_a?(Array)
+          auto_build_relation_list.each do |rel|
+            build_relation_with_options(rel)
+          end
+        elsif auto_build_relation_list.is_a?(Hash)
+          auto_build_relation_list.each do |rel, nested_options|
+            build_relation_with_options(rel, auto_build_relations: nested_options)
+          end
+        elsif auto_build_relation_list.is_a?(Symbol) || auto_build_relation_list.is_a?(String)
+          build_relation_with_options(auto_build_relation_list)
+        end
+      end
+
+      ret_val
+    end
+
+    # Get onformation about relation
+    def reflection_for(method)
+      if self.class.respond_to?(:reflect_on_association)
+        self.class.reflect_on_association(method)
+      elsif self.class.respond_to?(:associations) # MongoMapper uses the 'associations(method)' instead
+        self.class.associations[method]
+      end
+    end
+
+    # Build relation based on type of it
+    def build_relation_with_options(rel, options = {})
+      reflection = reflection_for(rel)
+      if reflection.present?
+        relation = instance_eval(rel.to_s)
+        if %i(has_and_belongs_to_many
+                  has_many
+                  references_and_referenced_in_many
+                  references_many).include?(reflection.macro)
+          if relation.blank?
+            relation << reflection.klass.new({}, options)
+          end
+        else
+          if relation.blank?
+            self.send("#{rel}=", reflection.klass.new({}, options))
+          end
+        end
+      end
+    end
+
+    # Create nested Hash with attributes for using in nested_attributes
+    # Example:
+    #   input:  {versions:
+    #             {doc_kit_source: [:source, :author]},
+    #              product: :project}
+    #   Output: {versions_attributes:
+    #             {doc_kit_source_attributes:
+    #               {source_attributes: {},
+    #                author_attributes: {}
+    #               }
+    #             },
+    #            product_attributes:
+    #             {project_attributes: {}}
+    #           }
+    #
+    def create_nested_options(build_options)
+      new_attributes = {}
+      if build_options.is_a?(Hash)
+        build_options.each do |required_rel, nested_rels|
+          new_attributes.merge!(rel_name_to_nested_attrs(required_rel))
+          nested_key = to_nested_attributes_key(required_rel)
+          if nested_rels.is_a?(Symbol)
+            new_attributes[nested_key].merge!(rel_name_to_nested_attrs(nested_rels))
+          elsif nested_rels.is_a?(Array)
+            nested_rels.each do |nested_rel|
+              new_attributes[nested_key].merge!(rel_name_to_nested_attrs(nested_rel))
+            end
+          elsif nested_rels.is_a?(Hash)
+            new_attributes[nested_key].merge!(create_nested_options(nested_rels))
+          end
+        end
+      end
+
+      new_attributes
+    end
+
+    # Generate key-name for nested_attributes from relation name
+    def to_nested_attributes_key(relation_name)
+      "#{relation_name}_attributes".to_sym
+    end
+
+    # Hash for passing into nested_attributes for build single relation
+    def rel_name_to_nested_attrs(relation_name)
+      {to_nested_attributes_key(relation_name) => {}}
+    end
+
+    # Merge of initialize params and additional options for build relations through nested_attributes
+    def nested_deep_merge(master, slave)
+      # Add alternative deep_merge method for instance of Hash
+      extend_deep_merge = ->(obj){obj.send(:extend, RelationBuilder::ExtDeepMerge) unless master.is_a? RelationBuilder::ExtDeepMerge; obj}
+
+      extend_deep_merge.call(master)
+      extend_deep_merge.call(slave)
+
+      # extend_deep_merge call block for any coincide keys
+      master.ext_deep_merge(slave) do |_, master_val, slave_val|
+        # special processing of attributes for has_many relation (see nested_attributes documentation for details)
+        if master_val.is_a?(Hash) && master_val.all?{|k, _| key_is_numeric?(k)}
+          extend_deep_merge.call(master_val)
+          master_val.inject(extend_deep_merge.call({})) do |h, (inner_key, value)|
+            h[inner_key] = nested_deep_merge(value, slave_val)
+            h
+          end
+        elsif master_val.is_a?(Hash) && slave_val.is_a?(Hash)
+          extend_deep_merge.call(master_val)
+          extend_deep_merge.call(slave_val)
+
+          nested_deep_merge(master_val, slave_val)
+        else
+          master_val
+        end
+      end
+    end
+
+    def key_is_numeric?(key)
+      !(key =~ /^\d+$/).nil?
+    end
+
+    module ClassMethods
+      # stub
+    end
+
+  end
+end

data/lib/relation_builder/version.rb

@@ -0,0 +1,3 @@
+module RelationBuilder
+  VERSION = '0.1.0'
+end

data/lib/relation_builder.rb

@@ -0,0 +1,13 @@
+require 'relation_builder/version'
+
+module RelationBuilder
+  extend ActiveSupport::Autoload
+
+  autoload :InitializeOptions
+  autoload :ExtDeepMerge
+
+  eager_autoload do
+    autoload :InitializeOptions
+    autoload :ExtDeepMerge
+  end
+end

data/relation_builder.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'relation_builder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "relation_builder"
+  spec.version       = RelationBuilder::VERSION
+  spec.authors       = ["Ivan Zabrovskiy"]
+  spec.email         = ["loriowar@gmail.com"]
+  spec.summary       = %q{This is a gem for easy build of nested relations through options of initialize}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/Loriowar/relation_builder"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 3.2"
+  spec.add_dependency "activesupport", ">= 3.2"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: relation_builder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ivan Zabrovskiy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-06 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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: This is a gem for easy build of nested relations through options of initialize
+email:
+- loriowar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/relation_builder.rb
+- lib/relation_builder/ext_deep_merge.rb
+- lib/relation_builder/initialize_options.rb
+- lib/relation_builder/version.rb
+- relation_builder.gemspec
+homepage: https://github.com/Loriowar/relation_builder
+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.0.2
+signing_key: 
+specification_version: 4
+summary: This is a gem for easy build of nested relations through options of initialize
+test_files: []
+has_rdoc: