jiminy 0.1.0.pre1

data/lib/jiminy/cli.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Jiminy
+  require "thor"
+  require "byebug"
+  class CLI < Thor
+    require "jiminy/reporting/ci_providers/circle_ci"
+    include Jiminy::Reporting::CIProviders
+
+    class WorkflowStillRunningError < StandardError; end
+    private_constant :WorkflowStillRunningError
+
+    MAX_TIMEOUT = 1800 # 1 hour
+    POLL_INTERVAL = 60 # 1 min
+
+    def self.exit_on_failure?
+      false
+    end
+
+    desc "Report results", "Reports the results of tests"
+    method_option :commit, type: :string, aliases: "c", required: true,
+                           banner: "3e078f8770743549b722382ec5d412a30b9fdcc5",
+                           desc: "The full SHA for the current HEAD commit"
+    method_option :pr_number, type: :numeric, aliases: %w[pr p], required: true,
+                              banner: "1",
+                              desc: "The GitHub PR number"
+    method_option :dry_run, type: :boolean, default: false, lazy_default: true,
+                            desc: "Print to STDOUT instead of leaving a comment on GitHub"
+    method_option :timeout, type: :numeric, aliases: %w[max-timeout], default: MAX_TIMEOUT,
+                            desc: "How long to poll CircleCI before timing out (in seconds)"
+    method_option :poll_interval, type: :numeric, aliases: %w[poll-interval], default: POLL_INTERVAL,
+                                  desc: "How frequently to poll CircleCI (in seconds)"
+    method_option :source, type: :string, default: "circleci",
+                           desc: "Where are the results.yml files we should report?"
+    def report
+      self.start_time = Time.now
+      artifact_urls = artifacts.map(&:url)
+
+      Jiminy::Reporting.report!(*artifact_urls,
+                                pr_number: options[:pr_number],
+                                dry_run: options[:dry_run])
+
+      $stdout.puts "Reported N+1s successfully"
+      exit(0)
+    end
+
+    # rubocop:disable Metrics/BlockLength
+    no_tasks do
+      attr_accessor :start_time
+
+      def poll_interval
+        options[:poll_interval] || POLL_INTERVAL
+      end
+
+      def source
+        options[:source] || :circleci
+      end
+
+      def max_timeout
+        options[:timeout] || MAX_TIMEOUT
+      end
+
+      def timed_out?
+        (Time.now - start_time) > max_timeout
+      end
+
+      def git_revision
+        options[:commit]
+      end
+
+      def pr_number
+        options[:pr_number]
+      end
+
+      def pipeline
+        @_pipeline ||= CircleCI::Pipeline.find_by_revision(git_revision: git_revision, pr_number: pr_number) or
+          abort("No such Pipeline with commit SHA #{git_revision}")
+      end
+
+      def missing_options
+        [].tap do |array|
+          array.concat("--pr-number") unless pr_number
+          array.concat("--commit") unless git_revision
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def workflow
+        @_workflow ||= begin
+          result = CircleCI::Workflow.find(pipeline_id: pipeline.id, workflow_name: Jiminy.config.ci_workflow_name)
+          if result.nil?
+            abort("Unable to find workflow called '#{Jiminy.config.ci_workflow_name}' in Pipeline #{pipeline.id}")
+          end
+
+          if result.not_run? || result.running?
+            $stdout.puts "Workflow still running..."
+            raise(WorkflowStillRunningError)
+          end
+          abort("Workflow #{result.status}—aborting...") unless result.success?
+
+          result
+        rescue WorkflowStillRunningError
+          sleep(poll_interval)
+          $stdout.puts "Retrying..."
+          retry unless timed_out?
+
+          abort("Process timed out after #{Time.now - start_time} seconds")
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+
+      def jobs
+        @_jobs ||= CircleCI::Job.all(workflow_id: workflow.id)
+      end
+
+      def artifacts
+        @_artifacts ||= begin
+          unless respond_to?(:"artifacts_from_#{source}")
+            raise ArgumentError, "Uknown value for source option #{source}"
+          end
+
+          public_send(:"artifacts_from_#{source}")
+        end
+      end
+
+      def artifacts_from_local
+        Local::Artifact.all
+      end
+
+      def artifacts_from_circle_ci
+        CircleCI::Artifact.all(job_number: jobs.first.job_number)
+      end
+      alias_method :artifacts_from_circleci, :artifacts_from_circle_ci
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/jiminy/configuration.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Jiminy
+  class Configuration
+    DEFAULT_CONFIG_READER = -> { instance_variable_get(:"@_#{__callee__}" || raise_missing_required(__callee__)) }
+    DEFAULT_CONFIG_WRITER = ->(value) { instance_variable_set(:"@_#{__callee__}"[0..-2], value) }
+
+    class MissingConfigError < StandardError
+      attr_reader :missing_config_name
+
+      def initialize(missing_config_name)
+        super()
+        @missing_config_name = missing_config_name
+      end
+
+      def message
+        <<~MESSAGE
+          You must provide a configuration value for ##{missing_config_name}
+
+          This probably means you haven't set Jiminy.config.#{missing_config_name}
+        MESSAGE
+      end
+    end
+
+    class << self
+      def define_config(name, options = {})
+        define_method(:"#{name}=", DEFAULT_CONFIG_WRITER)
+        define_method(name.to_sym, DEFAULT_CONFIG_READER)
+        defined_configs[name].merge!(options)
+      end
+
+      def defined_configs
+        @_defined_configs ||= Hash.new { |hash, key| hash[key] = { default: nil, required: true } }
+      end
+    end
+
+    define_config :ci_workflow_name, default: "build"
+
+    define_config :circle_ci_api_token
+
+    define_config :github_token
+
+    define_config :ignore_file_path, default: File.join("./jiminy_ignores.yml")
+
+    define_config :project_reponame
+
+    define_config :project_username
+
+    define_config :temp_file_location, default: File.join("./tmp/jiminy/results.yml")
+
+    def initialize
+      apply_defaults!
+    end
+
+    def repo_path
+      [project_username, project_reponame].join("/")
+    end
+
+    private
+
+    def defined_configs_with_defaults
+      self.class.defined_configs.select { |_config_name, options| options[:default] }
+    end
+
+    def required_configs
+      self.class.defined_configs.select { |_config_name, options| options[:required] }
+    end
+
+    def apply_defaults!
+      defined_configs_with_defaults.each do |config_name, options|
+        public_send(:"#{config_name}=", options[:default])
+      end
+    end
+
+    def raise_missing_required(config_name)
+      return unless required_configs.key?(config_name)
+
+      raise MissingConfigError, config_name
+    end
+  end
+
+  module ConfigurationMethods
+    def configure(&block)
+      block.call(configuration)
+    end
+
+    def configuration
+      @_configuration ||= Configuration.new
+    end
+
+    alias config configuration
+
+    def configured?
+      !!configuration
+    end
+  end
+end

data/lib/jiminy/github_apiable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module GithubAPIable
+    require "octokit"
+
+    private
+
+    def env_config
+      @_env_config ||= Reporting::CIProviders::Github::Configuration.new
+    end
+
+    def client
+      @_client ||= Octokit::Client.new(access_token: env_config.github_token)
+    end
+  end
+end

data/lib/jiminy/recording/n_plus_one.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Recording
+    class NPlusOne
+      attr_reader :file, :location
+
+      LOCATION_MATCHER = /(?<file>.+\.rb):
+        (?<line>\d+):in\s`
+        (?:block\sin\s)?
+        (?<method_name>.+)'
+      /x.freeze
+
+      EXAMPLES_COUNT = 3
+
+      def initialize(location:, queries: [])
+        @location = location.to_s.strip
+        @queries = queries
+        match = location.match(LOCATION_MATCHER)
+        @line = match[:line]
+        @method_name = match[:method_name]
+        @file = match[:file]
+        freeze
+      end
+
+      def ==(other)
+        location == other.location
+      end
+
+      def to_h
+        {
+          location => attributes
+        }
+      end
+
+      private
+
+      attr_reader :queries, :line, :method_name
+
+      def attributes
+        {
+          "file" => file,
+          "line" => line,
+          "method" => method_name,
+          "examples" => queries.take(EXAMPLES_COUNT)
+        }
+      end
+    end
+  end
+end

data/lib/jiminy/recording/prosopite_ext/send_notifications_with_tmp_file.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Recording
+    module ProsopiteExt
+      require_relative "tmp_file_recorder"
+
+      module SendNotificationsWithTmpFile
+        def prepare_results_file!
+          TmpFileRecorder.prepare_results_file!
+        end
+
+        def tmp_file=(value)
+          @tmp_file = value
+        end
+
+        def tmp_file
+          !!@tmp_file
+        end
+
+        def send_notifications
+          super
+
+          return unless Prosopite.tmp_file
+
+          # https://github.com/charkost/prosopite/blob/main/lib/prosopite.rb#L157
+          tc[:prosopite_notifications].each do |queries, backtrace|
+            absolute_location = backtrace.detect { |path| path.exclude?(Bundler.bundle_path.to_s) }
+            next unless absolute_location
+
+            relative_location = absolute_location.gsub("#{Rails.root.realpath}/", "")
+            tmp_file_recorder.record(location: relative_location, queries: queries)
+          end
+        end
+
+        private
+
+        def tmp_file_recorder
+          @_tmp_file_recorder ||= TmpFileRecorder.new
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/recording/prosopite_ext/tmp_file_recorder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Recording
+    module ProsopiteExt
+      class TmpFileRecorder
+        require_relative "../n_plus_one"
+
+        def record(location:, queries:)
+          yaml_content = File.read(Jiminy.config.temp_file_location)
+          array = YAML.safe_load(yaml_content)
+          n_plus_one = NPlusOne.new(location: location, queries: queries)
+
+          array << n_plus_one.to_h unless location_in_array?(location, array) || filepath_ignored?(n_plus_one.file)
+          File.write(Jiminy.config.temp_file_location, array.to_yaml)
+        end
+
+        private
+
+        def location_in_array?(location, array)
+          array.detect { |hash| hash.key?(location) }
+        end
+
+        def filepath_ignored?(filepath)
+          ignored_files.include?(filepath)
+        end
+
+        def ignored_files
+          @_ignored_files ||= load_ignored_files
+        end
+
+        def load_ignored_files
+          return [] unless File.exist?(Jiminy.config.ignore_file_path)
+
+          YAML.load_file(Jiminy.config.ignore_file_path) || []
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/recording/rspec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Recording
+    require "jiminy/recording/prosopite_ext/send_notifications_with_tmp_file"
+
+    module RSpec
+      require "prosopite"
+      require "jiminy/recording/test_controller_concern"
+
+      ::Prosopite.singleton_class.prepend ProsopiteExt::SendNotificationsWithTmpFile
+
+      def wrap_rspec_example(example)
+        Prosopite.tmp_file = true
+        ActionController::Base.include(Jiminy::Recording::TestControllerConcern)
+        example.run
+        Prosopite.tmp_file = false
+      end
+      Jiminy.extend(self)
+    end
+  end
+end

data/lib/jiminy/recording/test_controller_concern.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Recording
+    module TestControllerConcern
+      extend ActiveSupport::Concern
+
+      included do
+        around_action :_test_n_plus_one_detection
+      end
+
+      private
+
+      def _test_n_plus_one_detection
+        yield and return if Prosopite.scan?
+
+        begin
+          Prosopite.scan
+          yield
+        ensure
+          Prosopite.finish
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/recording.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Recording
+    abort("Jiminy::Recording must be run from a Rails app") unless defined?(Rails)
+
+    module_function
+
+    def reset_results_file!
+      Rails.root.join(File.dirname(Jiminy.config.temp_file_location)).mkpath
+      File.write(Jiminy.config.temp_file_location, [].to_yaml)
+    end
+  end
+end

data/lib/jiminy/reporting/ci_providers/circle_ci/api_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Reporting
+    module CIProviders
+      module CircleCI
+        class APIRequest
+          API_BASE = "https://circleci.com/api/v2/"
+
+          CIRCLE_TOKEN_HEADER = "Circle-Token"
+
+          def initialize(path)
+            @url = URI.join(API_BASE, path)
+          end
+
+          def perform!
+            puts url
+            response
+          end
+
+          private
+
+          attr_reader :url
+
+          def response
+            @_response ||= http.request(request)
+          end
+
+          def request
+            @_request ||= Net::HTTP::Get.new(url).tap do |req|
+              req[CIRCLE_TOKEN_HEADER] = Jiminy.config.circle_ci_api_token
+            end
+          end
+
+          def http
+            @_http ||= Net::HTTP.new(url.host, url.port).tap do |http_instance|
+              http_instance.use_ssl = true
+              http_instance.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/reporting/ci_providers/circle_ci/artifact.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Reporting
+    module CIProviders
+      module CircleCI
+        class Artifact < Base
+          define_attribute_readers :url
+
+          def self.all(job_number:)
+            fetch_api_resource("project/gh/#{Jiminy.config.repo_path}/#{job_number}/artifacts")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/reporting/ci_providers/circle_ci/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Reporting
+    module CIProviders
+      module CircleCI
+        require_relative "api_request"
+
+        class Base
+          require "uri"
+          require "net/http"
+          require "json"
+
+          attr_reader :attributes
+
+          def self.define_attribute_readers(*attr_names)
+            attr_names.each do |attr_name|
+              define_method(attr_name, -> { attributes[__callee__.to_s] })
+            end
+          end
+
+          class << self
+            attr_reader :next_token
+          end
+
+          class << self
+            attr_writer :next_token
+          end
+
+          def self.fetch_api_resource(path)
+            response = APIRequest.new(path).perform!
+            raise "Error response: #{response.body}" unless response.is_a?(Net::HTTPOK)
+
+            json_body = JSON.parse(response.read_body)
+            self.next_token = json_body["next_page_token"]
+            json_body["items"].map { |attributes| new(attributes) }
+          end
+
+          def initialize(attributes = {})
+            @attributes = attributes.transform_keys!(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/reporting/ci_providers/circle_ci/job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Reporting
+    module CIProviders
+      module CircleCI
+        class Job < Base
+          define_attribute_readers :job_number
+
+          def self.all(workflow_id:)
+            fetch_api_resource("workflow/#{workflow_id}/job")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/reporting/ci_providers/circle_ci/pipeline.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Reporting
+    module CIProviders
+      module CircleCI
+        require_relative "base"
+        require_relative "vcs"
+
+        class Pipeline < Base
+          MAX_PAGE_LOOKUP = 20
+
+          define_attribute_readers :id, :project_slug, :vcs
+
+          def self.find_by_revision(git_revision:, pr_number:)
+            attempt_count = 0
+            matching_pipeline = nil
+            until matching_pipeline || attempt_count >= MAX_PAGE_LOOKUP
+              page_pipelines = fetch_page_from_api(next_token)
+              matching_pipeline = page_pipelines.detect { |p| pipeline_match?(p, git_revision, pr_number) }
+              attempt_count += 1
+            end
+            matching_pipeline
+          end
+
+          def self.fetch_page_from_api(page_token)
+            query = "org-slug=gh/#{Jiminy.config.project_username}&mine=false"
+            query += "&page-token=#{page_token}" if page_token
+            url = "pipeline?#{query}"
+            fetch_api_resource(url)
+          end
+
+          def self.pipeline_match?(pipeline, git_revision, _pr_number)
+            return false unless pipeline.project_slug.to_s.downcase.end_with?(Jiminy.config.repo_path.downcase)
+
+            pipeline.vcs.revision == git_revision
+
+            # TODO: Get PR comparison working too
+            # pipeline.vcs.review_url.end_with?("pull/#{pr_number}")
+          end
+
+          def vcs
+            VCS.new(attributes["vcs"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/reporting/ci_providers/circle_ci/vcs.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Reporting
+    module CIProviders
+      module CircleCI
+        class VCS < Base
+          define_attribute_readers :revision, :review_url
+        end
+      end
+    end
+  end
+end

data/lib/jiminy/reporting/ci_providers/circle_ci/workflow.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Jiminy
+  module Reporting
+    module CIProviders
+      module CircleCI
+        class Workflow < Base
+          # Link to states: https://circleci.com/docs/2.0/workflows/#states
+          SUCCESS = "success"
+          FAILED = "failed"
+          NOT_RUN = "not run"
+          RUNNING = "running"
+
+          define_attribute_readers :id, :name, :status
+
+          def self.find(pipeline_id:, workflow_name:)
+            url = "pipeline/#{pipeline_id}/workflow"
+            collection = fetch_api_resource(url)
+            collection.detect { |w| w.name.to_s == workflow_name.to_s }
+          end
+
+          def success?
+            status == SUCCESS
+          end
+
+          def running?
+            status == RUNNING
+          end
+
+          def not_run?
+            status == NOT_RUN
+          end
+
+          def failed?
+            status == FAILED
+          end
+        end
+      end
+    end
+  end
+end