diffend-monitor 0.2.28 → 0.2.34

data/lib/diffend/configs/validator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Module for all the components related to setting up the config
+  module Configs
+    # Class responsible for validating the config from .diffend.yml
+    module Validator
+      KNOWN_KEYS = {
+        project_id: [String],
+        shareable_id: [String],
+        shareable_key: [String],
+        build_path: [String],
+        env: [String],
+        command: [String],
+        ignore_errors?: [TrueClass, FalseClass],
+        development?: [TrueClass, FalseClass]
+      }.freeze
+
+      class << self
+        # @param config [Diffend::Config]
+        def call(config)
+          KNOWN_KEYS.each_key do |key|
+            if missing?(config, key)
+              missing_key_message(key)
+                .tap(&config.logger.method(:fatal))
+
+              raise Diffend::Errors::HandledException
+            end
+
+            if invalid?(config, key)
+              invalid_key_message(config, key)
+                .tap(&config.logger.method(:fatal))
+
+              raise Diffend::Errors::HandledException
+            end
+          end
+        end
+
+        private
+
+        # @param config [Diffend::Config]
+        # @param key [String]
+        #
+        # @return [Boolean] true if we are missing a key, false otherwise
+        def missing?(config, key)
+          value = config.public_send(key)
+
+          value.nil? || (value.respond_to?(:empty?) && value.empty?)
+        end
+
+        # @param config [Diffend::Config]
+        # @param key [String]
+        #
+        # @return [Boolean] true if we are missing a key, false otherwise
+        def invalid?(config, key)
+          !KNOWN_KEYS[key].include?(config.public_send(key).class)
+        end
+
+        # Missing key message
+        #
+        # @param key [String] missing key
+        #
+        # @return [String]
+        def missing_key_message(key)
+          <<~MSG
+            \nDiffend configuration is missing #{key} key.\n
+          MSG
+        end
+
+        # Invalid key message
+        #
+        # @param hash [Hash] config hash
+        # @param key [String] invalid key
+        #
+        # @return [String]
+        def invalid_key_message(hash, key)
+          <<~MSG
+            \nDiffend configuration value for #{key} is invalid.\n
+            It should be #{KNOWN_KEYS[key].join(' or ')} but is #{hash.public_send(key).class}.\n
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/diffend/errors.rb

@@ -5,10 +5,6 @@ module Diffend
   module Errors
     # Base error class from which all the errors should inherit
     BaseError = Class.new(StandardError)
-    # Raised when we couldn't find a valid configuration file
-    MissingConfigurationFile = Class.new(BaseError)
-    # Raised when configuration file is empty
-    EmptyConfigurationFile = Class.new(BaseError)
     # Raised when configuration file is malformed
     MalformedConfigurationFile = Class.new(BaseError)
     # Raised when project_id is missing in configuration file
@@ -23,5 +19,7 @@ module Diffend
     RequestServerError = Class.new(BaseError)
     # Raised when we had an exception that we know how to handle
     HandledException = Class.new(BaseError)
+    # Raised when we are unable to resolve dependencies
+    DependenciesResolveException = Class.new(BaseError)
   end
 end

data/lib/diffend/{voting.rb → execute.rb}

@@ -1,28 +1,38 @@
 # frozen_string_literal: true
 
 module Diffend
-  # Verifies voting verdicts for gems
-  module Voting
+  # Executes a check for a given command
+  module Execute
     class << self
       # Build verdict
       #
-      # @param command [String] either install or update
-      # @param config [OpenStruct] diffend config
-      # @param definition [Bundler::Definition] definition for your source
-      def call(command, config, definition)
-        Versions::Remote
-          .call(command, config, definition)
-          .tap { |response| build_message(command, config, response) }
+      # @param config [Diffend::Config]
+      def call(config)
+        Diffend::RequestVerdict
+          .call(config, build_definition(config.command))
+          .tap { |response| build_message(config, response) }
+      rescue Diffend::Errors::DependenciesResolveException
+        # We are unable to resolve dependencies, no message will be printed
       end
 
-      # @param command [String] either install or update
-      # @param config [OpenStruct] diffend config
+      # Build bundler definition
+      #
+      # @return [Bundler::Definition]
+      def build_definition(command)
+        Diffend::BuildBundlerDefinition.call(
+          command,
+          Bundler.default_gemfile,
+          Bundler.default_lockfile
+        )
+      end
+
+      # @param config [Diffend::Config]
       # @param response [Hash] response from diffend API
-      def build_message(command, config, response)
+      def build_message(config, response)
         if response.key?('error')
-          build_error(response)
+          build_error(config, response)
         elsif response.key?('action')
-          build_verdict(command, config, response)
+          build_verdict(config, response)
         else
           Diffend::HandleErrors::Report.call(
             config: config,
@@ -36,25 +46,24 @@ module Diffend
       # @param response [Hash] response from diffend API
       def build_error(response)
         build_error_message(response)
-          .tap(&Bundler.ui.method(:error))
+          .tap(&config.logger.method(:error))
 
         raise Diffend::Errors::HandledException
       end
 
-      # @param command [String] either install or update
-      # @param config [OpenStruct] diffend config
+      # @param config [Diffend::Config]
       # @param response [Hash] response from diffend API
-      def build_verdict(command, config, response)
+      def build_verdict(config, response)
         case response['action']
         when 'allow'
-          build_allow_message(command, response)
-            .tap(&Bundler.ui.method(:confirm))
+          build_allow_message(config.command, response)
+            .tap(&config.logger.method(:info))
         when 'warn'
-          build_warn_message(command, response)
-            .tap(&Bundler.ui.method(:warn))
+          build_warn_message(config.command, response)
+            .tap(&config.logger.method(:warn))
         when 'deny'
-          build_deny_message(command, response)
-            .tap(&Bundler.ui.method(:error))
+          build_deny_message(config.command, response)
+            .tap(&config.logger.method(:error))
 
           exit 1
         else
@@ -77,7 +86,7 @@ module Diffend
         MSG
       end
 
-      # @param command [String] either install or update
+      # @param command [String] command executed via bundler
       # @param response [Hash] response from diffend API
       #
       # @return [String]
@@ -89,7 +98,7 @@ module Diffend
         MSG
       end
 
-      # @param command [String] either install or update
+      # @param command [String] command executed via bundler
       # @param response [Hash] response from diffend API
       #
       # @return [String]
@@ -101,7 +110,7 @@ module Diffend
         MSG
       end
 
-      # @param command [String] either install or update
+      # @param command [String] command executed via bundler
       # @param response [Hash] response from diffend API
       #
       # @return [String]
@@ -114,7 +123,7 @@ module Diffend
       end
 
       # @param type [String] verdict type
-      # @param command [String] either install or update
+      # @param command [String] command executed via bundler
       #
       # @return [String]
       def build_message_header(type, command)

data/lib/diffend/handle_errors/report.rb

@@ -7,10 +7,10 @@ module Diffend
       class << self
         # Execute request to Diffend
         #
+        # @param config [Diffend::Config]
+        # @param message [Symbol] message that we want to display
         # @param exception [Exception] expection that was raised
         # @param payload [Hash] with versions to check
-        # @param config [OpenStruct] Diffend config
-        # @param message [Symbol] message that we want to display
         # @param report [Boolean] if true we will report the issue to diffend
         # @param raise_exception [Boolean] if true we will raise an exception
         #
@@ -18,8 +18,11 @@ module Diffend
         def call(config:, message:, exception: nil, payload: {}, report: false, raise_exception: true)
           exception_payload = prepare_exception_payload(exception, payload)
 
-          Bundler.ui.error(Diffend::HandleErrors::Messages::PAYLOAD_DUMP)
-          Bundler.ui.error(Diffend::HandleErrors::Messages.const_get(message.to_s.upcase))
+          Diffend::HandleErrors::Messages::PAYLOAD_DUMP
+            .tap(&config.logger.method(:error))
+          Diffend::HandleErrors::Messages
+            .const_get(message.to_s.upcase)
+            .tap(&config.logger.method(:error))
 
           if report
             Diffend::Request.call(
@@ -30,14 +33,14 @@ module Diffend
           raise Diffend::Errors::HandledException if raise_exception
         end
 
-        # @param config [OpenStruct] diffend config
+        # @param config [Diffend::Config]
         # @param payload [Hash]
         #
         # @return [Diffend::RequestObject]
         def build_request_object(config, payload)
           Diffend::RequestObject.new(
             config: config,
-            url: errors_url(config.project_id),
+            url: config.errors_url,
             payload: payload,
             request_method: :post
           )
@@ -54,17 +57,6 @@ module Diffend
             .call(exception, payload)
             .tap(&Diffend::HandleErrors::DisplayToStdout.method(:call))
         end
-
-        # Provides diffend errors endpoint url
-        #
-        # @param project_id [String] diffend project_id
-        #
-        # @return [String] diffend endpoint
-        def errors_url(project_id)
-          return ENV['DIFFEND_ERROR_URL'] if ENV.key?('DIFFEND_ERROR_URL')
-
-          "https://my.diffend.io/api/projects/#{project_id}/errors"
-        end
       end
     end
   end

data/lib/diffend/latest_version.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Verify if we are running latest version of the plugin
+  module LatestVersion
+    class << self
+      # Verify if we are running latest version of the plugin
+      #
+      # @param config [Diffend::Config]
+      def call(config)
+        return if config.development?
+        return if installed_version == Diffend::VERSION
+
+        print_message(config, installed_version)
+
+        exit 2
+      end
+
+      private
+
+      # @return [String] installed plugin version
+      def installed_version
+        ::Bundler::Plugin
+          .index
+          .plugin_path('diffend')
+          .basename
+          .to_s
+          .split('-')
+          .last
+      end
+
+      # @param config [Diffend::Config]
+      # @param version [Hash] installed version
+      def print_message(config, version)
+        build_message(version)
+          .tap(&config.logger.method(:error))
+      end
+
+      # @param version [Hash] installed version
+      #
+      # @return [String]
+      def build_message(version)
+        <<~MSG
+          \nYou are running an outdated version (#{version}) of the plugin, which will lead to issues.
+          \nPlease upgrade to the latest one (#{Diffend::VERSION}) by executing "rm -rf .bundle/plugin".\n
+        MSG
+      end
+    end
+  end
+end

data/lib/diffend/local_context.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Module responsible for building local context
+  module LocalContext
+    class << self
+      # Build diffend, host, packages, and platform specific information
+      #
+      # @param config [Diffend::Config]
+      # @param definition [Bundler::Definition] definition for your source
+      #
+      # @return [Hash] payload for diffend endpoint
+      def call(config, definition)
+        {
+          'diffend' => Diffend.call(config),
+          'host' => Host.call,
+          'packages' => Packages.call(config.command, definition),
+          'platform' => Platform.call
+        }.freeze
+      end
+    end
+  end
+end

data/lib/diffend/local_context/diffend.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Module responsible for building local context
+  module LocalContext
+    # Module responsible for building diffend information from local context
+    module Diffend
+      # API version
+      API_VERSION = '0.1'
+      # Platform type ruby
+      PLATFORM_TYPE = 0
+
+      private_constant :API_VERSION, :PLATFORM_TYPE
+
+      class << self
+        # Build diffend information
+        #
+        # @param config [Diffend::Config]
+        #
+        # @return [Hash]
+        def call(config)
+          {
+            'api_version' => API_VERSION,
+            'environment' => config.env,
+            'project_id' => config.project_id,
+            'type' => PLATFORM_TYPE,
+            'version' => ::Diffend::VERSION
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/diffend/local_context/host.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+module Diffend
+  # Module responsible for building local context
+  module LocalContext
+    # Module responsible for building host information from local context
+    module Host
+      class << self
+        # Build host information
+        #
+        # @return [Hash]
+        def call
+          uname = Etc.uname
+
+          {
+            'command' => command,
+            'ips' => ips,
+            'name' => uname[:nodename],
+            'system' => {
+              'machine' => uname[:machine],
+              'name' => uname[:sysname],
+              'release' => uname[:release],
+              'version' => uname[:version]
+            },
+            'tags' => tags,
+            'user' => Etc.getpwuid(Process.uid).name,
+            'pid' => Process.pid
+          }.freeze
+        end
+
+        private
+
+        # Build host command information
+        #
+        # @return [Hash]
+        def command
+          if File.exist?($PROGRAM_NAME)
+            if defined?(JRUBY_VERSION)
+              name = $PROGRAM_NAME.split('/').last.strip
+              command = "#{name} #{ARGV.join(' ')}"
+            else
+              array = `ps -p #{Process.pid} -o command=`.strip.split(' ')
+              array.shift if array.first.end_with?('bin/ruby')
+              name = array.shift.split('/').last.strip
+              command = "#{name} #{array.join(' ')}"
+            end
+
+            { 'name' => command, 'title' => '' }
+          else
+            { 'name' => ARGV.join(' '), 'title' => $PROGRAM_NAME }
+          end
+        end
+
+        # Build host ips, except localhost and loopback
+        #
+        # @return [Array<String>]
+        def ips
+          Socket.ip_address_list.map do |ip|
+            next if ip.ipv4_loopback? || ip.ipv6_loopback? || ip.ipv6_linklocal?
+
+            ip.ip_address
+          end.compact
+        end
+
+        # Build host tags
+        #
+        # @return [Array]
+        def tags
+          tags = []
+
+          if ENV.key?('GITHUB_ACTIONS')
+            tags << 'ci'
+            tags << 'ci-github'
+          end
+
+          if ENV.key?('CIRCLECI')
+            tags << 'ci'
+            tags << 'ci-circle'
+          end
+
+          tags
+        end
+      end
+    end
+  end
+end