gems_bond 1.0.4 → 1.1.0

data/lib/gems_bond/helpers/concurrency_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module GemsBond
+  module Helpers
+    # Concurrency helper
+    module ConcurrencyHelper
+      # Run each item concurrently
+      # @param items [Boolean] items to process
+      # @yield [item] apply to each item
+      # @return [void]
+      # @example
+      #   each_concurrently(words) do |word|
+      #     dictionnary_api.fetch(word)
+      #   end
+      def each_concurrently(items)
+        threads = []
+        items.each do |item|
+          threads << Thread.new { block_given? ? yield(item) : item }
+        end
+        threads.each(&:join)
+      end
+    end
+  end
+end

data/lib/gems_bond/helpers/formatting_helper.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module GemsBond
+  module Helpers
+    # Formatting helper
+    module FormattingHelper
+      MISSING = "-"
+
+      module_function
+
+      # Returns a date with a readable format
+      # @param date [Date]
+      # @return [String]
+      # @example
+      #   human_date(Date.new(2017, 11, 19)) #=> "2007-11-19"
+      #   human_date(nil) #=> "-"
+      def human_date(date)
+        return MISSING if date.nil?
+
+        date.strftime("%F")
+      end
+
+      # Returns a number with a readable format
+      # @param date [Integer]
+      # @return [String]
+      # @example
+      #   human_number(1_000_000) #=> "1 000 000"
+      #   human_number(nil) #=> "-"
+      def human_number(number)
+        return MISSING if number.nil?
+
+        number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1 ")
+      end
+
+      # Returns score out of 100
+      # @param date [Float]
+      # @return [String]
+      # @example
+      #   human_score(0.5) #=> "50"
+      #   human_score(nil) #=> "-"
+      def human_score(score)
+        return MISSING if score.nil?
+
+        (score * 100).round
+      end
+    end
+  end
+end

data/lib/gems_bond/printers/csv.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "csv"
+require "gems_bond/printers/printer"
+
+module GemsBond
+  module Printers
+    # Prints CSV file
+    class CSV < Printer
+      DATA = %w[
+        name
+        homepage
+        source_code_uri
+        version
+        last_version
+        last_version_date
+        days_since_last_version
+        last_commit_date
+        days_since_last_commit
+        downloads_count
+        contributors_count
+        stars_count
+        forks_count
+        open_issues_count
+      ].freeze
+
+      private
+
+      # Prints data into a CSV file
+      # @return [void]
+      def print
+        ::CSV.open("#{DIRECTORY_PATH}/spy.csv", "w") do |csv|
+          csv << headers
+          @gems.each do |gem|
+            csv << row(gem)
+          end
+        end
+      end
+
+      # Generates CSV headers
+      # @return [Array]
+      def headers
+        DATA
+      end
+
+      # Generates CSV row for a gem
+      # @param gem [GemsBond::Gem]
+      # @return [Array]
+      def row(gem)
+        DATA.map { |data| gem.public_send(data) }
+      end
+    end
+  end
+end

data/lib/gems_bond/printers/html.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "erb"
+require "gems_bond/printers/printer"
+require "gems_bond/helpers/formatting_helper"
+
+module GemsBond
+  module Printers
+    # Prints HTML file
+    class HTML < Printer
+      include GemsBond::Helpers::FormattingHelper
+
+      private
+
+      # Prints data into a file
+      # @return [void]
+      def print
+        File.open("#{DIRECTORY_PATH}/spy.html", "w") do |file|
+          file.puts content
+        end
+      end
+
+      # Returns the ERB template
+      # @return [String]
+      def template
+        File.read(File.join(File.dirname(__FILE__), "../../../views/", "diagnosis.erb"))
+      end
+
+      # Returns the HTML content
+      # @return [String]
+      def content
+        ERB.new(template).result(binding)
+      end
+
+      # Returns a color depending on the gap to last released version
+      # @param gap [Integer]
+      # @return [String] branding for Bootstrap use
+      def version_color(gap)
+        return "secondary" if gap.nil?
+        return "success" if gap.zero?
+
+        gap < 3 ? "warning" : "danger"
+      end
+
+      # Returns a color depending on the score value
+      # @param score [Float] in [0, 1]
+      # @return [String] branding for Bootstrap use
+      def color(score)
+        return "secondary" if score.nil?
+
+        if score < 0.33
+          "danger"
+        elsif score < 0.66
+          "warning"
+        else
+          "success"
+        end
+      end
+    end
+  end
+end

data/lib/gems_bond/printers/printer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module GemsBond
+  module Printers
+    # Prints HTML file
+    class Printer
+      DIRECTORY_PATH = "gems_bond"
+
+      # Initializes an instance
+      # @param gems [Array<GemsBond::Gem>]
+      # @return [GemsBond::Printers]
+      def initialize(gems)
+        @gems = gems
+      end
+
+      # Manages print
+      # @return [void]
+      def call
+        format = self.class.name.split("::").last
+        puts "\nPreparing data for printing results into #{format} file..."
+        create_directory
+        print
+        puts "Open file gems_bond/spy.#{format.downcase} to display the results."
+      end
+
+      private
+
+      # Prints data into a file
+      # @return [void]
+      def print
+        raise NotImplementedError, "Subclasses must implement a call method."
+      end
+
+      # Creates the "gems_bond" directory if absent
+      def create_directory
+        return if File.directory?(DIRECTORY_PATH)
+
+        FileUtils.mkdir_p(DIRECTORY_PATH)
+      end
+
+      # Returns gems sorted by the average_score
+      # @return [Array<GemsBond::Gem>]
+      # @note gems with no average_score are put at the end
+      def sorted_gems
+        # sort with putting gems without average_score at the end
+        @gems.sort do |a, b|
+          if a.average_score && b.average_score
+            a.average_score <=> b.average_score
+          else
+            a.average_score ? -1 : 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gems_bond/printers/stdout.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "gems_bond/helpers/formatting_helper"
+
+module GemsBond
+  module Printers
+    # Inspects gem and outputs the result
+    class Stdout < SimpleDelegator
+      include GemsBond::Helpers::FormattingHelper
+
+      # Logs gem information
+      # @return [void]
+      def call
+        line_break
+        puts "--- #{name} info ---".upcase
+        line_break
+        puts description
+        line_break
+        log_url
+        log_version
+        log_counts
+        log_activity
+        line_break
+        return unless unknown
+
+        puts "Note: this gem is not listed in your current dependencies!"
+        line_break
+      end
+
+      private
+
+      # Adds a line break
+      def line_break
+        puts ""
+      end
+
+      # Logs url information
+      def log_url
+        url = source_code_uri || homepage || "?"
+        puts "- url: #{url}"
+      end
+
+      # Logs version information
+      def log_version
+        return unless version_gap
+
+        alert = version_gap.zero? ? "(up-to-date)" : "(#{version_gap} behind #{last_version})"
+        puts "- version: #{version} #{alert}"
+      end
+
+      # Logs counts (downloads, forks, stars, contributors) information
+      def log_counts
+        print "- counts: "
+        content = []
+        add_count =
+          lambda do |type|
+            count = public_send("#{type}_count")
+            return unless count
+
+            content << "#{human_number(count)} #{type}"
+          end
+
+        add_count.call("downloads")
+        add_count.call("forks")
+        add_count.call("stars")
+        add_count.call("contributors")
+
+        puts content.empty? ? "unknown" : content.join(" | ")
+      end
+
+      # Logs activity information
+      def log_activity
+        print "- activity: "
+        content = []
+        add_days_since_last =
+          lambda do |days, type|
+            return if days.nil?
+
+            unit = days.zero? || days > 1 ? "days" : "day"
+            content << "#{human_number(days)} #{unit} since last #{type}"
+          end
+
+        add_days_since_last.call(days_since_last_version, "version")
+        add_days_since_last.call(days_since_last_commit, "commit")
+
+        puts content.empty? ? "unkown" : content.join(" | ")
+      end
+    end
+  end
+end

data/lib/gems_bond/railtie.rb

@@ -4,7 +4,8 @@ module GemsBond
   # Makes Rails aware of the tasks
   class Railtie < Rails::Railtie
     rake_tasks do
-      load "tasks/gems_bond/spy.rake"
+      load "tasks/gems_bond/spy/one.rake"
+      load "tasks/gems_bond/spy/all.rake"
     end
   end
 end

data/lib/gems_bond/spy/all.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "gems_bond/gem"
+require "gems_bond/helpers/concurrency_helper"
+require "gems_bond/printers/html"
+require "gems_bond/printers/csv"
+
+module GemsBond
+  module Spy
+    # Inspects gems and outputs the result in HTML and CSV files
+    class All
+      include GemsBond::Helpers::ConcurrencyHelper
+
+      # Number of fetch retries before skipping gem
+      RETRIES = 2
+
+      # Fetches and scores gems then prints result
+      # @return [void]
+      def call
+        timer do
+          fetch_gems_data
+          GemsBond::Printers::HTML.new(gems).call
+          GemsBond::Printers::CSV.new(gems).call
+        end
+      end
+
+      private
+
+      # Returns number of gems
+      # @return [Integer]
+      def gems_count
+        @gems_count ||= gems.count
+      end
+
+      # Starts a timer and executes given block
+      # @yieldparam [Proc] code to execute and time
+      # @return [void] (stdout)
+      def timer
+        start_at = Time.now
+        yield
+        seconds = Time.now - start_at
+        time_per_gem_text = "#{(seconds / Float(gems_count)).round(2)} second(s) per gem"
+        puts "\nIt took #{seconds} second(s) to spy #{gems_count} gem(s) (#{time_per_gem_text})."
+      end
+
+      # Returns list of gems to spy
+      # @return [Array<GemsBond::Gem>]
+      def gems
+        @gems ||=
+          Bundler.load.current_dependencies.map do |dependency|
+            GemsBond::Gem.new(dependency)
+          end
+      end
+
+      # Fetches data for each gem
+      # @return [void] (mutate gems)
+      # @note use concurrency to fetch quickly fetch data from APIs
+      def fetch_gems_data
+        puts "Fetching data for..."
+        # slice 100 to avoid too many requests on RubyGems and GitHub APIs
+        gems.each_slice(100) do |batch|
+          each_concurrently(batch) do |gem|
+            begin
+              retries ||= 0
+              # set verbose to true to stdout the gem name
+              gem.prepare_data(verbose: true)
+            # rescue SocketError, Faraday::ConnectionFailed...
+            rescue StandardError
+              (retries += 1) <= RETRIES ? retry : nil
+            end
+          end
+        end
+      end
+
+      # Starts a thread to process the given gem
+      # @param gem [GemsBond::Gem] gem to process
+      # @note if there is a connection/API error
+      #   retry or rescue if too many retries
+      def gem_thread(gem)
+        Thread.new do
+          begin
+            retries ||= 0
+            # set verbose to true to stdout the gem name
+            gem.prepare_data(verbose: true)
+          # rescue SocketError, Faraday::ConnectionFailed...
+          rescue StandardError
+            (retries += 1) <= RETRIES ? retry : nil
+          end
+        end
+      end
+    end
+  end
+end