travis-backup 0.2.1 → 0.3.0

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,77 @@
+# 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 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,9 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Abuse < Model
+  belongs_to :owner, polymorphic: true
+  belongs_to :request
+  self.table_name = 'abuses'
+end

data/lib/models/annotation.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Annotation < Model
+  belongs_to :job
+  self.table_name = 'annotations'
+end

data/lib/models/branch.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
-require 'models/model'
+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
+
   self.table_name = 'branches'
 end

data/lib/models/broadcast.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Broadcast < Model
+  belongs_to :recipient, polymorphic: true
+  self.table_name = 'broadcasts'
+end

data/lib/models/build.rb

@@ -1,14 +1,34 @@
 # frozen_string_literal: true
 
 require 'models/job'
-require 'models/model'
+require 'model'
 require 'models/repository'
 
 # Build model
 class Build < Model
   belongs_to :repository
-  has_many   :jobs, -> { order('id') }, foreign_key: :source_id, dependent: :destroy, class_name: 'Job'
-  has_one    :repo_for_that_this_build_is_current, foreign_key: :current_build_id, dependent: :destroy, class_name: '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
+  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
 
   self.table_name = 'builds'
+
+  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,
+      :branches_for_that_this_build_is_last
+    ]
+  end
 end

data/lib/models/commit.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
-require 'models/model'
+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
+
   self.table_name = 'commits'
 end

data/lib/models/cron.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'models/model'
+require 'model'
 
 class Cron < Model
+  belongs_to :branch
   self.table_name = 'crons'
 end

data/lib/models/email.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Email < Model
+  belongs_to :user
+  self.table_name = 'emails'
+end

data/lib/models/invoice.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Invoice < Model
+  belongs_to :subscription
+  self.table_name = 'invoices'
+end

data/lib/models/job.rb

@@ -1,15 +1,23 @@
 # frozen_string_literal: true
 
-require 'models/model'
+require 'model'
 require 'models/repository'
 require 'models/log'
+require 'models/annotation'
+require 'models/queueable_job'
 
 # Job model
 class Job < Model
   self.inheritance_column = :_type_disabled
 
+  belongs_to :source, polymorphic: true
+  belongs_to :owner, polymorphic: true
   belongs_to :repository
-  has_many   :logs, -> { order('id') }, foreign_key: :job_id, dependent: :destroy, class_name: 'Log'
+  belongs_to :commit
+  belongs_to :stage
+  has_many   :logs, -> { order('id') }, dependent: :destroy
+  has_many   :annotations
+  has_many   :queueable_jobs
 
   self.table_name = 'jobs'
 end

data/lib/models/log.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'models/model'
+require 'model'
 
 class Log < Model
   belongs_to :job

data/lib/models/membership.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Membership < Model
+  belongs_to :organization
+  belongs_to :user
+  self.table_name = 'memberships'
+end

data/lib/models/message.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Message < Model
+  belongs_to :subject, polymorphic: true
+  self.table_name = 'messages'
+end

data/lib/models/organization.rb

@@ -1,7 +1,21 @@
 # frozen_string_literal: true
 
-require 'models/model'
+require 'model'
 
 class Organization < Model
+  has_many :builds_for_that_this_organization_is_owner, as: :owner, class_name: 'Build'
+  has_many :builds_for_that_this_organization_is_sender, as: :sender, class_name: 'Build'
+  has_many :repositories, as: :owner
+  has_many :jobs, as: :owner
+  has_many :requests_for_that_this_organization_is_owner, as: :owner, class_name: 'Request'
+  has_many :abuses, as: :owner
+  has_many :subscriptions, as: :owner
+  has_many :owner_groups, as: :owner
+  has_many :trials, as: :owner
+  has_many :trial_allowances, as: :creator
+  has_many :broadcasts, as: :recipient
+  has_many :requests_for_that_this_organization_is_sender, as: :sender, class_name: 'Request'
+  has_many :memberships
+
   self.table_name = 'organizations'
 end

data/lib/models/owner_group.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class OwnerGroup < Model
+  belongs_to :owner, polymorphic: true
+  self.table_name = 'owner_groups'
+end

data/lib/models/permission.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class Permission < Model
+  belongs_to :repository
+  belongs_to :user
+  self.table_name = 'permissions'
+end

data/lib/models/pull_request.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
-require 'models/model'
+require 'model'
 
 class PullRequest < Model
+  belongs_to :repository
+  has_many :requests
+  has_many :builds
+
   self.table_name = 'pull_requests'
 end

data/lib/models/queueable_job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'model'
+
+class QueueableJob < Model
+  belongs_to :job
+  self.table_name = 'queueable_jobs'
+end

data/lib/models/repository.rb

@@ -1,13 +1,26 @@
 # frozen_string_literal: true
 
-require 'models/model'
+require 'model'
 require 'models/build'
 require 'models/request'
+require 'models/permission'
+require 'models/star'
 
 # Repository model
 class Repository < Model
-  has_many :builds, -> { order('id') }, foreign_key: :repository_id, class_name: 'Build'
-  has_many :requests, -> { order('id') }, foreign_key: :repository_id, dependent: :destroy, class_name: 'Request'
+  belongs_to :owner, polymorphic: true
+  belongs_to :current_build, foreign_key: :current_build_id, class_name: 'Build'
+  belongs_to :last_build, foreign_key: :last_build_id, class_name: 'Build'
+  has_many :builds, -> { order('id') }
+  has_many :requests, -> { order('id') }, dependent: :destroy
+  has_many :jobs
+  has_many :branches
+  has_many :ssl_keys
+  has_many :commits
+  has_many :permissions
+  has_many :stars
+  has_many :pull_requests
+  has_many :tags
 
   self.table_name = 'repositories'
 end