rfix 1.0.15 → 1.1.0.pre.147

data/lib/rfix/no_file.rb

@@ -0,0 +1,13 @@
+class NoFile < Struct.new(:path)
+  def include?(_line)
+    return true
+  end
+
+  def divide
+    Set.new
+  end
+
+  def empty?
+    false
+  end
+end

data/lib/rfix/rake/paths.rb

@@ -0,0 +1,50 @@
+module Travis
+  SETUP = "travis:setup".freeze
+  INSTALL = "travis:install".freeze
+  TASKS = "travis:tasks:all".freeze
+  GIT = "travis:git:config".freeze
+end
+
+module Bundle
+  INSTALL = "bundle:install".freeze
+  ADD = "bundle:git:add".freeze
+  CONFIG = File.join(__dir__, "../../../.rubocop.yml")
+  TAG = "rally-point".freeze
+  REBUILD = "bundle:rebuild".freeze
+  BUILD = "bundle:build".freeze
+  ROOT = File.expand_path(File.join(__dir__, "../../.."))
+  DIR = File.join(ROOT, "spec/fixtures")
+  TMP = File.join(ROOT, "tmp")
+
+  module Simple
+    FILE = File.join(DIR, "simple.bundle")
+    REPO = File.join(TMP, "simple")
+    REBUILD = "bundle:simple:rebuild".freeze
+    BUILD = "bundle:simple:build".freeze
+    FLUSH = "bundle:simple:flush".freeze
+    TEST = "bundle:simple:test".freeze
+    TAG = Bundle::TAG
+  end
+
+  module Complex
+    FILE = File.join(DIR, "complex.bundle")
+    REPO = File.join(TMP, "complex")
+    GITHUB = "https://github.com/oleander/git-fame-rb".freeze
+    REBUILD = "bundle:complex:rebuild".freeze
+    BUILD = "bundle:complex:build".freeze
+    FLUSH = "bundle:complex:flush".freeze
+    TEST = "bundle:complex:test".freeze
+    TAG = Bundle::TAG
+  end
+end
+
+module Vendor
+  ROOT = File.expand_path(File.join(__dir__, "../../.."))
+  DIR = File.join(ROOT, "vendor/shopify")
+  REPO = File.join(DIR, "cli-ui")
+  GITHUB = "https://github.com/shopify/cli-ui".freeze
+  START = "ef976d".freeze
+  BUILD = "vendor:shopify:build".freeze
+  REBUILD = "vendor:shopify:rebuild".freeze
+  TEST = "vendor:shopify:test".freeze
+end

data/lib/rfix/rake/support.rb

@@ -0,0 +1,75 @@
+require "colorize"
+require "fileutils"
+require "shellwords"
+
+module Rfix::Support
+  include FileUtils
+
+  alias _sh sh
+  alias _cd cd
+  alias _rm_rf rm_rf
+  alias _rm_f rm_f
+  alias _mkdir_p mkdir_p
+  alias _chdir chdir
+
+  def gemfiles
+    Dir["Gemfile*", "ci/Gemfile*"]
+  end
+
+  def say(msg)
+    $stderr.puts "#{'==>'.blue} #{to_relative(msg).italic}"
+  end
+
+  def sh(*args)
+    args = args.map(&:shellsplit).flatten
+    colorize args
+    _sh(*args)
+  end
+
+  def chdir(*args, &block)
+    colorize :cd, args
+    _chdir(*args, &block)
+  end
+
+  def rm_rf(*args)
+    colorize :rm, args
+    _rm_rf(*args)
+  end
+
+  def rm_f(*args)
+    colorize :rm, args
+    _rm_f(*args)
+  end
+
+  def cd(*args, &block)
+    colorize :cd, args
+    _cd(*args, &block)
+  end
+
+  def mkdir_p(*args)
+    colorize :mkdir, args
+    _mkdir_p(*args)
+  end
+
+  def clone_and_run(&block)
+    Dir.mktmpdir do |repo|
+      sh "git clone", Bundle::Complex::FILE, repo, "--branch", "master"
+      Dir.chdir(repo) { block.call(repo) }
+    end
+  end
+
+  private
+
+  def current_path
+    File.join(Dir.getwd, "/")
+  end
+
+  def to_relative(path)
+    path.to_s.gsub(current_path, "")
+  end
+
+  def colorize(*args)
+    head, *tail = args.flatten.map(&method(:to_relative))
+    say [head.yellow, tail.join(" ").italic].join(" ")
+  end
+end

data/lib/rfix/repository.rb

@@ -0,0 +1,201 @@
+require "rugged"
+require "rfix/file"
+require "rfix/file_cache"
+require "rfix/untracked"
+require "rfix/tracked"
+
+class Rfix::Repository
+  include Rfix::Log
+  attr_reader :files, :repo
+
+  def initialize(root_path:, load_untracked: false, reference: Rfix::Branch::HEAD, paths: [])
+    unless File.exist?(root_path)
+      raise Rfix::Error, "#{root_path} does not exist"
+    end
+
+    unless Pathname.new(root_path).absolute?
+      raise Rfix::Error, "#{root_path} is not absolute"
+    end
+
+    unless reference.is_a?(Rfix::Branch::Base)
+      raise Rfix::Error.new("Need Branch::Base, got {{error:#{reference.class}}}")
+    end
+
+    @files          = FileCache.new(root_path)
+    @repo           = Rugged::Repository.new(root_path)
+    @paths          = paths
+    @reference      = reference
+    @load_untracked = load_untracked
+
+    load!
+  end
+
+  def load_untracked?
+    @load_untracked
+  end
+
+  def load_tracked?
+    !! @reference
+  end
+
+  def reference
+    @reference
+  end
+
+  def refresh!(path)
+    @files.get(path).refresh!
+  end
+
+  def include?(path, line)
+    if file = @files.get(path)
+      return file.include?(line)
+    end
+
+    return false
+  end
+
+  def set_root(_path_path)
+    using_path(root_path)
+  end
+
+  def paths
+    files.pluck(&:absolute_path)
+  end
+
+  def current_branch
+    repo.head.name
+  end
+
+  def has_reference?(reference)
+    repo.rev_parse(reference)
+  rescue Rugged::ReferenceError
+    return false
+  end
+
+  def local_branches
+    repo.branches.each_name(:local).to_a
+  end
+
+  def git_path
+    repo.workdir
+  end
+
+  def head
+    @head ||= repo.rev_parse("HEAD")
+  end
+
+  def upstream
+    @upstream ||= reference.resolve(with: repo)
+  end
+
+  private
+
+  def load_tracked!
+    params = {
+      # ignore_whitespace_change: true,
+      include_untracked_content: true,
+      recurse_untracked_dirs: true,
+      # ignore_whitespace_eol: true,
+      include_unmodified: false,
+      include_untracked: true,
+      ignore_submodules: true,
+      # ignore_whitespace: true,
+      include_ignored: false,
+      context_lines: 0
+    }
+
+    unless @paths.empty?
+      say_debug("Use @paths #{@paths.join(", ")}")
+      params[:disable_pathspec_match] = false
+      params[:paths] = @paths
+    end
+
+    say_debug("Run diff on #{reference}")
+    upstream.diff(head, **params).tap do |diff|
+      diff.find_similar!(
+        renames_from_rewrites: true,
+        renames: true,
+        copies: true
+      )
+    end.each_delta do |delta|
+      path = delta.new_file.fetch(:path)
+      say_debug("Found #{path} while diff")
+      try_store(path, [delta.status])
+    end
+  rescue Rugged::ReferenceError
+    abort_box($ERROR_INFO.to_s) do
+      prt "Reference {{error:#{reference}}} cannot be found in repository"
+    end
+  rescue Rugged::ConfigError
+    abort_box($ERROR_INFO.to_s) do
+      prt "No upstream branch set for {{error:#{current_branch}}}"
+    end
+  rescue TypeError
+    abort_box($ERROR_INFO.to_s) do
+      prt "Reference {{error:#{reference}}} is not pointing to a tree or commit"
+    end
+  end
+
+  def load!
+    load_tracked!
+    load_untracked!
+  end
+
+  # https://github.com/libgit2/rugged/blob/35102c0ca10ab87c4c4ffe2e25221d26993c069c/test/status_test.rb
+  # - +:index_new+: the file is new in the index
+  # - +:index_modified+: the file has been modified in the index
+  # - +:index_deleted+: the file has been deleted from the index
+  # - +:worktree_new+: the file is new in the working directory
+  # - +:worktree_modified+: the file has been modified in the working directory
+  # - +:worktree_deleted+: the file has been deleted from the working directory
+
+  MODIFIED  = [:modified, :worktree_modified, :index_modified].freeze
+  IGNORED   = [:ignored].freeze
+  STAGED    = [:added, :index_new].freeze
+  UNTRACKED = [:worktree_new, :untracked].freeze
+  COPIED    = [:copied].freeze
+  DELETED   = [:deleted, :worktree_deleted, :index_deleted].freeze
+  RENAMED   = [:renamed].freeze
+
+  SKIP = [*DELETED, *RENAMED, *COPIED, *IGNORED].freeze
+  ACCEPT = [*MODIFIED].freeze
+
+  def load_untracked!
+    repo.status do |path, status|
+      try_store(path, status)
+    end
+  end
+
+  def store(file)
+    say_debug("Trying to add #{file.absolute_path}")
+    if File.exist?(file.absolute_path)
+      @files.add(file)
+    else
+      say_debug "#{file} does not exist"
+    end
+  end
+
+  def try_store(path, status)
+    if SKIP.any?(&status.method(:include?))
+      return say_debug("Ignored {{warning:#{status.join(', ')}}} #{path}")
+    end
+
+    if STAGED.any?(&status.method(:include?))
+      return store(Rfix::Untracked.new(path, repo, nil))
+    end
+
+    if UNTRACKED.any?(&status.method(:include?))
+      unless load_untracked?
+        return say_debug("Ignore #{path} as untracked files are ignored: #{status}")
+      end
+
+      return store(Rfix::Untracked.new(path, repo, nil))
+    end
+
+    if ACCEPT.any?(&status.method(:include?))
+      return store(Rfix::Tracked.new(path, repo, reference))
+    end
+
+    say_debug "Status not found {{error:#{status.join(', ')}}} for {{italic:#{path}}}"
+  end
+end

data/lib/rfix/rfix.rb

@@ -1,111 +1,14 @@
 # frozen_string_literal: true
 
-# rubocop:disable Layout/LineLength
-
 require "rubocop"
-require "optparse"
-require "rbconfig"
-require "rfix/git_file"
-require "rfix/git_helper"
 require "rfix/log"
-require "rfix/tracked_file"
-require "rfix/untracked_file"
 
 module Rfix
-  include GitHelper
   include Log
+  attr_accessor :repo
+  attr_accessor :test
 
-  def indent
-    " " * 2
-  end
-
-  def thanks
-    tx = []
-    tx << "\n{{v}} Thank you for installing {{green:rfix v#{Rfix::VERSION}}}!\n"
-    tx << "{{i}} Run {{command:rfix}} for avalible commands or any of the following to get started:"
-    tx << ""
-    # tx << "Here are a few examples that might be useful:"
-    tx << "#{indent}{{command:$ rfix local}}   {{italic:# Auto-fixes commits not yet pushed to upstream}}"
-    tx << "#{indent}{{command:$ rfix origin}}  {{italic:# Auto-fixes commits between HEAD and origin branch}}"
-    tx << "#{indent}{{command:$ rfix lint}}    {{italic:# Lints commits and untracked files not yet pushed to upstream}}"
-    tx << ""
-    tx << "{{*}} {{bold:ProTip:}} Append {{command:--dry}} to run {{command:rfix}} in read-only mode"
-    tx << ""
-    tx << "{{i}} {{bold:Issues}} {{italic:https://github.com/oleander/rfix-rb/issues}}"
-    tx << "{{i}} {{bold:Readme}} {{italic:https://github.com/oleander/rfix-rb/blob/master/README.md}}"
-    tx << "{{i}} {{bold:Travis}} {{italic:https://travis-ci.org/github/oleander/rfix-rb}}"
-    tx << ""
-    tx << "{{italic:~ Linus}}\n\n"
-    CLI::UI.fmt(tx.join("\n"), enable_color: true)
-  end
-
-  def help
-    cmds = [""]
-    cmds << "#{indent}{{command:$ rfix [cmd] [options]}} # {{italic:--dry --help --list-files --limit-files --config --untracked}}"
-    cmds << "#{indent}{{command:$ rfix branch <branch>}} #  {{italic:Fix changes made between HEAD and <branch>}}"
-    cmds << "#{indent}{{command:$ rfix origin}}          #  {{italic:Fix changes made between HEAD and origin branch}}"
-    cmds << "#{indent}{{command:$ rfix local}}           #  {{italic:Fix changes not yet pushed to upstream branch}}"
-    cmds << "#{indent}{{command:$ rfix info}}            #  {{italic:Display runtime dependencies and their versions}}"
-    cmds << "#{indent}{{command:$ rfix all}}             #  {{italic:Fix all files in this repository}} {{warning:(not recommended)}}"
-    cmds << "#{indent}{{command:$ rfix lint}}            #  {{italic:Shortcut for 'local --dry --untracked'}}"
-    CLI::UI.fmt(cmds.join("\n"), enable_color: true)
-  end
-
-  def current_branch
-    git("rev-parse", "--abbrev-ref", "HEAD").first
-  end
-
-  def debug?
-    @debug
-  end
-
-  def debug!
-    @debug = true
-    @config[:debug] = true
-  end
-
-  def number_of_commits_since
-    cmd("git rev-list master..HEAD | wc -l").first
-  end
-
-  def config
-    @config
-  end
-
-  def no_auto_correct!
-    @config[:auto_correct] = false
-  end
-
-  def auto_correct!
-    @config[:auto_correct] = true
-  end
-
-  def load_config
-    yield @store
-  rescue RuboCop::Error => e
-    say_abort "[Config:RuboCop] #{e}"
-  rescue TypeError => e
-    say_abort "[Config:Type] #{e}"
-  rescue Psych::SyntaxError => e
-    say_abort "[Config:Syntax] #{e}"
-  end
-
-  def lint_mode!
-    no_auto_correct!
-    load_untracked!
-  end
-
-  def git_version
-    cmd("git --version").last.split(/\s+/, 3).last
-  end
-
-  def ruby_version
-    RbConfig::CONFIG["ruby_version"] || "<unknown>"
-  end
-
-  def current_os
-    RbConfig::CONFIG["host_os"] || "<unknown>"
-  end
+  alias test? test
 
   def global_enable!
     @global_enable = true
@@ -115,110 +18,16 @@ module Rfix
     @global_enable
   end
 
-  def store
-    @store
-  end
-
-  def clear_cache!
-    RuboCop::ResultCache.cleanup(@store, true)
-  end
-
-  def init!
-    @files ||= {}
-    @global_enable = false
-    @debug = false
-    @config = {
-      force_exclusion: true,
-      formatters: ["Rfix::Formatter"]
-    }
-
-    @store = RuboCop::ConfigStore.new
-    auto_correct!
-  end
-
-  def files
-    @files.values
-  end
-
-  def spin
-    @spin ||= CLI::UI::SpinGroup.new
-  end
-
-  def paths
-    @files.keys
-  end
-
-  def root_dir
-    @root_dir ||= git("rev-parse", "--show-toplevel").first
-  end
-
   def refresh!(source)
-    @files[source.file_path]&.refresh!
-  end
-
-  def enabled?(path, line)
     return true if global_enable?
 
-    @files[path]&.include?(line)
-  end
-
-  def to_relative(path:)
-    Pathname.new(path).relative_path_from(Pathname.new(root_dir)).to_s
-  rescue ArgumentError
-    path
-  end
-
-  def load_untracked!
-    cached(list_untrack_files.map do |path|
-      UntrackedFile.new(path, nil, root_dir)
-    end.select(&:file?).to_set)
-  end
-
-  def load_tracked!(reference)
-    cached(git("log", "--name-only", "--pretty=format:", *params, "#{reference}...HEAD").map do |path|
-      TrackedFile.new(path, reference, root_dir)
-    end.select(&:file?).to_set)
-  end
-
-  def has_branch?(name)
-    cmd_succeeded?("git", "cat-file", "-t", name)
-  end
-
-  # Ref since last push
-  def ref_since_push
-    git("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}") do
-      [ref_since_origin]
-    end.first
-  end
-
-  # Original branch, usually master
-  def ref_since_origin
-    git("show-branch", "--merge-base").first
+    repo.refresh!(source.file_path)
   end
 
-  private
-
-  def old?
-    # For version 0.80.x .. 0.83.x:
-    # Otherwise it will exit with status code = 1
-    (0.80..0.83).include?(RuboCop::Version::STRING.to_f)
-  end
-
-  def get_file(path, &block)
-    if file = @files[path]
-      block.call(file)
-    end
-  end
-
-  def list_untrack_files
-    git("ls-files", "--exclude-standard", "--others")
-  end
+  def enabled?(path, line)
+    return true if global_enable?
 
-  def cached(files)
-    @files ||= {}
-    files.each do |file|
-      @files[file.path] = file
-    end
+    repo.include?(path, line)
   end
 end