index_tree 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 331b4073422929cabfbb5292d94d11bd1aca0e80
+  data.tar.gz: 20958ba592b248ed9137ddac5b72f9f2f1b8cc89
+SHA512:
+  metadata.gz: 7f0b87af9ac9a7d5be4921f588464bec77655f1abb75ebefa7f38bf63fc9c4cf14897b940941defdf89b56c6f79565e9fa4f3c5fab398c35542f9fae0bc3aa4d
+  data.tar.gz: 18ea0a9f0a72749582ba0bd6713e104d7ff577819afc49526070078de54a1353ab40563812f8349c7457d7aa3a071ec07fd8b8af4b1a073c73e0bcf6df2d16b0

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/.idea
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Natural-Intelligence
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Natural Intelligence
+
+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,99 @@
+# IndexTree
+
+This Gem eager loads trees by indexing the nodes of the tree. The number of queries needed to load a tree is N, 
+when N is the number of different models(ActiveRecords) in the tree.
+
+Each inner object in the tree have an index node instance that is connecting it to the root.
+When the root of the tree is loaded, only the objects that are in the tree are fetched(Pruning).
+The index nodes are created when the root element is saved.
+
+Example:
+
+    class Equation
+        acts_as_indexed_node :root => true do
+            has_many :expressions
+        end
+      
+        has_one :not_tree_association_a
+    end
+    
+    
+    class Expression
+        acts_as_indexed_node do
+            has_many :expressions
+        end
+        
+        has_one :not_tree_association_b
+    end
+        
+                     +----------+                                         +----------+
+                     |Equation 1|                                         |Equation 2|
+                     +-+------+-+                                         +-+------+-+
+                       |      |                                             |      |
+               +-------+      +-------+                             +-------+      +-------+
+               |                      |                             |                      |
+               v                      v                             v                      v
+         +-----------+          +-----------+                 +-----------+          +-----------+
+         |Expression1|          |Expression2|                 |Expression5|          |Expression6|
+         +-----------+          +-+-------+-+                 +-----------+          +-+-------+-+
+                                  |       |                                            |       |
+                          +-------+       +-------+                            +-------+       +-------+
+                          |                       |                            |                       |
+                          v                       v                            v                       v
+                    +-----------+           +-----------+                +-----------+           +-----------+
+                    |Expression3|           |Expression4|                |Expression7|           |Expression8|
+                    +-----------+           +-----------+                +-----------+           +-----------+
+    
+The following statement fetches only the objects in the Equation1 tree in two queries:    
+      
+    Equation.find(1).preload_tree
+    
+One query to fetch Equations, and the second query is to fetch Expressions(Doesn't matter how deep is the tree it is still one query)
+    
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'index_tree'
+```
+
+And then execute:
+
+    $ bundle
+    $ rake db:migrate 
+    
+There is a migration which creates index_tree_index_node table
+
+## Declaration
+
+All the models should be loaded in the Rails application, before using the preload_tree.
+
+    class RootNode < ActiveRecord::Base
+       acts_as_indexed_node :root => true do
+         has_many :child_nodes, dependent: :destroy
+       end
+    end
+    
+### The following associations are supported:
+ 
+     belongs_to
+     belongs_to :class, polymorphic: true
+     has_one
+     has_many
+
+### The following types of inheritance are supported:
+    
+    STI 
+    Polymorphic associations
+    
+### Options:
+
+    :root   Used to declare a root model(default is false)
+        
+## Usage
+
+    RootModel.find(1).preload_tree
+    RootModel.all.preload_tree
+    RootModel.where(color: 'red').all.preload_tree

data/Rakefile

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

data/app/models/index_node.rb

@@ -0,0 +1,7 @@
+# Used to for indexing the nodes in tree
+module IndexTree
+  class IndexNode < ActiveRecord::Base
+    belongs_to :root_element, polymorphic: true
+    belongs_to :node_element, polymorphic: true
+  end
+end

data/db/migrate/20141004075233_create_index_tree_index_nodes.rb

@@ -0,0 +1,9 @@
+class CreateIndexTreeIndexNodes < ActiveRecord::Migration
+  def change
+    create_table :index_tree_index_nodes do |t|
+      t.references :root_element, polymorphic: true, :null => false
+      t.references :node_element, polymorphic: true, :null => false
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20141004075333_add_index_to_tree_index_nodes.rb

@@ -0,0 +1,5 @@
+class AddIndexToTreeIndexNodes < ActiveRecord::Migration
+  def change
+    add_index :index_tree_index_nodes, [:root_element_id, :root_element_type], :name => 'index_index_tree_index_nodes_on_root_element'
+  end
+end

data/index_tree.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'index_tree/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "index_tree"
+  spec.version       = IndexTree::VERSION
+  spec.authors       = ["Alex Stanovsky"]
+  spec.email         = %w(info@naturalint.com)
+  spec.homepage      = 'http://www.naturalint.com'
+
+  spec.description   = %q{Eager loads trees by indexing the nodes of the tree. The number of queries needed to load a tree is N,
+when N is number of different models(ActiveRecords) in the tree}
+
+  spec.summary       = %q{This Gem eager loads trees by indexing the nodes of the tree. The number of queries needed to load a tree is N,
+when N is number of different models(ActiveRecords) in the tree.
+Each inner object in the tree have an index node instance that is connecting it to the root.
+When the root of the tree is loaded, only the objects that are in the tree are fetched(Pruning).
+The index nodes are created when the root element is saved.}
+
+  spec.files         = `git ls-files`.split($/)
+  spec.require_paths = %w(lib app)
+
+  spec.add_dependency "activerecord"
+end

data/lib/index_tree/acts_as_indexed_node.rb

@@ -0,0 +1,20 @@
+module IndexTree
+  module ActsAsIndexedNode
+    def acts_as_indexed_node(options={}, &block)
+      if options[:root]
+        include IndexTree::RootElement
+      else
+        include IndexTree::NodeElement
+      end
+
+      # Find what associations were defined in the given block
+      # And set the child nodes
+      if block_given?
+        current_associations = reflections.keys
+        yield
+        associations_in_block = reflections.keys - current_associations
+        child_nodes *associations_in_block
+      end
+    end
+  end
+end

data/lib/index_tree/engine.rb

@@ -0,0 +1,14 @@
+# Rails Engine copies the migration to the Rails app
+module IndexTree
+  class Engine < Rails::Engine
+    isolate_namespace IndexTree
+
+    initializer :append_migrations do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+  end
+end

data/lib/index_tree/finder_methods.rb

@@ -0,0 +1,33 @@
+# Adds a preload_tree method to the model
+# Usage example:
+#
+#     Model.find(1).preload_tree
+#
+module IndexTree
+  module FinderMethods
+    extend ActiveSupport::Concern
+
+    included do
+      def preload_tree
+        return IndexTree::TreePreloader.preload_entities(self)
+      end
+
+    end
+  end
+end
+
+
+# Add a preload_tree method to the ActiveRecord_Relation
+# Usage example:
+#
+#     Model.where(level: 2).all.preload_tree
+#     Model.all.preload_tree
+#
+module ActiveRecord
+  class Relation
+    def preload_tree
+      load unless loaded?
+      return IndexTree::TreePreloader.preload_entities(@records)
+    end
+  end
+end

data/lib/index_tree/node_element.rb

@@ -0,0 +1,59 @@
+require 'active_support/concern'
+
+module IndexTree
+  module NodeElement
+    extend ActiveSupport::Concern
+
+    included do
+      # Pointer to the index node
+      has_one :index_tree_index_node, :class_name => 'IndexTree::IndexNode', as: :node_element
+
+      # Creates index node for current tree node, and invokes index node creation for each defined association
+      # @param [root_element] Id of the root
+      def create_index_node(root_element)
+        IndexTree::IndexNode.create!(:root_element => root_element, :node_element => self)
+        create_index_nodes_for_children(root_element)
+      end
+
+      private
+
+      class_attribute :child_nodes
+
+      # Empty default value
+      self.child_nodes = {}
+
+      # Define what associations are child nodes
+      # It will be used to create Index nodes when the root element will be saved
+      # @param [*attributes] list of associations
+      def self.child_nodes(*attributes)
+        self.child_nodes = valid_associations(attributes)
+      end
+
+      # @return [valid_associations] map with existing associations
+      def self.valid_associations(attributes)
+        valid_associations = {}
+
+        # Check if the declared input is an existing association
+        Array(attributes).each do |association_name|
+          valid_associations[association_name] = reflections[association_name] if reflections[association_name]
+        end
+
+        return valid_associations
+      end
+
+      # Invoke index node creation for children node
+      # @param [root_element] id of the root element
+      def create_index_nodes_for_children(root_element)
+
+        self.child_nodes.keys.each do |association_name|
+          association_value = send(association_name)
+
+          Array(association_value).each do |child_node|
+            child_node.create_index_node(root_element)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/index_tree/railtie.rb

@@ -0,0 +1,8 @@
+# Defines the ActsAssTreeNode Method
+module IndexTree
+  class Railtie < Rails::Railtie
+    ActiveSupport.on_load(:active_record) do
+      extend IndexTree::ActsAsIndexedNode
+    end
+  end
+end

data/lib/index_tree/root_element.rb

@@ -0,0 +1,82 @@
+require 'active_support/concern'
+
+# Defines the root element of the tree, it invokes the recursive index nodes creation.
+# And Hold the structure of the tree
+module IndexTree
+  module RootElement
+    extend ActiveSupport::Concern
+    include IndexTree::FinderMethods
+    include IndexTree::NodeElement
+
+    included do
+      has_many :index_tree_index_nodes, :class_name => 'IndexTree::IndexNode', as: :root_element, dependent: :destroy
+
+      after_save :rebuild_index_nodes
+
+      private
+      # Will rebuild the index nodes for the decision tree of the Root element
+      # It will be used in the eager load for fetching only the data that is related to the current Root Element
+      def rebuild_index_nodes
+        # Delete all old indices
+        IndexTree::IndexNode.delete_all({:root_element => self})
+
+        # Creates index node for the current tree node, and invokes recursive call for the children of the node
+        create_index_nodes_for_children(self)
+      end
+
+      # @return [tree_structure] Each Root Element hold the structure of the tree
+      def self.tree_structure
+        @@tree_structure ||= create_tree_structure({}, self)
+      end
+
+      # Recursive function that create the structure of the tree
+      # Iterates each tree node relation and creates a loading instruction
+      # @param [loaded_associations] Previous associations
+      # @param [class_to_load] Current class association
+      def self.create_tree_structure(loaded_associations, class_to_load)
+        class_to_load.child_nodes.each do |association_name, association|
+          get_all_child_classes(association).each do |child_class|
+
+            if (loaded_associations[class_to_load].nil? || loaded_associations[class_to_load][child_class].nil?)
+              loaded_associations[class_to_load] ||= {}
+
+              if association.macro == :belongs_to
+                loaded_associations[class_to_load][child_class] = {many: false, opposite: false, association_name: association_name, polymorphic: association.polymorphic?}
+              elsif association.macro == :has_one
+                loaded_associations[class_to_load][child_class] = {many: false, opposite: true, association_name: association_name, polymorphic: association.polymorphic? }
+              elsif association.macro == :has_many
+                loaded_associations[class_to_load][child_class] = {many: true, opposite: true, association_name: association_name, polymorphic: association.polymorphic?}
+              end
+
+              create_tree_structure(loaded_associations, child_class)
+            end
+          end
+        end
+
+        return loaded_associations
+      end
+
+      # Return all the classes for current association
+      # @param [association]
+      def self.get_all_child_classes(association)
+        if (association.polymorphic?)
+          return find_all_polymorphic_classes(association.name)
+        else
+          return Array(association.klass)
+        end
+      end
+
+      # Find all the classes from the polymorphic type
+      # @param [polymorphic_class] type to find
+      def self.find_all_polymorphic_classes(polymorphic_class)
+        ret = []
+        ObjectSpace.each_object(Class).select { |klass| klass < ActiveRecord::Base }.each do |i|
+          unless i.reflect_on_all_associations.select { |j| j.options[:as] == polymorphic_class }.empty?
+            ret << i
+          end
+        end
+        ret.flatten
+      end
+    end
+  end
+end

data/lib/index_tree/tree_preloader.rb

@@ -0,0 +1,68 @@
+module IndexTree
+  module TreePreloader
+    def self.preload_entities(root_entities)
+
+      root_entities_array = Array(root_entities)
+      root_entity_class = root_entities_array.first.class
+
+      cache = {root_entity_class =>
+                   Hash[root_entities_array.map { |t| [t.id, t] }]}
+
+      tree_structure = root_entity_class.tree_structure
+
+      tree_structure.each do |source_class, target_classes|
+        target_classes.each do |target_class, load_instruction|
+          preload_class(cache, root_entity_class, source_class)
+          preload_class(cache, root_entity_class, target_class)
+
+          if load_instruction[:opposite]
+            associate_entities_opposite(cache, source_class, load_instruction[:association_name], target_class, load_instruction[:many])
+          else
+            associate_entities(cache, source_class, load_instruction[:association_name], target_class, load_instruction[:polymorphic])
+          end
+        end
+      end
+
+      return root_entities
+    end
+
+    def self.preload_class(cache, root_entity_class, class_to_load)
+      unless cache.has_key?(class_to_load)
+        cache[class_to_load] = Hash[class_to_load.joins(:index_tree_index_node).where(:index_tree_index_nodes => {:root_element_type => cache[root_entity_class].values.first.class,
+                                                                                                                  :root_element_id => cache[root_entity_class].keys}).all.map { |t| [t.id, t] }]
+      end
+    end
+
+    def self.associate_entities(cache, source_class, association_name, target_class, is_polymorphic)
+      cache[source_class].values.each do |source_entity|
+        if (is_polymorphic)
+          parent_type = source_entity.send(association_name.to_s + '_type')
+          next unless  parent_type == target_class.to_s
+        end
+
+        parent_id = source_entity.send(association_name.to_s + '_id')
+        source_entity.association(association_name).target = cache[target_class][parent_id]
+        source_entity.association(association_name).loaded!
+      end
+    end
+
+    def self.associate_entities_opposite(cache, source_class, association_name, target_class, many)
+      cache[target_class].values.each do |target_entity|
+        attr_name = source_class.model_name.element + '_id'
+        parent_id = target_entity.send(attr_name)
+        if (parent_id)
+          if (many)
+            cache[source_class][parent_id].association(association_name).target << target_entity
+          else
+            cache[source_class][parent_id].association(association_name).target = target_entity
+          end
+        end
+      end
+
+      cache[source_class].values.each do |source_entity|
+        source_entity.association(association_name).loaded!
+      end
+    end
+
+  end
+end

data/lib/index_tree/version.rb

@@ -0,0 +1,3 @@
+module IndexTree
+  VERSION = "0.0.1"
+end

data/lib/index_tree.rb

@@ -0,0 +1,18 @@
+require "index_tree/version"
+require "index_tree/engine"
+
+
+require 'index_tree/finder_methods'
+require 'index_tree/node_element'
+require 'index_tree/root_element'
+require 'models/index_node'
+require 'index_tree/tree_preloader'
+
+require 'index_tree/acts_as_indexed_node'
+require 'index_tree/railtie'
+
+module IndexTree
+  def self.table_name_prefix
+    'index_tree_'
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: index_tree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Stanovsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Eager loads trees by indexing the nodes of the tree. The number of queries needed to load a tree is N,
+  when N is number of different models(ActiveRecords) in the tree
+email:
+- info@naturalint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/models/index_node.rb
+- db/migrate/20141004075233_create_index_tree_index_nodes.rb
+- db/migrate/20141004075333_add_index_to_tree_index_nodes.rb
+- index_tree.gemspec
+- lib/index_tree.rb
+- lib/index_tree/acts_as_indexed_node.rb
+- lib/index_tree/engine.rb
+- lib/index_tree/finder_methods.rb
+- lib/index_tree/node_element.rb
+- lib/index_tree/railtie.rb
+- lib/index_tree/root_element.rb
+- lib/index_tree/tree_preloader.rb
+- lib/index_tree/version.rb
+homepage: http://www.naturalint.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- app
+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.2.2
+signing_key: 
+specification_version: 4
+summary: This Gem eager loads trees by indexing the nodes of the tree. The number
+  of queries needed to load a tree is N, when N is number of different models(ActiveRecords)
+  in the tree. Each inner object in the tree have an index node instance that is connecting
+  it to the root. When the root of the tree is loaded, only the objects that are in
+  the tree are fetched(Pruning). The index nodes are created when the root element
+  is saved.
+test_files: []