rfix 1.4.1 → 2.0.0

data/lib/rfix/rake/gemfile.rb

@@ -0,0 +1,111 @@
+require "dry/types"
+require "dry/struct"
+require "dry/logic"
+
+module Rfix
+  module Rake
+    Dry::Types.define_builder(:not) do |type|
+      Dry::Types::Constrained.new(type.lax, rule: Dry::Logic::Operations::Negation.new(type.rule))
+    end
+
+    class Gemfile < Dry::Struct
+      include Dry::Core::Constants, FileUtils
+
+      module Types
+        include Dry::Types()
+
+        module Version
+          AST = Types::String.enum("0.84")
+        end
+      end
+
+      attribute :root_path, Types::Instance(Pathname)
+      attribute :version, Types::Version::AST.not
+
+      class AST < self
+        attribute :version, Types::Version::AST
+
+        def content
+          [super, 'gem "rubocop-ast", "< 0.7"'].join("\n")
+        end
+      end
+
+      FORMAT = "Gemfile.rubocop-%s%s"
+      VERSIONS = [
+        '0.82',
+        '0.83',
+        '0.84',
+        '0.92',
+        '0.93',
+        '1.0.0',
+        '1.7.0',
+        '1.5.0',
+        '1.5.1',
+        '1.5.2',
+        '1.6.1',
+        '1.8.1',
+        '1.8.0',
+        '1.9.0',
+        '1.10.0',
+        '1.11.0',
+        '1.12.0',
+        '1.12.1',
+        '1.13.0'
+      ]
+
+      def self.call(*args, **kwargs, &block)
+        (self | AST).call(*args, **kwargs, &block)
+      end
+
+      def self.files(root_path)
+        VERSIONS.map do |version|
+          Gemfile.call(root_path: root_path, version: version)
+        end
+      end
+
+      def call
+        puts "Working with #{version}"
+
+        gemfile.write(content)
+
+        if lockfile.exist?
+          lockfile.delete
+        end
+
+        bundle_lock
+        puts "Finished with #{version}"
+      end
+
+      def bundle_lock
+        sh *lock_args
+      rescue RuntimeError
+        sh *lock_args[0..-2]
+      end
+
+      def lock_args
+        ["bundle", "lock", "--gemfile", gemfile.to_path, "--local"]
+      end
+
+      def to_s
+        gemfile.to_s
+      end
+
+      private
+
+      def gemfile
+        root_path.join(FORMAT % [version, EMPTY_STRING])
+      end
+
+      def lockfile
+        root_path.join(FORMAT % [version, ".lock"])
+      end
+
+      def content
+        <<~GEMFILE
+          eval_gemfile("../Gemfile")
+          gem "rubocop", "#{version}"
+        GEMFILE
+      end
+    end
+  end
+end

data/lib/rfix/rake/paths.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module Travis
-  SETUP = "travis:setup".freeze
-  INSTALL = "travis:install".freeze
-  TASKS = "travis:tasks:all".freeze
-  GIT = "travis:git:config".freeze
+  SETUP = "travis:setup"
+  INSTALL = "travis:install"
+  TASKS = "travis:tasks:all"
+  GIT = "travis:git:config"
 end
 
 module Bundle
-  INSTALL = "bundle:install".freeze
-  ADD = "bundle:git:add".freeze
-  TAG = "rally-point".freeze
-  REBUILD = "bundle:rebuild".freeze
-  BUILD = "bundle:build".freeze
+  INSTALL = "bundle:install"
+  ADD = "bundle:git:add"
+  TAG = "rally-point"
+  REBUILD = "bundle:rebuild"
+  BUILD = "bundle:build"
   ROOT = Dir.getwd
   CONFIG = File.join(ROOT, ".rubocop.yml")
   DIR = File.join(ROOT, "spec/fixtures")
@@ -19,21 +21,21 @@ module Bundle
   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
+    REBUILD = "bundle:simple:rebuild"
+    BUILD = "bundle:simple:build"
+    FLUSH = "bundle:simple:flush"
+    TEST = "bundle:simple:test"
     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
+    GITHUB = "https://github.com/oleander/git-fame-rb"
+    REBUILD = "bundle:complex:rebuild"
+    BUILD = "bundle:complex:build"
+    FLUSH = "bundle:complex:flush"
+    TEST = "bundle:complex:test"
     TAG = Bundle::TAG
   end
 end
@@ -42,9 +44,9 @@ 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
+  GITHUB = "https://github.com/shopify/cli-ui"
+  START = "6058c301bb144c2f33f7910734d08b1490ed8112"
+  BUILD = "vendor:shopify:build"
+  REBUILD = "vendor:shopify:rebuild"
+  TEST = "vendor:shopify:test"
 end

data/lib/rfix/rake/support.rb

@@ -1,75 +1,90 @@
-require "colorize"
-require "fileutils"
+# frozen_string_literal: true
+
+require "rainbow/ext/string"
 require "shellwords"
+require "fileutils"
 
-module Rfix::Support
-  include FileUtils
+module Rfix
+  module Rake
+    module Support
+      class Utils
+        include FileUtils
+      end
 
-  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 self.extended(base)
+        super
 
-  def gemfiles
-    Dir["Gemfile*", "ci/Gemfile*"]
-  end
+        utils = Utils.new
 
-  def say(msg)
-    $stderr.puts "#{'==>'.blue} #{to_relative(msg).italic}"
-  end
+        %i[cd sh rm_rf rm_f rm mkdir_p chdir].each do |name|
+          base.define_singleton_method("_#{name}".to_sym, &utils.method(name))
+        end
+      end
 
-  def sh(*args)
-    args = args.map(&:shellsplit).flatten
-    colorize args
-    _sh(*args)
-  end
+      def gemfiles
+        Dir["Gemfile*", "ci/Gemfile*"]
+      end
 
-  def chdir(*args, &block)
-    colorize :cd, args
-    _chdir(*args, &block)
-  end
+      def say(msg)
+        warn "#{'==>'.color(:blue)} #{to_relative(msg).italic}"
+      end
 
-  def rm_rf(*args)
-    colorize :rm, args
-    _rm_rf(*args)
-  end
+      def directory(*args)
+        mkdir_p args
+      end
 
-  def rm_f(*args)
-    colorize :rm, args
-    _rm_f(*args)
-  end
+      def sh(*args)
+        args = args.map(&:to_s).map(&:shellsplit).flatten
+        colorize args
+        _sh(*args)
+      end
 
-  def cd(*args, &block)
-    colorize :cd, args
-    _cd(*args, &block)
-  end
+      def chdir(*args, &block)
+        colorize :cd, args
+        _chdir(*args, &block)
+      end
 
-  def mkdir_p(*args)
-    colorize :mkdir, args
-    _mkdir_p(*args)
-  end
+      def rm_rf(*args)
+        colorize :rm, args
+        _rm_rf(*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
+      def rm_f(*args)
+        colorize :rm, args
+        _rm_f(*args)
+      end
 
-  private
+      def cd(*args, &block)
+        colorize :cd, args
+        _cd(*args, &block)
+      end
 
-  def current_path
-    File.join(Dir.getwd, "/")
-  end
+      def mkdir_p(*args)
+        colorize :mkdir, args
+        _mkdir_p(*args)
+      end
 
-  def to_relative(path)
-    path.to_s.gsub(current_path, "")
-  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
 
-  def colorize(*args)
-    head, *tail = args.flatten.map(&method(:to_relative))
-    say [head.yellow, tail.join(" ").italic].join(" ")
+      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.color(:yellow), tail.join(" ").italic].join(" ")
+      end
+    end
   end
 end

data/lib/rfix/repository.rb

@@ -1,202 +1,152 @@
-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, "Need Branch::Base, got {{error:#{reference.class}}}"
-    end
+# frozen_string_literal: true
 
-    @files          = FileCache.new(root_path)
-    @repo           = Rugged::Repository.new(root_path)
-    @paths          = paths
-    @reference      = reference
-    @load_untracked = load_untracked
+require "active_support/core_ext/module/delegation"
+require "dry/core/constants"
+require "dry/core/memoizable"
+require "dry/struct"
+require "rugged"
 
-    load!
-  end
+module Rfix
+  class Repository < Dry::Struct
+    include Dry::Core::Constants
+    include Log
 
-  def load_untracked?
-    @load_untracked
-  end
+    attribute :repository, Types.Instance(Rugged::Repository)
 
-  def load_tracked?
-    !!@reference
-  end
+    attribute :reference, Types.Instance(Branch::Base)
 
-  attr_reader :reference
+    delegate :head, :branches, :workdir, :rev_parse, :diff_workdir, to: :repository
 
-  def refresh!(path)
-    @files.get(path).refresh!
-  end
+    OPTIONS = {
+      include_untracked_content: true,
+      ignore_whitespace_change: false,
+      recurse_untracked_dirs: true,
+      ignore_whitespace_eol: false,
+      include_unmodified: true,
+      include_untracked: true,
+      ignore_submodules: true,
+      include_ignored: false,
+      context_lines: 0
+    }.freeze
 
-  def include?(path, line)
-    say_debug "Checking #{path}:#{line}"
+    def initialize(*)
+      super
+      call
+    end
 
-    if file = @files.get(path)
-      return file.include?(line)
+    def origin
+      reference.resolve
     end
 
-    say_debug "\tSkip file (return false)"
-    return false
-  end
+    def status(found = EMPTY_HASH.dup)
+      @status ||= begin
+        repository.status do |path, statuses|
+          statuses.each do |status|
+            (found[path] ||= []) << status
+          end
+        end
+
+        if repository.head_unborn?
+          return found
+        end
+
+        origin.diff_workdir(**OPTIONS.dup).tap do |diff|
+          diff.find_similar!(
+            renames_from_rewrites: true,
+            renames: true,
+            copies: true
+          )
+        end.each_delta.each_with_object(found) do |delta, acc|
+          (acc[delta.new_file[:path]] ||= []) << delta.status
+        end
+      end
+    end
 
-  def set_root(_path_path)
-    using_path(root_path)
-  end
+    def call
+      status.each do |path, statuses|
+        build(path, statuses)
+      end
+    end
 
-  def paths
-    files.pluck(&:absolute_path)
-  end
+    def path
+      Pathname(workdir)
+    end
 
-  def current_branch
-    repo.head.name
-  end
+    # @path [String]
+    def refresh!(*)
+      # NOP
+    end
 
-  def has_reference?(reference)
-    repo.rev_parse(reference)
-  rescue Rugged::ReferenceError
-    return false
-  end
+    # @path [String]
+    # @line [Integer]
+    # @return Bool
+    def include?(path, line)
+      get(path).include?(line)
+    rescue KeyError
+      false
+    end
 
-  def local_branches
-    repo.branches.each_name(:local).to_a
-  end
+    def skipped
+      ignored + deleted
+    end
 
-  def git_path
-    repo.workdir
-  end
+    def tracked
+      files.values.select(&:tracked?)
+    end
 
-  def head
-    @head ||= repo.rev_parse("HEAD")
-  end
+    def ignored
+      files.values.select(&:ignored?)
+    end
 
-  def upstream
-    @upstream ||= reference.resolve(with: repo)
-  end
+    def untracked
+      files.values.select(&:untracked?)
+    end
 
-  private
+    def deleted
+      files.values.select(&:deleted?)
+    end
 
-  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 {{info:#{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"
+    def permitted
+      untracked + tracked
     end
-  end
 
-  def load!
-    load_tracked!
-    load_untracked!
-  end
+    def to_s
+      options = {
+        untracked: untracked.map(&:basename).join(", "),
+        tracked: tracked.map(&:basename).join(", "),
+        ignored: ignored.map(&:basename).join(", "),
+        deleted: deleted.map(&:basename).join(", ")
+      }
 
-  # 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)
+      "Repository<Untracked: %<untracked>s, Tracked: %<tracked>s, Ignored: %<ignored>s, Deleted: %<deleted>s>" % options
     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"
+    def files
+      @files ||= EMPTY_HASH.dup
     end
-  end
 
-  def try_store(path, status)
-    if SKIP.any?(&status.method(:include?))
-      return say_debug("Ignored {{warning:#{status.join(', ')}}} #{path}")
+    def paths
+      permitted.map(&:basename)
     end
 
-    if STAGED.any?(&status.method(:include?))
-      return store(Rfix::Untracked.new(path, repo, nil))
+    def include_file?(path)
+      permitted.include?(files.fetch(path, Undefined))
     end
 
-    if UNTRACKED.any?(&status.method(:include?))
-      unless load_untracked?
-        return say_debug("Ignore #{path} as untracked files are ignored: #{status}")
-      end
+    private
 
-      return store(Rfix::Untracked.new(path, repo, nil))
+    def store(file)
+      files.store(file.key, file)
     end
 
-    if ACCEPT.any?(&status.method(:include?))
-      return store(Rfix::Tracked.new(path, repo, reference))
+    def get(path)
+      files.fetch(path)
     end
 
-    say_debug "Status not found {{error:#{status.join(', ')}}} for {{italic:#{path}}}"
+    def build(path, status)
+      store(Rfix::File.call(basename: path, status: status, repository: self))
+    rescue Dry::Struct::Error => e
+      raise Error, { path: path, status: status, message: e.message }.inspect
+    end
   end
 end