diffend 0.2.27 → 0.2.32

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,28 +1,39 @@
 # 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/file_finder
+  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}" }
+config = Diffend::Config.new(
+  command: Diffend::Commands::EXEC,
+  severity: Diffend::Logger::FATAL
+)
+
+return if %w[development test].include?(config.env)
 
 Thread.new do
-  track = Diffend::Track.new
+  track = Diffend::Track.new(config)
   track.start
 end

data/lib/diffend/plugin.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+%w[
+  bundler
+].each(&method(:require))
+
+%w[
+  version
+  logger
+  latest_version
+  errors
+  build_bundler_definition
+  commands
+  config
+  configs/fetcher
+  configs/file_finder
+  configs/validator
+  handle_errors/messages
+  handle_errors/build_exception_payload
+  handle_errors/display_to_stdout
+  handle_errors/report
+  request_object
+  request
+  local_context/diffend
+  local_context/host
+  local_context/packages
+  local_context/platform
+  local_context
+  request_verdict
+  execute
+  track
+].each { |file| require "diffend/#{file}" }
+
+module Diffend
+  module Plugin
+    class << self
+      # Registers the plugin and add before install all hook
+      def register
+        ::Bundler::Plugin.add_hook('before-install-all') do |_|
+          execute
+        end
+      end
+
+      # Execute diffend plugin
+      def execute
+        return unless enabled?
+
+        config = Diffend::Config.new(severity: Diffend::Logger::INFO)
+
+        Diffend::LatestVersion.call(config)
+
+        Diffend::Execute.call(config)
+      rescue Diffend::Errors::HandledException
+        return if config.ignore_errors?
+
+        exit 255
+      rescue StandardError => e
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          config: config,
+          message: :unhandled_exception,
+          report: true,
+          raise_exception: false
+        )
+
+        return if config.ignore_errors?
+
+        exit 255
+      end
+
+      # Checks if plugin is enabled
+      #
+      # @return [Boolean] true if enabled, false otherwise
+      def enabled?
+        ::Bundler
+          .default_gemfile
+          .read
+          .split("\n")
+          .reject(&:empty?)
+          .map(&:strip)
+          .select { |line| line.start_with?('plugin') }
+          .any? { |line| line.include?('diffend') }
+      end
+    end
+  end
+end

data/lib/diffend/request.rb

@@ -67,7 +67,7 @@ module Diffend
       rescue Diffend::Errors::RequestServerError => e
         retry_count += 1
 
-        retry if handle_retry(SERVER_ERROR_MESSAGE, retry_count)
+        retry if handle_retry(request_object.config, SERVER_ERROR_MESSAGE, retry_count)
 
         Diffend::HandleErrors::Report.call(
           exception: e,
@@ -78,7 +78,7 @@ module Diffend
       rescue *CONNECTION_EXCEPTIONS => e
         retry_count += 1
 
-        retry if handle_retry(CONNECTION_MESSAGE, retry_count)
+        retry if handle_retry(request_object.config, CONNECTION_MESSAGE, retry_count)
 
         Diffend::HandleErrors::Report.call(
           exception: e,
@@ -89,7 +89,7 @@ module Diffend
       rescue *TIMEOUT_EXCEPTIONS => e
         retry_count += 1
 
-        retry if handle_retry(TIMEOUT_MESSAGE, retry_count)
+        retry if handle_retry(request_object.config, TIMEOUT_MESSAGE, retry_count)
 
         Diffend::HandleErrors::Report.call(
           exception: e,
@@ -101,12 +101,13 @@ module Diffend
 
       # Handle retry
       #
+      # @param config [Diffend::Config]
       # @param message [String] message we want to display
       # @param retry_count [Integer]
-      def handle_retry(message, retry_count)
+      def handle_retry(config, message, retry_count)
         return false if retry_count == RETRIES
 
-        Bundler.ui.error(message)
+        config.logger.warn(message)
         sleep(exponential_backoff(retry_count))
 
         retry_count < RETRIES
@@ -123,8 +124,8 @@ module Diffend
           uri.port,
           use_ssl: uri.scheme == 'https',
           verify_mode: OpenSSL::SSL::VERIFY_NONE,
-          open_timeout: 5,
-          read_timeout: 5
+          open_timeout: 15,
+          read_timeout: 15
         ) { |http| yield(http, uri) }
       end
 
@@ -132,7 +133,7 @@ module Diffend
       #
       # @param uri [URI::HTTPS]
       # @param request_method [Symbol]
-      # @param config [OpenStruct] Diffend config
+      # @param config [Diffend::Config]
       # @param payload [Hash] with versions to check
       #
       # @return [Net::HTTP::Post, Net::HTTP::Put]
@@ -160,9 +161,8 @@ module Diffend
       # Assigns basic authorization if provided in the config
       #
       # @param request [Net::HTTP::Post] prepared http post
-      # @param config [OpenStruct] Diffend config
+      # @param config [Diffend::Config]
       def assign_auth(request, config)
-        return unless config
         return unless config.shareable_id
         return unless config.shareable_key
 

data/lib/diffend/request_verdict.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Diffend
+  # Module responsible for fetching diffend verdict on local context
+  module RequestVerdict
+    class << self
+      # @param config [Diffend::Config]
+      # @param definition [Bundler::Definition] definition for your source
+      def call(config, definition)
+        payload = Diffend::LocalContext.call(config, definition)
+
+        response = Diffend::Request.call(
+          build_request_object(config, payload)
+        )
+
+        JSON.parse(response.body)
+      rescue Bundler::GemNotFound, Bundler::VersionConflict
+        raise ::Diffend::Errors::DependenciesResolveException
+      rescue StandardError => e
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          payload: payload || {},
+          config: config,
+          message: :unhandled_exception,
+          report: true
+        )
+      end
+
+      # @param config [Diffend::Config]
+      # @param payload [Hash]
+      #
+      # @return [Diffend::RequestObject]
+      def build_request_object(config, payload)
+        Diffend::RequestObject.new(
+          config: config,
+          url: config.commands_url,
+          payload: payload,
+          request_method: :post
+        )
+      end
+    end
+  end
+end

data/lib/diffend/track.rb

@@ -9,14 +9,16 @@ module Diffend
     RETRY_SLEEP = 15
 
     # Initialize tracking
-    def initialize
+    #
+    # @param config [Diffend::Config]
+    def initialize(config)
       @mutex = Mutex.new
-      @config = fetch_config
+      @config = config
     end
 
     # Start tracking
     def start
-      response = exec_request
+      response = Diffend::Execute.call(@config)
 
       perform(response['id'])
     rescue Diffend::Errors::HandledException
@@ -40,27 +42,12 @@ module Diffend
     # @param request_id [String]
     def perform(request_id)
       loop do
-        @mutex.synchronize do
-          track_request(request_id)
-        end
+        @mutex.synchronize { track_request(request_id) }
 
         sleep(TRACK_SLEEP)
       end
     end
 
-    # Perform an exec request
-    def exec_request
-      Diffend::Voting.call(
-        Diffend::Commands::EXEC,
-        @config,
-        Diffend::BuildBundlerDefinition.call(
-          Diffend::Commands::EXEC,
-          Bundler.default_gemfile,
-          Bundler.default_lockfile
-        )
-      )
-    end
-
     # Perform a track request
     #
     # @param request_id [String]
@@ -76,29 +63,10 @@ module Diffend
     def build_request_object(request_id)
       Diffend::RequestObject.new(
         config: @config,
-        url: track_url(@config.project_id, request_id),
+        url: @config.track_url(request_id),
         payload: { id: request_id }.freeze,
         request_method: :put
       ).freeze
     end
-
-    # Fetch diffend config file
-    #
-    # @return [OpenStruct, nil] configuration object
-    #
-    # @raise [Errors::MissingConfigurationFile] when no config file
-    def fetch_config
-      Config::Fetcher.call(
-        File.expand_path('..', Bundler.bin_path)
-      )
-    end
-
-    # @param project_id [String] diffend project_id
-    # @param request_id [String]
-    #
-    # @return [String]
-    def track_url(project_id, request_id)
-      "https://my.diffend.io/api/projects/#{project_id}/bundle/#{request_id}/track"
-    end
   end
 end