rfix 1.2.2

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
+  TAG = "rally-point".freeze
+  REBUILD = "bundle:rebuild".freeze
+  BUILD = "bundle:build".freeze
+  ROOT = Dir.getwd
+  CONFIG = File.join(ROOT, ".rubocop.yml")
+  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,204 @@
+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)
+    say_debug "Checking #{path}:#{line}"
+
+    if file = @files.get(path)
+      return file.include?(line)
+    end
+
+    say_debug "\tSkip file (return false)"
+    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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "rfix/log"
+
+module Rfix
+  include Log
+  attr_accessor :repo
+  attr_accessor :test
+
+  alias test? test
+
+  def global_enable!
+    @global_enable = true
+  end
+
+  def global_enable?
+    @global_enable
+  end
+
+  def refresh!(source)
+    return true if global_enable?
+
+    repo.refresh!(source.file_path)
+  end
+
+  def enabled?(path, line)
+    return true if global_enable?
+
+    repo.include?(path, line)
+  end
+end
+
+# rubocop:enable Layout/LineLength

data/lib/rfix/tracked.rb

@@ -0,0 +1,72 @@
+require "rfix/no_file"
+
+class Rfix::Tracked < Rfix::File
+  include Rfix::Log
+
+  def include?(line)
+    set = diff.each_line.to_a.map{ |l| l.new_lineno }.reject { |l| l == -1 }.to_set
+    say_debug "Does {{yellow:#{set}}} contain {{red:#{line}}}"
+    set.include?(line)
+  end
+
+  private
+
+  # def set
+  #   return NoFile.new(path) if @set.empty?
+  #   return @set
+  # end
+
+  # def refresh!
+  #   @changes = diff.each_line.to_a.map{ |l| l.new_lineno }.to_set
+  #
+  #   if @changes.empty?
+  #     @changes = NoFile.new(path)
+  #   end
+  # rescue Rugged::TreeError
+  #   @changed = NoFile.new(path)
+  # end
+
+  # def changes
+  #   @changes or raise(Rfix::Error, "No changes found: #{self}")
+  # end
+
+  # def needs_update?
+  #   current_changed_at = changed_at
+  #   if @changed_at != current_changed_at
+  #     @changed_at = current_changed_at
+  #     return true
+  #   end
+  #
+  #   return false
+  # end
+
+  # def changed_at
+  #   File.new(absolute_path).ctime
+  # end
+
+  def upstream
+    @upstream ||= ref.resolve(with: repo)
+  end
+
+  def head
+    @head ||= repo.rev_parse("HEAD")
+  end
+
+  def diff
+    upstream.diff_workdir({
+      include_untracked_content: true,
+      recurse_untracked_dirs: true,
+      include_untracked: true,
+      ignore_submodules: true,
+      include_ignored: false,
+      context_lines: 0,
+      paths: [path]
+    }).tap do |diff|
+      diff.find_similar!(
+        renames_from_rewrites: true,
+        renames: true,
+        copies: true
+      )
+    end
+  end
+end