diffend 0.2.29 → 0.2.34

data/lib/diffend/local_context/packages.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Module responsible for building local context
+  module LocalContext
+    # Module responsible for building packages information from local context
+    class Packages
+      # 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] command executed via bundler
+        # @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.to_s
+        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

data/lib/diffend/local_context/platform.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Module responsible for building local context
+  module LocalContext
+    # Module responsible for building platform information from local context
+    module Platform
+      class << self
+        # Build platform information
+        #
+        # @return [Hash]
+        def call
+          {
+            'bundler' => {
+              'version' => Bundler::VERSION
+            },
+            'environment' => environment,
+            'ruby' => ruby_information,
+            'rubygems' => {
+              'specification_version' => Gem::Specification::CURRENT_SPECIFICATION_VERSION,
+              'version' => Gem::VERSION
+            }
+          }.freeze
+        end
+
+        private
+
+        # Build platform ruby information
+        #
+        # @return [Hash]
+        def ruby_information
+          if defined?(JRUBY_VERSION)
+            revision = JRUBY_REVISION.to_s
+            version = JRUBY_VERSION
+          else
+            revision = RUBY_REVISION.to_s
+            version = RUBY_ENGINE_VERSION
+          end
+
+          {
+            'engine' => RUBY_ENGINE,
+            'patchlevel' => RUBY_PATCHLEVEL,
+            'release_date' => RUBY_RELEASE_DATE,
+            'revision' => revision,
+            'version' => version
+          }
+        end
+
+        # Build platform environment information
+        #
+        # @return [String]
+        def environment
+          ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+        end
+      end
+    end
+  end
+end

data/lib/diffend/logger.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Diffend logging
+  class Logger
+    # Low-level information, mostly for developers.
+    DEBUG = 0
+    # Generic (useful) information about system operation.
+    INFO = 1
+    # A warning.
+    WARN = 2
+    # A handleable error condition.
+    ERROR = 3
+    # An unhandleable error that results in a program crash.
+    FATAL = 4
+    # An unknown message that should always be logged.
+    UNKNOWN = 5
+
+    # @param level [Integer] logging severity threshold
+    def initialize(level = INFO)
+      @level = level
+    end
+
+    # @param message [String]
+    def debug(message)
+      log(DEBUG, message)
+    end
+
+    # @param message [String]
+    def info(message)
+      log(INFO, message)
+    end
+
+    # @param message [String]
+    def warn(message)
+      log(WARN, message)
+    end
+
+    # @param message [String]
+    def error(message)
+      log(ERROR, message)
+    end
+
+    # @param message [String]
+    def fatal(message)
+      log(FATAL, message)
+    end
+
+    private
+
+    # @param severity [Integer]
+    # @param message [String]
+    def log(severity, message)
+      return if severity < @level
+
+      case severity
+      when INFO
+        Bundler.ui.confirm(message)
+      when WARN
+        Bundler.ui.warn(message)
+      when ERROR, FATAL
+        Bundler.ui.error(message)
+      end
+    end
+  end
+end

data/lib/diffend/monitor.rb

@@ -1,30 +1,43 @@
 # frozen_string_literal: true
 
 %w[
-  build_bundler_definition
+  version
+  logger
   errors
-  config/fetcher
-  config/file_finder
-  config/validator
+  build_bundler_definition
   commands
+  config
+  configs/fetcher
+  configs/validator
   handle_errors/messages
   handle_errors/build_exception_payload
   handle_errors/display_to_stdout
   handle_errors/report
   request_object
   request
-  voting
+  local_context/diffend
+  local_context/host
+  local_context/packages
+  local_context/platform
+  local_context
+  request_verdict
+  execute
   track
 ].each { |file| require "diffend/#{file}" }
 
-%w[
-  versions/local
-  versions/remote
-].each { |file| require "diffend/voting/#{file}" }
+begin
+  config = Diffend::Config.new(
+    command: Diffend::Commands::EXEC,
+    severity: Diffend::Logger::FATAL
+  )
+rescue Diffend::Errors::HandledException
+  # we silent exit here because we don't want to break client boot
+  return
+end
+
+return if %w[development test].include?(config.env)
 
-unless %w[development test].include?(ENV['DIFFEND_ENV'])
-  Thread.new do
-    track = Diffend::Track.new
-    track.start
-  end
+Thread.new do
+  track = Diffend::Track.new(config)
+  track.start
 end