myprecious 0.0.8 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5d502021d1c25f2475553b82cb157470bce16f0a2e0f9680dcfa22a0acd47e6
-  data.tar.gz: 0bfea940fdaa87306851066fd19a90ff5cb871eb2ad43b221a3c9949086b2c79
+  metadata.gz: be0d5a3297a77bea22a403968fa7c3a23f2fd7c2d4ce96b957c832788f29de91
+  data.tar.gz: d82b540dbb7be2ffb7601fe571cc07482d2fbe87563b8d78d937bc791bd22d3f
 SHA512:
-  metadata.gz: edb4f9229db398ec9705c1a2a8348ee0a5e5ddf181050d5aaf0decb854a102a3996983ba96074af9833734e09bb28345d1edc6711932277e8819c5fd8f5c4527
-  data.tar.gz: ff0fb7720fa0f961f01a9f48d77b75e958cb6581b54d93c2520d899eb9e0c2abac075fee2322b6f9b79e7c004984da96d7572e69f79250212fd365be96e03980
+  metadata.gz: 79e7317fa010abdc6ab9d7207d7be1229d85e2ba2a53cb2225e1a8bed7c95063d51294fab4917f1449e106210e1aa3ef5c52fa743bde9e6fb85f582a6942694a
+  data.tar.gz: 0fb7d8ec2c159fe58867b2f5cbbfa95a9a27c7f0e6f020ea2f69fb2ecf55b49b2ed385857c3a6162670c07a39871b54724f2005c71dd6897e691438701d33316

data/bin/myprecious

@@ -1,4 +1,8 @@
 #!/usr/bin/env ruby
 
+require 'rubygems'
 require 'myprecious'
-puts MyPrecious.update
+
+MyPrecious::Program.run(
+  on_error: (:exit_program! if ENV['TRACE_ERRORS'].to_s.empty?)
+)

data/lib/myprecious.rb

@@ -1,121 +1,550 @@
-require 'gems'
 require 'date'
 require 'git'
+require 'ostruct'
+require 'pathname'
+require 'rake/toolkit_program'
+require 'uri'
 
-class MyPrecious
-  def self.update
-    g = Git.open(Dir.pwd)
-    repo_name = g.repo.path.split(".git")[0].split("/").last
-    repo_name = repo_name + "-dependency-tracking"
-    gem_lines = {}
-    gem_name_pos = 0
-    gem_version_pos = 1
-    gem_latest_pos = 2
-    gem_date_pos = 3
-    gem_age_pos = 4
-    gem_license_pos = 5
-    gem_change_pos = 6
-    default_length = 7
-    already_fetched_gems = {}
-    if File.file?(repo_name+'.md')
-      File.open(repo_name+".md", "r").each_with_index do |line, line_number|
-        #puts line + " dds " + line_number.to_s
-        word_array = line.split('|')
-        if line_number == 1
-          default_length = word_array.size
-          word_array.each_with_index do |word, index|
-            if word.strip == 'Gem'
-              gem_name_pos = index
-            elsif word.strip == 'Our Version'
-              gem_version_pos = index
-            elsif word.strip == 'Latest Version'
-              gem_latest_pos = index
-            elsif word.strip == 'Date available'
-              gem_date_pos = index
-            elsif word.strip == 'Age (in days)'
-              gem_age_pos = index
-            elsif word.strip == 'License Type'
-              gem_change_pos = index
-            elsif word.strip == 'Change Log'
-              gem_change_pos = index
-            end
+# Declare the module here so it doesn't cause problems for files in the
+# "myprecious" directory (or _does_ cause problems if they try to declare
+# it a class)
+module MyPrecious
+  DATA_DIR = Pathname('~/.local/lib/myprecious').expand_path
+  ONE_DAY = 60 * 60 * 24
+end
+require 'myprecious/data_caches'
+
+module MyPrecious
+  extend Rake::DSL
+  
+  Program = Rake::ToolkitProgram
+  Program.title = "myprecious Dependecy Reporting Tool"
+  
+  def self.common_program_args(parser, args)
+    parser.on(
+      '-o', '--out FILE',
+      "Output file to generate",
+    ) {|fpath| args.output_file = Pathname(fpath)}
+    
+    args.target = Pathname.pwd
+    parser.on(
+      '-C', '--dir PATH',
+      "Path to inspect",
+    ) do |fpath|
+      fpath = Pathname(fpath)
+      parser.invalid_args!("#{fpath} does not exist.") unless fpath.exist?
+      args.target = fpath
+    end
+    
+    parser.on(
+      '--[no-]cache',
+      "Control caching of gem information"
+    ) {|v| MyPrecious.caching_disabled = v}
+  end
+  
+  # Declare the tasks exposed as subcommands in this block
+  Program.command_tasks do
+    desc "Generate report on Ruby gems"
+    task('ruby-gems').parse_args(into: OpenStruct.new) do |parser, args|
+      parser.expect_positional_cardinality(0)
+      common_program_args(parser, args)
+    end
+    task 'ruby-gems' do
+      require 'myprecious/ruby_gems'
+      args = Program.args
+      out_fpath = args.output_file || Reporting.default_output_fpath(args.target)
+      
+      col_order = Reporting.read_column_order_from(out_fpath)
+      
+      # Get all gems used via RubyGemInfo.each_gem_used, accumulating version requirements
+      gems = RubyGemInfo.accum_gem_lock_info(args.target)
+      
+      out_fpath.open('w') do |outf|
+        # Header
+        outf.puts "Last updated: #{Time.now.rfc2822}; Use for directional purposes only, this data is not real time and might be slightly inaccurate"
+        outf.puts
+        
+        Reporting.header_lines(
+          col_order,
+          RubyGemInfo.method(:col_title)
+        ).each {|l| outf.puts l}
+        
+        # Iterate all gems in name order, pulling column values from the RubyGemInfo objects
+        gems.keys.sort_by {|n| n.downcase}.map {|name| gems[name]}.each do |gem|
+          Reporting.on_dependency(gem.name) do
+            outf.puts col_order.markdown_columns(MarkdownAdapter.new(gem))
           end
-        elsif line_number > 2
-          gem_name_index = word_array[gem_name_pos].strip
-          #extract just the name of the gem from the first column
-          #since that column contains a markdown-formatted hyperlink
-          gem_name_index = gem_name_index[/\[(.*?)\]/,1]
-          gem_lines[gem_name_index] = line_number
         end
-
       end
-      #puts gem_lines
-    else
-      File.open(repo_name+'.md', 'w') { |write_file|
-        write_file.puts "Last updated:" + Date.today.to_s + "; Use for directional purposes only, this data is not real time and might be slightly inaccurate" + "\n\n"
-        write_file.puts "Gem | Our Version | Latest Version | Date available | Age (in days) | License Type | Change Log"
-        write_file.puts "--- | --- | --- | --- | --- | --- | ---"
-      }
+        
     end
-
-    file = File.new("Gemfile", "r")
-
-    final_write = File.readlines(repo_name+'.md')
-
-    while (line = file.gets)
-      gem_line = line.strip
-      if (gem_line.include? 'gem') && !gem_line.start_with?('#') && !gem_line.start_with?('source')
-        name = gem_line.split(' ')[1].split(',')[0].tr(" '\"", "")
+    
+    desc "Generate report on Python packages"
+    task('python-packages').parse_args(into: OpenStruct.new) do |parser, args|
+      parser.expect_positional_cardinality(0)
+      common_program_args(parser, args)
+      
+      parser.on(
+        '-r', '--requirements-file FILE',
+        "requirements.txt-style file to read"
+      ) do |file|
+        if args.requirements_file
+          invalid_args!("Only one requirements file may be specified.")
+        end
+        args.requirements_file = file
+      end
+    end
+    task 'python-packages' do
+      require 'myprecious/python_packages'
+      args = Program.args
+      out_fpath = args.output_file || Reporting.default_output_fpath(args.target)
+      
+      col_order = Reporting.read_column_order_from(out_fpath)
+      
+      req_file = args.requirements_file
+      req_file ||= PyPackageInfo.guess_req_file(args.target)
+      req_file = args.target.join(req_file) unless req_file.nil?
+      if req_file.nil? || !req_file.exist?
+        invalid_args!("Unable to guess requirement file name; specify with '-r FILE' option.")
+      end
+      pkgs = PyPackageInfo::Reader.new(req_file).each_installed_package
+      
+      out_fpath.open('w') do |outf|
+        # Header
+        outf.puts "Last updated: #{Time.now.rfc2822}; Use for directional purposes only, this data is not real time and might be slightly inaccurate"
+        outf.puts
+        
+        Reporting.header_lines(
+          col_order,
+          PyPackageInfo.method(:col_title)
+        ).each {|l| outf.puts l}
+        
+        pkgs = pkgs.to_a
+        pkgs.sort_by! {|pkg| pkg.name.downcase}
+        pkgs.each do |pkg|
+          Reporting.on_dependency(pkg.name) do
+            outf.puts col_order.markdown_columns(MarkdownAdapter.new(pkg))
+          end
+        end
+      end
+    end
+    
+    desc "Clear all myprecious data caches"
+    task('clear-caches').parse_args(into: OpenStruct.new) do |parser, args|
+      args.prompt = true
+      parser.on('--[no-]confirm', "Control confirmation prompt") {|v| args.prompt = v}
+      
+      # This option exists to force users to specify the full "--no-confirm"
+      parser.on('--no-confir', "Warn about incomplete --no-confirm") do
+        parser.invalid_args!("Incomplete --no-confirm flag")
+      end
+    end
+    task 'clear-caches' do
+      # Load all "myprecious/*.rb" files so we know where all the caches are
+      Dir[File.expand_path('myprecious/*.rb', __dir__)].each {|f| require f}
+      
+      next if Program.args.prompt && !yes_no('Delete all cached data (y/n)?')
+      MyPrecious.data_caches.each do |cache|
         begin
-          puts name + " is being fetched, and processed"
-          gems_latest_info = Gems.info name
-          current_version = Gem::Specification.find_all_by_name(name).max ? Gem::Specification.find_all_by_name(name).max.version : gems_latest_info["version"]
-
-         gems_info = Gems.versions name
-          latest_build = ''
-          gems_info.each do |gem_info|
-            if gem_info["number"].to_s == gems_latest_info["version"].to_s
-              latest_build = Date.parse gem_info["built_at"]
-            end
-            if gem_info["number"].to_s == current_version.to_s && !already_fetched_gems[name]
-              already_fetched_gems[name] = true
-              current_build = Date.parse gem_info["built_at"]
-
-              days_complete = latest_build - current_build
-              #puts name
-              #puts gem_lines
-              if gem_lines[name].nil?
-                array_to_write = Array.new(default_length) { |i| "" }
-              else
-                array_to_write = final_write[gem_lines[name]].split('|')
-              end
-              array_to_write[gem_name_pos] = "[" + name + "]" + "(" + gems_latest_info["homepage_uri"].to_s  + ")"
-              array_to_write[gem_version_pos] = current_version.to_s
-              array_to_write[gem_latest_pos] = gems_latest_info["version"].to_s
-              array_to_write[gem_date_pos] = (latest_build).to_s
-              array_to_write[gem_age_pos] = days_complete.to_i.to_s
-              if !gem_info["licenses"].nil?
-                array_to_write[gem_license_pos] = gem_info["licenses"][0]
-              else
-                array_to_write[gem_license_pos] = "N/A"
-              end
-              array_to_write[gem_change_pos] = gems_latest_info["changelog_uri"].to_s + "\n"
-              if !gem_lines[name].nil?
-                final_write[gem_lines[name]] = array_to_write.join("|")
-              else
-                final_write << array_to_write.join("|")
-              end
-            end
+          rm_r cache
+        rescue Errno::ENOENT
+          # No problem, we wanted to delete this anyway
+        end
+      end
+    end
+  end
+  
+  ##
+  # Prompt user for a yes/no answer
+  #
+  # It doesn't matter if they've redirected STDIN/STDOUT -- this grabs the TTY
+  # directly.
+  #
+  def self.yes_no(prompt)
+    Pathname('/dev/tty').open('r+') do |term|
+      loop do
+        term.write("#{prompt} ")
+        case term.gets[0..-2]
+        when 'y', 'Y', 'yes', 'Yes', 'YES'
+          return true
+        when 'n', 'N', 'no', 'No', 'NO'
+          return false
+        end
+      end
+    end
+  end
+  
+  ##
+  # Tool for getting information about the Git repository associated with a
+  # directory
+  #
+  class GitInfoExtractor
+    URL_PATTERN = /\/([^\/]+)\.git$/
+    
+    def initialize(dir)
+      super()
+      @dir = dir
+    end
+    attr_reader :dir
+    
+    def git_info
+      @git_info ||= Git.open(self.dir)
+    end
+    
+    def origin_remote
+      git_info.remotes.find {|r| r.name == 'origin'}
+    end
+    
+    def repo_name
+      @repo_name ||= (URL_PATTERN =~ origin_remote.url) && $1
+    end
+  end
+  
+  ##
+  # Common behavior in dependency report generation
+  #
+  # The methods here are not specific to any language or dependency management
+  # framework.  They do work with ColumnOrder and an expected set of attributes
+  # on the dependency information objects.
+  #
+  module Reporting
+    ##
+    # Compute the default output filepath for a directory
+    #
+    def default_output_fpath(dir)
+      dir / (GitInfoExtractor.new(dir).repo_name + "-dependency-tracking.md")
+    end
+    module_function :default_output_fpath
+    
+    ##
+    # Read the column order from the file at the given path
+    #
+    # If +fpath+ indicates a file that does not exist, return the default
+    # ColumnOrder.
+    #
+    def read_column_order_from(fpath)
+      result = ColumnOrder.new
+      begin
+        prev_line = nil
+        fpath.open {|inf| inf.each_line do |line|
+          if prev_line && /^-+(?:\|-+)*$/ =~ line.gsub(' ', '')
+            result.read_order_from_headers(prev_line)
+            break
           end
-        rescue Exception => e
-          puts e
-          puts name
+          prev_line = line
+        end}
+      rescue Errno::ENOENT
+        # No problem
+      end
+      return result
+    end
+    module_function :read_column_order_from
+    
+    ##
+    # Generate header lines for the output Markdown table
+    #
+    # Returns an Array of strings, currently two lines giving header text and
+    # divider row.
+    #
+    def header_lines(order, titlizer)
+      col_titles = order.map {|c| titlizer.call(c)}
+      
+      # Check that all attributes in #order round-trip through the title name
+      order.zip(col_titles) do |attr, title|
+        unless title.kind_of?(Symbol) || ColumnOrder.col_from_text_name(title) == attr
+          raise "'#{attr}' does not round-trip (rendered as #{result.inspect})"
         end
       end
+      
+      return [
+        col_titles.join(" | "),
+        (["---"] * col_titles.length).join(" | "),
+      ]
+    end
+    module_function :header_lines
+    # TODO: Mark dependencies with colors a la https://stackoverflow.com/a/41247934
+    
+    ##
+    # Converts an attribute name to the column title for generic attributes
+    #
+    # Dependency info classes (like RubyGemInfo) can delegate common column
+    # title generation to this function.
+    #
+    def common_col_title(attr)
+      case attr
+      when :current_version then 'Our Version'
+      when :age then 'Age (in days)'
+      when :latest_version then 'Latest Version'
+      when :latest_released then 'Date Available'
+      when :recommended_version then 'Recommended Version'
+      when :license then 'License Type'
+      when :changelog then 'Change Log'
+      when :obsolescence then 'How Bad'
+      else
+        warn("'#{attr}' column does not have a mapped name")
+        attr
+      end
+    end
+    module_function :common_col_title
+    
+    ##
+    # Determine obsolescence level from days
+    #
+    # Returns one of +nil+, +:mild+, +:moderate+, or +:severe+.
+    #
+    # +at_least_moderate:+ allows putting a floor of +:moderate+ obsolescence
+    # on the result.
+    #
+    def obsolescence_by_age(days, at_least_moderate: false)
+      return case 
+      when days < 270
+        at_least_moderate ? :moderate : nil
+      when days < 500
+        at_least_moderate ? :moderate : :mild
+      when days < 730
+        :moderate
+      else
+        :severe
+      end
+    end
+    module_function :obsolescence_by_age
+    
+    ##
+    # Wrap output from processing of an individual dependency with intro and
+    # outro messages
+    #
+    def on_dependency(name)
+      progress_out = $stdout
+      progress_out.puts("--- Reporting on #{name}...")
+      yield
+      progress_out.puts("    (done)")
+    end
+    module_function :on_dependency
+  end
+  
+  ##
+  # Order of columns in a Markdown table
+  #
+  # Contains the default column ordering when constructed.  Columns are
+  # identified by the Symbol commonly used as an attribute on a dependency
+  # info object (e.g. RubyGemInfo instance).  Objects of this class behave
+  # to some extent like frozen Array instances.
+  #
+  class ColumnOrder
+    DEFAULT = %i[name current_version age latest_version latest_released recommended_version license changelog].freeze
+    COLUMN_FROM_TEXT_NAME = {
+      'gem' => :name,
+      'package' => :name,
+      'module' => :name,
+      'our version' => :current_version,
+      'how bad' => :obsolescence,
+      'latest version' => :latest_version,
+      'date available' => :latest_released,
+      'age (in days)' => :age,
+      'license type' => :license,
+      /change ?log/ => :changelog,
+      'recommended version' => :recommended_version,
+    }
+    
+    def initialize
+      super
+      @order = DEFAULT
+    end
+    
+    ##
+    # Get the +n+-th column attribute Symbol
+    #
+    def [](n)
+      @order[n]
+    end
+    
+    def length
+      @order.length
+    end
+    
+    def each(&blk)
+      @order.each(&blk)
+    end
+    include Enumerable
+    
+    ##
+    # Update the column order to match those in the given line
+    #
+    # Columns not included in the line are appended in the order they
+    # appear in the default order.
+    #
+    def read_order_from_headers(headers_line)
+      headers = headers_line.split('|').map {|h| h.strip.squeeze(' ')}
+      @order = headers.map {|h| self.class.col_from_text_name(h)}.compact
+      
+      # Add in any missing columns at the end
+      @order.concat(DEFAULT - @order)
+      
+      return @order.dup
+    end
+    
+    ##
+    # Render a line to include in a Markdown table for the given dependency
+    #
+    # The dependency must know how to respond to (Ruby) messages (i.e.
+    # have attributes) for all columns currently included in the order as
+    # represented by this instance.
+    #
+    def markdown_columns(dependency)
+      map {|attr| dependency.send(attr)}.join(" | ")
+    end
+    
+    ##
+    # Given a text name, derive the equivalent column attribute
+    #
+    def self.col_from_text_name(n)
+      n = n.downcase
+      entry = COLUMN_FROM_TEXT_NAME.find {|k, v| k === n}
+      return entry && entry[1]
+    end
+  end
+  
+  ##
+  # Extension of String that can accomodate some additional commentary
+  #
+  # The +update_info+ attribute is used to pass information about changes
+  # to licensing between the current and recommended version of a dependency,
+  # and may be +nil+.
+  #
+  class LicenseDescription < String
+    attr_accessor :update_info
+  end
+  
+  ##
+  # Dependency info wrapper to generate nice Markdown columns
+  #
+  # This wrapper takes basic data from the underlying dependency info object
+  # and returns enhanced Markdown for selected columns (e.g. +name+).
+  #
+  class MarkdownAdapter
+    def initialize(dep)
+      super()
+      @dependency = dep
+    end
+    attr_reader :dependency
+    
+    ##
+    # Generate Markdown linking the +name+ to the homepage for the dependency
+    #
+    def name
+      cswatch = begin
+        color_swatch + ' '
+      rescue StandardError
+        ''
+      end
+      "#{cswatch}[#{dependency.name}](#{dependency.homepage_uri})"
+    rescue StandardError
+      dependency.name
+    end
+    
+    ##
+    # Include information about temporal difference between current and
+    # recommended versions
+    #
+    def recommended_version
+      recommended_version = dependency.recommended_version
+      if dependency.current_version < recommended_version
+        span_comment = begin
+          if days_newer = dependency.days_between_current_and_recommended
+            " -- #{days_newer} days newer"
+          else
+            ""
+          end
+        end
+        "**#{recommended_version}**#{span_comment}"
+      else
+        recommended_version
+      end
+    rescue StandardError
+      recommended_version || "(error)"
+    end
+    
+    ##
+    # Include update info in the license column
+    #
+    def license
+      value = dependency.license
+      if value.update_info
+        "#{value}<br/>(#{value.update_info})"
+      else
+        value
+      end
+    rescue StandardError
+      "(error)"
+    end
+    
+    ##
+    # Render short links for http: or https: changelog URLs
+    #
+    def changelog
+      base_val = begin
+        dependency.changelog
+      rescue StandardError
+        return "(error)"
+      end
+      
+      begin
+        uri = URI.parse(base_val)
+        if ['http', 'https'].include?(uri.scheme)
+          return "[on #{uri.hostname}](#{base_val})"
+        end
+      rescue StandardError
+      end
+      return base_val
+    end
+    
+    def obsolescence
+      color_swatch
+    rescue StandardError
+      ''
+    end
+    
+    ##
+    # Get a CSS-style hex color code corresponding to the obsolescence of the dependency
+    #
+    def color
+      case dependency.obsolescence
+      when :mild then "dde418"
+      when :moderate then "f9b733"
+      when :severe then "fb0e0e"
+      else "4dda1b"
+      end
+    end
+    
+    ##
+    # Markdown for an obsolescence color swatch
+    # 
+    # Sourced from: https://stackoverflow.com/a/41247934
+    #
+    def color_swatch
+      "![##{color}](https://placehold.it/15/#{color}/000000?text=+)"
+    end
+    
+    ##
+    # Delegate other attribute queries to the base dependency object
+    #
+    # Errors are caught and rendered as "(error)"
+    #
+    def method_missing(meth, *args, &blk)
+      dependency.send(meth, *args, &blk)
+    rescue NoMethodError
+      raise
+    rescue StandardError
+      "(error)"
+    end
+  end
+  
+  module URIModuleMethods
+    def try_parse(s)
+      parse(s)
+    rescue URI::InvalidURIError
+      nil
     end
-    File.open(repo_name+'.md', 'w') { |f| f.write(final_write.join) }
-    file.close
   end
+  URI.extend(URIModuleMethods)
 end
-
-MyPrecious.update