repofetch 0.4.0

data/lib/repofetch/github.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'action_view'
+require 'octokit'
+require 'optparse'
+require 'repofetch'
+
+class Repofetch
+  # Adds support for GitHub repositories.
+  class Github < Repofetch::Plugin
+    include ActionView::Helpers::NumberHelper
+
+    HTTP_REMOTE_REGEX = %r{https?://github\.com/(?<owner>[\w.\-]+)/(?<repository>[\w.\-]+)}.freeze
+    SSH_REMOTE_REGEX = %r{git@github\.com:(?<owner>[\w.\-]+)/(?<repository>[\w.\-]+)}.freeze
+    ASCII = File.read(File.expand_path('github/ASCII', __dir__))
+
+    attr_reader :owner, :repository
+
+    # Initializes the GitHub plugin.
+    def initialize(owner, repository)
+      super
+
+      @owner = owner
+      @repository = repository
+      @client = Octokit::Client.new(access_token: ENV.fetch('GITHUB_TOKEN', nil))
+    end
+
+    def repo_id
+      "#{@owner}/#{@repository}"
+    end
+
+    def stats
+      [url, stargazers, subscribers, forks, created, updated, size, issues, pull_requests]
+    end
+
+    # Detects that the repository is a GitHub repository.
+    def self.matches_repo?(git)
+      default_remote = Repofetch.default_remote(git)
+      url = default_remote&.url
+      matches_remote?(url)
+    end
+
+    # Detects that the remote URL is for a GitHub repository.
+    def self.matches_remote?(remote)
+      HTTP_REMOTE_REGEX.match?(remote) || SSH_REMOTE_REGEX.match?(remote)
+    end
+
+    # Gets the owner and repository from a GitHub local repository.
+    def self.repo_identifiers(git)
+      default_remote = Repofetch.default_remote(git)
+      url = default_remote&.url
+      remote_identifiers(url)
+    end
+
+    # Gets the owner and repository from a GitHub remote URL.
+    #
+    # Returns nil if there is no match.
+    def self.remote_identifiers(remote)
+      match = HTTP_REMOTE_REGEX.match(remote)
+      match = SSH_REMOTE_REGEX.match(remote) if match.nil?
+      raise "Remote #{remote.inspect} doesn't look like a GitHub remote" if match.nil?
+
+      [match[:owner], match[:repository].delete_suffix('.git')]
+    end
+
+    # Creates an instance from a +Git::Base+ instance.
+    def self.from_git(git, args, _config)
+      # TODO: Raise a better exception than ArgumentError
+      raise ArgumentError, 'Explicitly activate this plugin to CLI arguments' unless args.empty?
+
+      owner, repository = repo_identifiers(git)
+
+      new(owner, repository)
+    end
+
+    # Creates an instance from CLI args and configuration.
+    def self.from_args(args, _config)
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: <plugin activation> -- [options] OWNER/REPOSITORY'
+        opts.separator ''
+        opts.separator 'This plugin can use the GITHUB_TOKEN environment variable increase rate limits'
+      end
+      parser.parse(args)
+      split = args[0]&.split('/')
+
+      # TODO: Raise a better exception than ArgumentError
+      raise ArgumentError, parser.to_s unless split&.length == 2
+
+      new(*split)
+    end
+
+    def header
+      "#{theme.format(:bold, "#{owner}/#{repository}")} @ #{theme.format(:bold, 'GitHub')}"
+    end
+
+    def ascii
+      ASCII
+    end
+
+    protected
+
+    def repo_stats
+      @repo_stats = @client.repository(repo_id) if @repo_stats.nil?
+      @repo_stats
+    end
+
+    def url
+      Repofetch::Stat.new('URL', repo_stats['clone_url'], emoji: '🌐', theme: theme)
+    end
+
+    def stargazers
+      Repofetch::Stat.new('stargazers', repo_stats['stargazers_count'], emoji: '⭐', theme: theme)
+    end
+
+    def subscribers
+      Repofetch::Stat.new('subscribers', repo_stats['subscribers_count'], emoji: '👀', theme: theme)
+    end
+
+    def forks
+      Repofetch::Stat.new('forks', repo_stats['forks_count'], emoji: '🔱', theme: theme)
+    end
+
+    def created
+      Repofetch::TimespanStat.new('created', repo_stats['created_at'], emoji: '🐣', theme: theme)
+    end
+
+    def updated
+      Repofetch::TimespanStat.new('updated', repo_stats['updated_at'], emoji: '📤', theme: theme)
+    end
+
+    def size
+      byte_size = number_to_human_size(
+        (repo_stats['size'] || 0) * 1024,
+        precision: 2,
+        significant: false,
+        strip_insignificant_zeros: false
+      )
+      Repofetch::Stat.new('size', byte_size, emoji: '💽', theme: theme)
+    end
+
+    def issues
+      @issue_search = @client.search_issues("repo:#{repo_id} is:issue", per_page: 1, page: 0) if @issue_search.nil?
+      Repofetch::Stat.new('issues', @issue_search['total_count'], emoji: '❗', theme: theme)
+    end
+
+    def pull_requests
+      @pr_search = @client.search_issues("repo:#{repo_id} is:pr", per_page: 1, page: 0) if @pr_search.nil?
+      Repofetch::Stat.new('pull requests', @pr_search['total_count'], emoji: '🔀', theme: theme)
+    end
+  end
+end
+
+Repofetch::Github.register

data/lib/repofetch/theme.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Repofetch
+  # Provides a theme for styling output.
+  class Theme
+    DEFAULT_STYLES = {
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      white: 37,
+      on_black: 40,
+      on_red: 41,
+      on_green: 42,
+      on_yellow: 43,
+      on_blue: 44,
+      on_magenta: 45,
+      on_cyan: 46,
+      on_white: 47,
+      bold: 1,
+      underline: 4,
+      reset: 0,
+      default: 0
+    }.freeze
+
+    attr_reader :styles
+
+    def initialize(styles = {})
+      @styles = DEFAULT_STYLES.merge(styles)
+    end
+
+    # Gets the ANSI escape sequence for a style.
+    def style(name)
+      "\e[#{styles[name]}m"
+    end
+
+    # Formats a string with ANSI escape sequences.
+    def format(name, text)
+      "#{style(name)}#{text}#{style(:reset)}"
+    end
+
+    # Returns a Hash with ANSI escape sequences for each style.
+    def to_h
+      styles.transform_values { |value| "\e[#{value}m" }
+    end
+  end
+end

data/lib/repofetch/util.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Repofetch
+  # Provides uncategorized utilities.
+  class Util
+    # Cleans a string with style parameters (e.g. "%{green}OK" -> "OK")
+    def self.clean_s(str)
+      str.gsub(/%{[\w\d]+?}/, '')
+    end
+  end
+end

data/lib/repofetch.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'action_view'
+require 'git'
+require 'repofetch/config'
+require 'repofetch/env'
+require 'repofetch/exceptions'
+require 'repofetch/theme'
+require 'repofetch/util'
+
+# Main class for repofetch
+class Repofetch
+  MAX_ASCII_WIDTH = 40
+  MAX_ASCII_HEIGHT = 20
+  DEFAULT_THEME = Theme.new.freeze
+  @plugins = []
+
+  class << self
+    attr_reader :plugins
+  end
+
+  # Registers a plugin.
+  #
+  # @param [Plugin] plugin The plugin to register
+  def self.register_plugin(plugin)
+    @plugins << plugin
+  end
+
+  # Replaces an existing plugin. If the existing plugin does not exist,
+  # then it registers the plugin instead.
+  #
+  # @param [Plugin] old The plugin to be replaced
+  # @param [Plugin] new The new plugin
+  def self.replace_or_register_plugin(old, new)
+    index = @plugins.find_index(old)
+    if index.nil?
+      register_plugin(new)
+    else
+      @plugins[index] = new
+      @plugins
+    end
+  end
+
+  # Returns the plugin that should be used.
+  # Raises a +Repofetch::NoPluginsError+ if no plugins are found.
+  # Raises a +Repofetch::TooManyPluginsError+ if more than one plugin is found.
+  #
+  # @param [String] git An instance of +Git::Base+
+  # @param [Array<String>] args The arguments passed to the program.
+  # @param [Repofetch::Config] config The configuration to use.
+  #
+  # @returns [Plugin] A plugin to use.
+  def self.get_plugin(git, args, config)
+    available_plugins = @plugins.filter do |plugin_class|
+      plugin_class.matches_repo?(git)
+    rescue NoMethodError
+      warn "#{plugin_class} Does not implement +matches_repo?+"
+      false
+    end
+    raise NoPluginsError if available_plugins.empty?
+
+    raise TooManyPluginsError if available_plugins.length > 1
+
+    available_plugins[0].from_git(git, args, config)
+  end
+
+  # Gets the name of the default remote to use.
+  #
+  # Will try to pick "origin", but if that is not found then it will
+  # pick the first one found, or nil if there aren't any available.
+  #
+  # @param [String] path The path to the repository.
+  #
+  # @returns [Git::Remote]
+  def self.default_remote(git)
+    remotes = git.remotes
+    found_remote = remotes.find { |remote| remote.name == 'origin' }
+    found_remote = remotes[0] if found_remote.nil?
+    found_remote
+  end
+
+  # Just wrapper around +default_remote+ since this is likely the most common
+  # use case (and it's easier than referencing the +Git::Remote+ docs to ensure
+  # correct usage in each plugin).
+  #
+  # @param [String] path The path to the repository.
+  #
+  # @return [String]
+  def self.default_remote_url(path)
+    default_remote(path)&.url
+  end
+
+  # Base class for plugins.
+  class Plugin
+    # Plugin intializer arguments should come from the +from_git+ or +from_args+
+    # class methods.
+    def initialize(*) end
+
+    # Registers this plugin class for repofetch.
+    def self.register
+      Repofetch.register_plugin(self)
+    end
+
+    # Tries to replace another plugin. An example use case might be if this plugin
+    # extends another registered plugin.
+    #
+    # @param [Plugin] old The plugin to replace
+    def self.replace_or_register(old)
+      Repofetch.replace_or_register_plugin(old, self)
+    end
+
+    # Detects that this plugin should be used. Should be overridden by subclasses.
+    #
+    # An example implementation is checking if +Repofetch.default_remote_url+ matches
+    # a regular expression.
+    #
+    # @param [Git::Base] _git The Git repository object
+    def self.matches_repo?(_git)
+      raise NoMethodError, 'matches_repo? must be overridden by the plugin subclass'
+    end
+
+    # This should use a git instance and call +Plugin.new+.
+    #
+    # @param [Git::Base] _git The Git repository object to use when calling +Plugin.new+.
+    # @param [Array] _args The arguments to process.
+    # @param [Config] _config The configuration loaded by the CLI.
+    #
+    # @returns [Plugin]
+    def self.from_git(_git, _args, _config)
+      raise NoMethodError, 'from_git must be overridden by the plugin subclass'
+    end
+
+    # This will receive an array of strings (e.g. +ARGV+) and call +Plugin.new+.
+    #
+    # @param [Array] _args The arguments to process.
+    # @param [Config] _config The configuration loaded by the CLI.
+    #
+    # @returns [Plugin]
+    def self.from_args(_args, _config)
+      raise NoMethodError, 'from_args must be overridden by the plugin subclass'
+    end
+
+    # Gets the plugin's theme. Override to use a theme besides the default.
+    def theme
+      Repofetch::DEFAULT_THEME
+    end
+
+    # The ASCII to be printed alongside the stats.
+    #
+    # This should be overridden by the plugin subclass.
+    # Should be within the bounds 40x20 (width x height).
+    def ascii
+      raise NoMethodError, 'ascii must be overridden by the plugin subclass'
+    end
+
+    # The header to show for the plugin.
+    #
+    # This should be overridden by the plugin subclass.
+    # For example, "foo/bar @ GitHub".
+    def header
+      raise NoMethodError, 'header must be overridden by the plugin subclass'
+    end
+
+    # Creates the separator that appears underneath the header
+    def separator
+      '-' * Repofetch::Util.clean_s(header).length
+    end
+
+    def to_s
+      zipped_lines.map do |ascii_line, stat_line|
+        cleaned_ascii = Repofetch::Util.clean_s(ascii_line)
+        styled_ascii = (ascii_line % theme.to_h) + theme.style(:reset)
+        aligned_stat_line = "#{' ' * (MAX_ASCII_WIDTH + 5)}#{stat_line}"
+        "#{styled_ascii}#{aligned_stat_line.slice(cleaned_ascii.length..)}\n"
+      end.join
+    end
+
+    # An array of stats that will be displayed to the right of the ASCII art.
+    #
+    # @returns [Array<Stat>]
+    def stats
+      []
+    end
+
+    # Makes an array of stat lines, including the header and separator.
+    def stat_lines
+      [header, separator, *stats.map(&:to_s)]
+    end
+
+    # Zips ASCII lines with stat lines.
+    #
+    # If there are more of one than the other, than the zip will be padded with empty strings.
+    def zipped_lines
+      ascii_lines = ascii.lines.map(&:chomp)
+      if ascii_lines.length > stat_lines.length
+        ascii_lines.zip(stat_lines)
+      else
+        stat_lines.zip(ascii_lines).map(&:reverse)
+      end.map { |ascii, stat| [ascii.to_s, stat.to_s] }
+    end
+  end
+
+  # Base class for stats.
+  class Stat
+    attr_reader :label, :value, :emoji
+
+    # Creates a stat
+    #
+    # @param [String] label The label of the stat
+    # @param value The value of the stat
+    # @param [String] emoji An optional emoji for the stat
+    def initialize(label, value, emoji: nil, theme: nil)
+      @label = label
+      @value = value
+      @emoji = emoji
+      @theme = theme
+    end
+
+    def to_s
+      "#{@emoji || ''}#{@theme.nil? ? @label : @theme.format(:bold, @label)}: #{format_value}"
+    end
+
+    # Formats the value
+    #
+    # This simply converts the value to a string, but can be overridden but
+    # subclasses to affect +to_s+.
+    def format_value
+      @value.to_s
+    end
+  end
+
+  # Timespan stat for "x units ago" stats.
+  class TimespanStat < Stat
+    include ActionView::Helpers::DateHelper
+
+    # Formats the value as "x units ago".
+    def format_value(now = nil)
+      now = Time.now if now.nil?
+      "#{distance_of_time_in_words(@value, now)} ago"
+    end
+  end
+
+  def self.clear_plugins
+    @plugins = []
+  end
+  private_class_method :clear_plugins
+end