travis-backup-for-v3 0.1.0

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 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
+
+  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
+
+  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

data/lib/model.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'ids_of_all_dependencies'
+require 'nullify_dependencies'
+
+class AssociationWithValue
+  delegate_missing_to :@association
+
+  def initialize(association, value)
+    @association = association
+    @value = value
+  end
+end
+
+class Model < ActiveRecord::Base
+  include IdsOfAllDependencies
+  include NullifyDependencies
+
+  self.abstract_class = true
+
+  def attributes_without_id
+    self.attributes.reject{|k, v| k == "id"}
+  end
+
+  def associations_hash
+    self.associations.map do |association|
+      [association.name, association]
+    end.to_h
+  end
+
+  def associations
+    self.class.reflect_on_all_associations.map do |association|
+      value = self.send(association.name)
+      AssociationWithValue.new(association, value)
+    end
+  end
+
+  def associations_without_belongs_to
+    self.associations.select { |a| a.macro != :belongs_to }
+  end
+
+  def self.get_model(name)
+    self.subclasses.find{ |m| m.name == name.to_s.camelcase }
+  end
+
+  def self.get_model_by_table_name(name)
+    self.subclasses.find{ |m| m.table_name == name.to_s }
+  end
+
+  def self.ids_of_subclasses_entries
+    self.subclasses.map do |subclass|
+      [subclass.name, subclass.all.map(&:id)] if subclass.any?
+    end.compact.to_h
+  end
+
+  def self.sum_of_subclasses_rows(except: [])
+    self.subclasses.map do |subclass|
+      next 0 if except.include?(subclass.table_name) || except.include?(subclass.name)
+
+      subclass.all.size
+    end.reduce(:+)
+  end
+
+  def self.subclasses_counts(except: [])
+    self.subclasses.map do |subclass|
+      next [subclass.name, 0] if except.include?(subclass.table_name) || except.include?(subclass.name)
+
+      [subclass.name, subclass.all.size]
+    end.to_h
+  end
+
+
+  def removed?
+    begin
+      reload
+      false
+    rescue ActiveRecord::RecordNotFound => e
+      true
+    end
+  end
+end
+
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.irregular 'abuse', 'abuses'
+end

data/lib/models/abuse.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Abuse < Model
+  belongs_to :owner, polymorphic: true
+  belongs_to :request
+end

data/lib/models/beta_migration_request.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class BetaMigrationRequest < Model
+  belongs_to :owner, polymorphic: true
+  has_many :organizations
+end

data/lib/models/branch.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Branch < Model
+  belongs_to :last_build, foreign_key: :last_build_id, class_name: 'Build'
+  belongs_to :repository
+  has_many :builds
+  has_many :commits
+  has_many :crons
+  has_many :jobs, as: :source
+  has_many :requests
+
+  has_many :deleted_builds
+  has_many :deleted_commits
+  has_many :deleted_jobs, as: :source
+  has_many :deleted_requests
+end

data/lib/models/broadcast.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Broadcast < Model
+  belongs_to :recipient, polymorphic: true
+end

data/lib/models/build.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Build < Model
+  belongs_to :repository
+  belongs_to :owner, polymorphic: true
+  belongs_to :sender, polymorphic: true
+  belongs_to :related_branch, foreign_key: :branch_id, class_name: 'Branch'
+  belongs_to :commit
+  belongs_to :pull_request
+  belongs_to :tag
+  belongs_to :request
+  belongs_to :build_config, foreign_key: :config_id, class_name: 'BuildConfig'
+
+  has_many   :jobs, -> { order('id') }, as: :source, dependent: :destroy
+  has_many   :repos_for_that_this_build_is_current, foreign_key: :current_build_id, dependent: :destroy, class_name: 'Repository'
+  has_many   :repos_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'Repository'
+  has_many   :tags_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'Tag'
+  has_many   :branches_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'Branch'
+  has_many   :stages
+
+  has_many   :deleted_jobs, -> { order('id') }, as: :source, dependent: :destroy
+  has_many   :deleted_tags_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'DeletedTag'
+  has_many   :deleted_stages
+
+  def self.default_dependencies_symbols_to_nullify
+    [
+      :repos_for_that_this_build_is_current,
+      :repos_for_that_this_build_is_last,
+      :tags_for_that_this_build_is_last,
+      :deleted_tags_for_that_this_build_is_last,
+      :branches_for_that_this_build_is_last,
+    ]
+  end
+end

data/lib/models/build_config.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class BuildConfig < Model
+  belongs_to :repository
+  has_many :builds, foreign_key: :config_id, class_name: 'Build'
+  has_many :deleted_builds, foreign_key: :config_id, class_name: 'DeletedBuild'
+end

data/lib/models/cancellation.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Cancellation < Model
+  belongs_to :subscription
+  belongs_to :user
+end

data/lib/models/commit.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Commit < Model
+  belongs_to :related_branch, foreign_key: :branch_id, class_name: 'Branch'
+  belongs_to :repository
+  belongs_to :tag
+  has_many :builds
+  has_many :jobs
+  has_many :requests
+
+  has_many :deleted_builds
+  has_many :deleted_jobs
+  has_many :deleted_requests
+end

data/lib/models/cron.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Cron < Model
+  belongs_to :branch
+end

data/lib/models/deleted_build.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class DeletedBuild < Model
+  belongs_to :repository
+  belongs_to :owner, polymorphic: true
+  belongs_to :sender, polymorphic: true
+  belongs_to :related_branch, foreign_key: :branch_id, class_name: 'Branch'
+  belongs_to :commit
+  belongs_to :pull_request
+  belongs_to :tag
+  belongs_to :request
+  belongs_to :build_config, foreign_key: :config_id, class_name: 'BuildConfig'
+  self.primary_key = 'id'
+
+  # has_many   :jobs, -> { order('id') }, as: :source, dependent: :destroy
+  # has_many   :repos_for_that_this_build_is_current, foreign_key: :current_build_id, dependent: :destroy, class_name: 'Repository'
+  # has_many   :repos_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'Repository'
+  # has_many   :tags_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'Tag'
+  # has_many   :branches_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'Branch'
+  # has_many   :stages
+
+  # has_many   :deleted_jobs, -> { order('id') }, as: :source, dependent: :destroy
+  # has_many   :deleted_tags_for_that_this_build_is_last, foreign_key: :last_build_id, class_name: 'DeletedTag'
+  # has_many   :deleted_stages
+
+  # def self.default_dependencies_symbols_to_nullify
+  #   [
+  #     :repos_for_that_this_build_is_current,
+  #     :repos_for_that_this_build_is_last,
+  #     :tags_for_that_this_build_is_last,
+  #     :deleted_tags_for_that_this_build_is_last,
+  #     :branches_for_that_this_build_is_last,
+  #   ]
+  # end
+end

data/lib/models/deleted_build_config.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class DeletedBuildConfig < Model
+  belongs_to :repository
+  self.primary_key = 'id'
+  # has_many :builds, foreign_key: :config_id, class_name: 'Build'
+  # has_many :deleted_builds, foreign_key: :config_id, class_name: 'DeletedBuild'
+end