dependency-trees 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c20c45337081f03a157d37fc0b7c2b4238277ef3fa6c8155fa5dec1aec5916f7
-  data.tar.gz: 0fba9959ca1e48e1693dca3905f90c54f81e3482dac5a8e8721f0c54d343c828
+  metadata.gz: a95942acda2903ecafc6c223b9e8c5716e171b793555f35e4e55c06bee826896
+  data.tar.gz: 8bff4a9cb8a3d22beabcec9c13c5f376743b50e59c58b9b4af96e102150388f4
 SHA512:
-  metadata.gz: '08e214e775fd74f4e80842fcc0a98cf17ad38c12840e773f5774342abb27040cb4ac6be3e0b39d95a3d5eed0a9d702238d76924b37da9fb85efa6135e58117e4'
-  data.tar.gz: f89fec9da74ad3174431ab5fd42ea27e75d1cf9458cc5867548178705da4cbcc317cc982e37d3bdca7c6851d3b325a925ed6b8c9623cbdca2d658af8b97ae229
+  metadata.gz: 391abe1bc060f9903662e9018541bc56c570f32bc7ad36ca92415269cf1034661a5a585e05c995ea2aa0bd551ab0ef887a4b16caf2296e61ec6b20d703799b56
+  data.tar.gz: 804a67f7345afd4a70fc34569c3ddd52d497d718cb74dd0fcf482867ce834ea3ef13183fe5bd62f61ee714a860fc0a783e0fbb78219ff43d7e1cf199a7f427f9

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+gemspec

data/dependency-trees.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+  s.name                  = 'dependency-trees'
+  s.version               = '0.0.4'
+  s.summary               = 'Tool for better visualizing and managing dependencies'
+  s.authors               = ['Karol Selak']
+  s.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  s.files                 = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  s.executables           = Dir.glob('bin/*').map { |f| File.basename(f) }
+  s.require_paths         = ["lib"]
+  s.license               = 'MIT'
+
+  s.add_dependency 'activerecord'
+  s.add_dependency 'pg'
+  s.add_dependency 'pry'
+  s.add_dependency 'rails'
+
+  s.add_dependency 'bootsnap'
+  s.add_dependency 'tzinfo-data'
+
+  s.add_development_dependency 'brakeman'
+  s.add_development_dependency 'byebug'
+  s.add_development_dependency 'factory_bot'
+  s.add_development_dependency 'rspec-rails'
+  s.add_development_dependency 'listen'
+  s.add_development_dependency 'rubocop', '~> 0.75.1'
+  s.add_development_dependency 'rubocop-rspec'
+  s.add_development_dependency 'database_cleaner-active_record'
+end

data/lib/dependency-trees.rb

@@ -0,0 +1 @@
+require 'ids_of_all_dependencies.rb'

data/lib/id_hash.rb

@@ -0,0 +1,97 @@
+# require 'model'
+
+class HashOfArrays < Hash
+  def initialize(hash = {})
+    hash.each do |key, array|
+      self[key] = hash[key].clone
+    end
+  end
+
+  def clone
+    self.class.new(self)
+  end
+
+  def subtract(hash)
+    result = self.clone
+    hash.each do |key, array|
+      next if result[key].nil?
+
+      array.each do |el|
+        result[key].delete(el)
+      end
+
+      result.delete(key) if result[key].empty?
+    end
+    result
+  end
+
+  def add(key, *values)
+    self[key] = [] if self[key].nil?
+    self[key].concat(values)
+  end
+
+  def self.join(*hashes)
+    result = self.new
+    result.join(*hashes)
+  end
+
+  def join(*hashes)
+    hashes.each do |hash|
+      hash.each do |key, array|
+        self.add(key, *array)
+      end
+    end
+    self
+  end
+
+  def sort_arrays!
+    self.each do |key, array|
+      array.sort!
+    end
+  end
+end
+
+class IdHash < HashOfArrays
+  def add(key, *values)
+    super(key, *values)
+    self[key].uniq!
+    self
+  end
+
+  # def with_table_symbols
+  #   result = HashOfArrays.new
+
+  #   self.each do |name, ids|
+  #     symbol = Model.get_model(name).table_name.to_sym
+  #     result[symbol] = ids
+  #   end
+
+  #   result
+  # end
+
+  # def remove_entries_from_db(as_first: [], as_last: [])
+  #   exceptionals = as_first + as_last
+  #   remove_from_exceptional(as_first)
+
+  #   self.each do |name, ids|
+  #     next if exceptionals.include?(name)
+  #     remove_entries_from_array(name, ids)
+  #   end
+
+  #   remove_from_exceptional(as_last)
+  # end
+
+  # private
+
+  # def remove_from_exceptional(array)
+  #   array.each do |name|
+  #     ids = self[name]
+  #     remove_entries_from_array(name, ids)
+  #   end
+  # end
+
+  # def remove_entries_from_array(model_name, ids)
+  #   model = Model.get_model(model_name)
+  #   model.delete(ids) if model.present?
+  # end
+end

data/lib/ids_of_all_dependencies.rb

@@ -0,0 +1,330 @@
+require 'id_hash'
+
+module SymbolsOfAllDirectDependencies
+  def symbols_of_all_direct_dependencies
+    self.class.reflect_on_all_associations.map do |association|
+      next if association.macro == :belongs_to
+
+      association.name
+    end.compact
+  end
+end
+
+module IdsOfAllDirectDependencies
+  include SymbolsOfAllDirectDependencies
+
+  def ids_of_all_direct_dependencies
+    result = IdHash.new
+
+    self.class.reflect_on_all_associations.map do |association|
+      next if association.macro == :belongs_to
+
+      symbol = association.klass.name.underscore.to_sym
+      self.send(association.name).map do |associated_object|
+        result.add(symbol, associated_object.id)
+      end
+    end
+
+    result
+  end
+end
+
+module IdsOfAllDependenciesNested
+  def ids_of_all_dependencies_nested(depth = Float::INFINITY)
+    result = depth > 0 ? get_associations(depth) : {}
+    result[:id] = id
+    result = result[:id] if result.size == 1
+    result
+  end
+
+  private
+
+  def get_associations(depth)
+    result = {}
+
+    self.class.reflect_on_all_associations.map do |association|
+      next if association.macro == :belongs_to
+
+      symbol = association.klass.name.underscore.to_sym
+      self.send(association.name).sort_by(&:id).map do |associated_object|
+        result[symbol] = [] if result[symbol].nil?
+        result[symbol] << associated_object.ids_of_all_dependencies_nested(depth - 1)
+      end
+    end
+
+    result
+  end
+end
+
+module DependencyTree
+  class Tree < Hash
+    def initialize(hash={})
+      hash.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def ids_tree
+      self_cloned = self.deep_tree_clone
+      self_cloned.delete_key_recursive(:instance)
+    end
+
+    def status_tree
+      self_cloned = self.deep_tree_clone
+
+      self_cloned.do_recursive do |tree|
+        begin
+          tree[:instance].reload
+          tree[:status] = 'present'
+        rescue ActiveRecord::RecordNotFound => e
+          tree[:status] = 'removed'
+        end
+
+        tree.delete(:instance)
+      end
+    end
+
+    def status_tree_condensed
+      result = status_tree.do_recursive do |tree|
+        tree.each do |name, array|
+          next unless array.class == Array
+
+          new_array = array.map do |subtree|
+            next subtree.root_duplicate_summary if subtree[:duplicate]
+            next subtree if subtree.class != Tree || subtree.size > 2
+
+            subtree.root_summary
+          end
+
+          array.clear
+          array.concat(new_array)
+        end
+      end
+
+      result.do_recursive do |tree|
+        tree[:_] = tree.root_summary
+        tree.delete(:id)
+        tree.delete(:status)
+        tree.last_to_beginning!
+      end
+    end
+
+    def last_to_beginning!
+      arr = self.to_a
+      arr.unshift(arr.pop)
+      self.clear
+      self.merge!(arr.to_h)
+    end
+
+    def root_summary
+      "id #{self[:id]}, #{self[:status]}"
+    end
+
+    def root_duplicate_summary
+      root_summary + ", duplicate"
+    end
+
+    def deep_tree_clone
+      hash = self.clone.map do |key, array|
+        next [key, array] unless array.class == Array
+
+        new_array = array.map do |subtree|
+          if subtree.class == Tree
+            subtree.deep_tree_clone
+          else
+            subtree
+          end
+        end
+
+        [key, new_array]
+      end
+
+      Tree.new(hash)
+    end
+
+    def delete_key_recursive(key)
+      call_method_recursive(:delete, key)
+    end
+
+    def call_method_recursive(method, *args, &block)
+      do_recursive do |tree|
+        tree.send(method, *args, &block)
+      end
+    end
+
+    def do_recursive(&block)
+      block.call(self)
+
+      self.each do |key, array|
+        next unless array.is_a? Array
+
+        array.each do |subtree|
+          subtree.do_recursive(&block) if subtree.is_a? Tree
+        end
+      end
+
+      self
+    end
+  end
+
+  def dependency_tree(depth = Float::INFINITY, hash_for_duplication_check = IdHash.new)
+    is_duplicate = hash_for_duplication_check[self.class]&.include?(id)
+    hash_for_duplication_check.add(self.class, id)
+    shoud_go_deeper = depth > 0 && !is_duplicate
+    result = shoud_go_deeper ? get_associations_for_tree(depth, hash_for_duplication_check) : Tree.new
+    result[:id] = id
+    result[:instance] = self
+    result[:duplicate] = true if is_duplicate
+    result
+  end
+
+  private
+
+  def get_associations_for_tree(depth, hash_for_duplication_check)
+    result = Tree.new
+
+    self.class.reflect_on_all_associations.map do |association|
+      next if association.macro == :belongs_to
+
+      symbol = association.klass.name.underscore.to_sym
+      self.send(association.name).sort_by(&:id).map do |associated_object|
+        result[symbol] = [] if result[symbol].nil?
+        result[symbol] << associated_object.dependency_tree(depth - 1, hash_for_duplication_check)
+      end
+    end
+
+    result
+  end
+end
+
+module IdsOfAllDependencies
+  include IdsOfAllDependenciesNested
+  include IdsOfAllDirectDependencies
+  include DependencyTree
+
+  def ids_of_all_dependencies(to_filter=nil, filtering_strategy=:with_parents)
+    ids_of_all_dependencies_with_filtered(to_filter, filtering_strategy)[:main]
+  end
+
+  def ids_of_all_dependencies_with_filtered(to_filter=nil, filtering_strategy=:with_parents)
+    id_hash = ids_of_all_dependencies_without_reflection(to_filter || {}, filtering_strategy)
+    move_wrongly_assigned_to_main(to_filter, id_hash) if to_filter && filtering_strategy == :with_parents
+    id_hash[:main].sort_arrays!
+    id_hash[:filtered_out].sort_arrays!
+    id_hash
+  end
+
+  def ids_of_all_dependencies_without_reflection(to_filter, filtering_strategy=:with_parents)
+    result = { main: IdHash.new, filtered_out: IdHash.new }
+    self_symbol = self.class.name.underscore.to_sym
+
+    self.class.reflect_on_all_associations.map do |association|
+      next if association.macro == :belongs_to
+      symbol = association.klass.name.underscore.to_sym
+      context = { to_filter: to_filter, self_symbol: self_symbol, association: association, strategy: filtering_strategy }
+
+      self.send(association.name).map do |associated_object|
+        hash_to_use = get_hash_to_use(result, **context, object: associated_object)
+        hash_to_use.add(symbol, associated_object.id)
+      end
+
+      result = get_result_with_grandchildren_hashes(result, context)
+    end
+
+    result
+  end
+
+  private
+
+  def get_result_with_grandchildren_hashes(result, context)
+    hashes = get_grandchildren_hashes(context)
+    main = hashes.map { |hash| hash[:main] }
+    filtered_out = hashes.map { |hash| hash[:filtered_out] }
+
+    result[:main] =result[:main].join(*main)
+    result[:filtered_out] = result[:filtered_out].join(*filtered_out)
+    result
+  end
+
+  def get_grandchildren_hashes(context)
+    association = context[:association]
+    to_filter = context[:to_filter]
+
+    self.send(association.name).map do |associated_object|
+      next if should_be_filtered?(**context, object: associated_object)
+      associated_object.ids_of_all_dependencies_without_reflection(to_filter, context[:strategy])
+    end.compact
+  end
+
+  def get_hash_to_use(result, context)
+    symbol = should_be_filtered?(**context) ? :filtered_out : :main
+    result[symbol]
+  end
+
+  def should_be_filtered?(context)
+    case context[:strategy]
+    when :with_parents
+      should_be_filtered_according_to_with_parents_strategy?(context)
+    when :without_parents
+      should_be_filtered_according_to_without_parents_strategy?(context)
+    end
+  end
+
+  def should_be_filtered_according_to_with_parents_strategy?(context)
+    to_filter = context[:to_filter]
+    object = context[:object]
+    association = context[:association]
+    symbol = association.klass.name.underscore.to_sym
+
+    association.klass.reflect_on_all_associations.each do |association2|
+      next if association2.macro == :belongs_to
+
+      context = { to_filter: to_filter, symbol: symbol, association: association2 }
+      return true if object.send(association2.name).any? && is_this_association_filtered?(**context)
+    end
+
+    false
+  end
+
+  def is_this_association_filtered?(to_filter:, symbol:, association:)
+    arr = to_filter[symbol]
+    arr.present? && arr.any? { |a| a == association.name }
+  end
+
+  def should_be_filtered_according_to_without_parents_strategy?(context)
+    is_this_association_filtered?(
+      to_filter: context[:to_filter],
+      symbol: context[:self_symbol],
+      association: context[:association]
+    )
+  end
+
+  def move_wrongly_assigned_to_main(to_filter, id_hash)
+    id_hash[:filtered_out].each do |model_symbol, array|
+      array.clone.each do |id|
+        object = Model.get_model(model_symbol).find(id)
+        move_object_to_main_if_necessary(to_filter[model_symbol], id_hash, object)
+      end
+    end
+    id_hash
+  end
+
+  def move_object_to_main_if_necessary(associations_to_filter, id_hash, object)
+    if should_object_be_moved?(associations_to_filter, id_hash, object)
+      symbol = object.class.name.underscore.to_sym
+      id_hash[:filtered_out][symbol].delete(object.id)
+      id_hash[:main].add(symbol, object.id)
+    end
+  end
+
+  def should_object_be_moved?(associations_to_filter, id_hash, object)
+    associations_to_filter.map do |association|
+      associated = object.send(association)
+
+      associated.to_a.empty? || associated.map do |associated_object|
+        class_symbol = associated_object.class.name.underscore.to_sym
+        id_hash[:main][class_symbol]&.include?(associated_object.id)
+      end.reduce(:&)
+    end.reduce(:&)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dependency-trees
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Karol Selak
@@ -211,7 +211,14 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- Gemfile
+- dependency-trees-0.0.1.gem
+- dependency-trees-0.0.2.gem
+- dependency-trees.gemspec
+- lib/dependency-trees.rb
+- lib/id_hash.rb
+- lib/ids_of_all_dependencies.rb
 homepage: 
 licenses:
 - MIT