diffend-monitor 0.2.28 → 0.2.34

data/lib/diffend/config/fetcher.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Diffend
-  # Module for all the components related to setting up the config
-  module Config
-    # Class responsible for fetching the config from .diffend.yml
-    module Fetcher
-      # All the errors for missing keys in the configuration file
-      MISSING_KEY_ERRORS = [
-        Errors::ProjectIdMissingInConfigurationFile,
-        Errors::ShareableIdMissingInConfigurationFile,
-        Errors::ShareableKeyMissingInConfigurationFile,
-        Errors::BuildPathMissingInConfigurationFile
-      ].freeze
-
-      class << self
-        # @param build_path [String] path of the current build
-        #
-        # @return [OpenStruct] open struct with config details
-        #
-        # @example
-        #   details = Fetcher.new.call('./')
-        #   details.build_path #=> './'
-        def call(build_path)
-          build(build_path)
-        rescue Errors::MissingConfigurationFile
-          Bundler.ui.error(build_missing_error_message(build_path))
-
-          raise Diffend::Errors::HandledException
-        rescue Errors::EmptyConfigurationFile
-          Bundler.ui.error(build_empty_error_message(build_path))
-
-          raise Diffend::Errors::HandledException
-        rescue Errors::MalformedConfigurationFile
-          Bundler.ui.error(build_malformed_error_message(build_path))
-
-          raise Diffend::Errors::HandledException
-        rescue *MISSING_KEY_ERRORS => e
-          Bundler.ui.error(build_missing_key_error_message(e))
-
-          raise Diffend::Errors::HandledException
-        end
-
-        private
-
-        # @param build_path [String] path of the current build
-        #
-        # @return [OpenStruct] open struct with config details
-        def build(build_path)
-          content = ERB.new(
-            File.read(
-              FileFinder.call(build_path)
-            )
-          ).result
-
-          raise Errors::EmptyConfigurationFile if content.empty?
-
-          OpenStruct.new(
-            parse_file(content)
-              .merge(build_path: build_path)
-              .merge(diffend_env: ENV['DIFFEND_ENV'] || 'development')
-          )
-          .tap(&Validator.method(:call))
-        end
-
-        def parse_file(content)
-          YAML.safe_load(content)
-        rescue Psych::SyntaxError
-          raise Errors::MalformedConfigurationFile
-        end
-
-        # @param build_path [String] path of the current build
-        #
-        # @return [String] missing configuration file message
-        def build_missing_error_message(build_path)
-          <<~MSG
-            \nWe were unable to locate Diffend configuration file.\n
-            Please make sure that .diffend.yml is present in #{build_path} folder.\n
-          MSG
-        end
-
-        # @return [String] empty configuration file message
-        def build_empty_error_message
-          <<~MSG
-            \nYour Diffend configuration file is empty.\n
-            Please re-setup.\n
-          MSG
-        end
-
-        # @return [String] malformed configuration file message
-        def build_malformed_error_message
-          <<~MSG
-            \nYour Diffend configuration file is malformed.\n
-            Please re-setup.\n
-          MSG
-        end
-
-        # @return [String] malformed configuration file message
-        def build_missing_key_error_message(exception)
-          missing_key = missing_key_from_exception(exception)
-
-          <<~MSG
-            \nYour Diffend configuration file is missing #{missing_key} key.\n
-            Please re-setup.\n
-          MSG
-        end
-
-        def missing_key_from_exception(exception)
-          case exception
-          when Errors::ProjectIdMissingInConfigurationFile then 'project_id'
-          when Errors::ShareableIdMissingInConfigurationFile then 'shareable_id'
-          when Errors::ShareableKeyMissingInConfigurationFile then 'shareable_key'
-          when Errors::BuildPathMissingInConfigurationFile then 'build_path'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/diffend/config/file_finder.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Diffend
-  module Config
-    # Class used to figure out the file from which we should load the settings
-    module FileFinder
-      # Names of the files or paths where we will look for the settings
-      #
-      # @note We do the double dot trick, to look outside of the current dir because when
-      #   executed from a docker container, we copy the local uncommitted settings into the
-      #   dir above the app location not to pollute the reset state of the git repo
-      #
-      # @note Order is important, as for local env we should load from
-      #   local file (if present first)
-      FILE_NAMES = %w[
-        .diffend.yml
-      ].map { |name| ["../#{name}", name] }.tap(&:flatten!).freeze
-
-      private_constant :FILE_NAMES
-
-      class << self
-        # Looks for Diffend settings file for a given env
-        #
-        # @param build_path [String] path of the current build
-        #
-        # @return [String] path to the file from which we should load all the settings
-        def call(build_path)
-          FILE_NAMES
-            .map { |name| File.join(build_path, name) }
-            .map { |name| Dir[name] }
-            .find { |selection| !selection.empty? }
-            .tap { |path| path || raise(Errors::MissingConfigurationFile) }
-            .first
-        end
-      end
-    end
-  end
-end

data/lib/diffend/config/validator.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Diffend
-  # Module for all the components related to setting up the config
-  module Config
-    # Class responsible for validating the config from .diffend.yml
-    module Validator
-      class << self
-        # @param config [OpenStruct] path of the current build
-        def call(config)
-          raise Errors::ProjectIdMissingInConfigurationFile if missing?(config, 'project_id')
-          raise Errors::ShareableIdMissingInConfigurationFile if missing?(config, 'shareable_id')
-          raise Errors::ShareableKeyMissingInConfigurationFile if missing?(config, 'shareable_key')
-          raise Errors::BuildPathMissingInConfigurationFile if missing?(config, 'build_path')
-        end
-
-        private
-
-        def missing?(config, key)
-          config.public_send(key).nil? || config.public_send(key).empty?
-        end
-      end
-    end
-  end
-end

data/lib/diffend/voting/versions/local.rb

@@ -1,304 +0,0 @@
-# frozen_string_literal: true
-
-module Diffend
-  module Voting
-    # Module responsible for handling both local and remote gem versions
-    module Versions
-      # Module responsible for preparing current or current/new versions of gems
-      class Local
-        # Definition of a local path, if it matches it means that we are the source
-        ME_PATH = '.'
-        # Sources that we expect to match ourselves too
-        ME_SOURCES = [
-          Bundler::Source::Gemspec,
-          Bundler::Source::Path
-        ].freeze
-        # List of dependency types
-        DEPENDENCIES_TYPES = {
-          direct: 0,
-          dependency: 1
-        }.freeze
-        # List of sources types
-        SOURCES_TYPES = {
-          valid: 0,
-          multiple_primary: 1
-        }.freeze
-        # List of gem sources types
-        GEM_SOURCES_TYPES = {
-          local: 0,
-          gemfile_source: 1,
-          gemfile_git: 2,
-          gemfile_path: 3
-        }.freeze
-
-        class << self
-          # @param command [String] either install or update
-          # @param definition [Bundler::Definition] definition for your source
-          def call(command, definition)
-            Bundler.ui.silence { definition.resolve_remotely! }
-
-            instance = new(definition)
-
-            case command
-            when Commands::INSTALL, Commands::EXEC then instance.build_install
-            when Commands::UPDATE then instance.build_update
-            else
-              raise ArgumentError, "invalid command: #{command}"
-            end
-          end
-        end
-
-        # @param definition [Bundler::Definition] definition for your source
-        #
-        # @return [Hash] local dependencies
-        def initialize(definition)
-          @definition = definition
-          @direct_dependencies = Hash[definition.dependencies.map { |val| [val.name, val] }]
-          # Support case without Gemfile.lock
-          @locked_specs = @definition.locked_gems ? @definition.locked_gems.specs : []
-        end
-
-        # Build install specification
-        #
-        # @return [Hash]
-        def build_install
-          hash = build_main
-
-          @definition.specs.each do |spec|
-            next if skip?(spec.source)
-
-            locked_spec = @locked_specs.find { |s| s.name == spec.name }
-
-            hash['dependencies'][spec.name] = {
-              'platform' => build_spec_platform(spec, locked_spec),
-              'source' => build_spec_source(spec),
-              'type' => build_dependency_type(spec.name),
-              'versions' => build_versions(spec, locked_spec)
-            }
-          end
-
-          hash
-        end
-
-        # Build update specification
-        #
-        # @return [Hash]
-        def build_update
-          hash = build_main
-
-          @definition.specs.each do |spec|
-            next if skip?(spec.source)
-
-            locked_spec = @locked_specs.find { |s| s.name == spec.name }
-
-            hash['dependencies'][spec.name] = {
-              'platform' => build_spec_platform(spec, locked_spec),
-              'source' => build_spec_source(spec),
-              'type' => build_dependency_type(spec.name),
-              'versions' => build_versions(spec, locked_spec)
-            }
-          end
-
-          hash
-        end
-
-        private
-
-        # Build default specification
-        #
-        # @return [Hash]
-        def build_main
-          {
-            'dependencies' => {},
-            'sources' => build_sources,
-            'plugins' => {},
-            'platforms' => @definition.platforms.map(&:to_s)
-          }
-        end
-
-        # Build gem versions
-        #
-        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
-        # @param locked_spec [Bundler::LazySpecification, Gem::Specification, NilClass]
-        #
-        # @return [Array<String>]
-        def build_versions(spec, locked_spec = nil)
-          if locked_spec && locked_spec.version.to_s != spec.version.to_s
-            [locked_spec.version.to_s, spec.version.to_s]
-          else
-            [spec.version.to_s]
-          end
-        end
-
-        # @param specs [Array] specs that are direct dependencies
-        # @param name [String] spec name
-        #
-        # @return [Boolean] dependency type
-        def build_dependency_type(name)
-          if @direct_dependencies.key?(name)
-            DEPENDENCIES_TYPES[:direct]
-          else
-            DEPENDENCIES_TYPES[:dependency]
-          end
-        end
-
-        # Build gem platform
-        #
-        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
-        # @param locked_spec [Bundler::LazySpecification, Gem::Specification, NilClass]
-        #
-        # @return [String]
-        def build_spec_platform(spec, locked_spec)
-          parse_platform(
-            spec.platform || locked_spec&.platform || spec.send(:generic_local_platform)
-          )
-        end
-
-        # Parse gem platform
-        #
-        # @param platform [String, Gem::Platform]
-        #
-        # @return [String]
-        def parse_platform(platform)
-          case platform
-          when String then platform
-          when Gem::Platform then platform.os
-          end
-        end
-
-        # Build gem source type
-        #
-        # @param source [Bundler::Source] gem source type
-        #
-        # @return [Integer] internal gem source type
-        def build_spec_gem_source_type(source)
-          case source
-          when Bundler::Source::Metadata
-            GEM_SOURCES_TYPES[:local]
-          when Bundler::Source::Rubygems, Bundler::Source::Rubygems::Remote
-            GEM_SOURCES_TYPES[:gemfile_source]
-          when Bundler::Source::Git
-            GEM_SOURCES_TYPES[:gemfile_git]
-          when Bundler::Source::Path
-            GEM_SOURCES_TYPES[:gemfile_path]
-          else
-            raise ArgumentError, "unknown source #{source.class}"
-          end
-        end
-
-        # Build gem source
-        #
-        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
-        #
-        # @return [Hash]
-        def build_spec_source(spec)
-          source = source_for_spec(spec)
-
-          {
-            'type' => build_spec_gem_source_type(source),
-            'value' => source_name_from_source(source)
-          }
-        end
-
-        # Figure out source for gem
-        #
-        # @param spec [Bundler::StubSpecification, Bundler::LazySpecification, Gem::Specification]
-        #
-        # @return [Bundler::Source] gem source type
-        def source_for_spec(spec)
-          return spec.remote if spec.remote
-
-          case spec.source
-          when Bundler::Source::Rubygems
-            spec
-              .source
-              .send(:remote_specs)
-              .search(Bundler::Dependency.new(spec.name, spec.version))
-              .last
-              .remote
-          when Bundler::Source::Metadata, Bundler::Source::Git, Bundler::Source::Path
-            spec.source
-          else
-            raise ArgumentError, "unknown source #{spec.source.class}"
-          end
-        end
-
-        # Build gem source name
-        #
-        # @param source [Bundler::Source] gem source type
-        #
-        # @return [String]
-        def source_name_from_source(source)
-          case source
-          when Bundler::Source::Metadata
-            ''
-          when Bundler::Source::Rubygems::Remote
-            source_name(source.anonymized_uri)
-          when Bundler::Source::Git
-            source.instance_variable_get(:@safe_uri)
-          when Bundler::Source::Path
-            source.path
-          else
-            raise ArgumentError, "unknown source #{source.class}"
-          end
-        end
-
-        # @param uri [Bundler::URI]
-        #
-        # @return [String]
-        def source_name(uri)
-          uri.to_s[0...-1]
-        end
-
-        # Build sources used in the Gemfile
-        #
-        # @return [Array<Hash>]
-        def build_sources
-          sources = @definition.send(:sources).rubygems_sources
-          hash = {}
-
-          sources.each do |source|
-            type = build_source_type(source.remotes)
-
-            source.remotes.each do |src|
-              hash[source_name(src)] = type
-            end
-          end
-
-          hash.map { |name, type| { 'name' => name, 'type' => type } }
-        end
-
-        # Build gem source type
-        #
-        # @param remotes [Array<Bundler::URI>]
-        #
-        # @return [Integer] internal source type
-        def build_source_type(remotes)
-          remotes.count > 1 ? SOURCES_TYPES[:multiple_primary] : SOURCES_TYPES[:valid]
-        end
-
-        # Checks if we should skip a source
-        #
-        # @param source [Bundler::Source] gem source type
-        #
-        # @return [Boolean] true if we should skip this source, false otherwise
-        def skip?(source)
-          return true if me?(source)
-
-          false
-        end
-
-        # Checks if it's a self source, this happens for repositories that are a gem
-        #
-        # @param source [Bundler::Source] gem source type
-        #
-        # @return [Boolean] true if it's a self source, false otherwise
-        def me?(source)
-          return false unless ME_SOURCES.include?(source.class)
-
-          source.path.to_s == ME_PATH
-        end
-      end
-    end
-  end
-end