rfix 1.0.15 → 1.1.0.pre.147

data/lib/rfix/branch.rb

@@ -0,0 +1,30 @@
+require "rfix/repository"
+require "rfix/error"
+
+module Rfix
+  module Branch
+    class UnknownBranchError < Rfix::Error
+    end
+
+    class NotYetImplementedError < Rfix::Error
+    end
+  end
+end
+
+Pathname(__dir__).glob("branches/*.rb").each(&method(:require))
+
+module Rfix
+  module Branch
+    UPSTREAM = Branch::Upstream.new
+    MAIN     = Branch::Main.new
+    HEAD     = Branch::Head.new
+
+    def self.local(at: Dir.pwd)
+      repo(at: at).branches.each_name(:local).sort
+    end
+
+    def self.repo(at:)
+      Rugged::Repository.new(at)
+    end
+  end
+end

data/lib/rfix/branches/base.rb

@@ -0,0 +1,29 @@
+class Rfix::Branch::Base
+  def resolve(with:)
+    raise Rfix::NotYetImplementedError.new("#resolved")
+  end
+
+  def to_s
+    raise Rfix::NotYetImplementedError.new("#to_s")
+  end
+
+  def branch(using:)
+    names(using: using).last or raise Rfix::Error.new("No named branch found for {{error:#{self}}}")
+  end
+
+  def names(using:)
+    oid = resolve(with: using).oid
+    locals = using.branches.each_name(:local).to_a
+
+    using.branches.select do |branch|
+      next false unless locals.include?(branch.name)
+      branch.target_id == oid
+    end
+  end
+
+  def revparse(using:, ref:)
+    using.rev_parse(ref)
+  rescue Rugged::InvalidError
+    raise Rfix::Branch::UnknownBranchError.new("Could not find reference {{error:#{ref}}}")
+  end
+end

data/lib/rfix/branches/head.rb

@@ -0,0 +1,11 @@
+module Rfix
+  class Branch::Head < Branch::Base
+    def resolve(with:)
+      with.lookup(with.head.target_id)
+    end
+
+    def to_s
+      "HEAD"
+    end
+  end
+end

data/lib/rfix/branches/main.rb

@@ -0,0 +1,33 @@
+require "rugged"
+
+module Rfix
+  class Branch::Main < Branch::Base
+    KEY = "rfix.main.branch"
+
+    def resolve(with:)
+      unless name = with.config[KEY]
+        raise Error.new("Please run {{command:rfix setup}} first")
+      end
+
+      String.new(name).resolve(with: with)
+    end
+
+    def self.set(branch, at: Dir.pwd)
+      unless branch.is_a?(String)
+        raise Rfix::Error.new("Branch must be a string, got {{error:#{branch.class}}}")
+      end
+
+      check = Branch::Name.new(branch)
+      repo = Branch.repo(at: at)
+      Branch.repo(at: at).config[KEY] = check.branch(using: repo).name
+    end
+
+    def self.get(at: Dir.pwd)
+      Branch.repo(at: at).config[KEY]
+    end
+
+    def to_s
+      "configured main branch"
+    end
+  end
+end

data/lib/rfix/branches/name.rb

@@ -0,0 +1,21 @@
+module Rfix
+  class Branch::Name < Branch::Base
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def resolve(with:)
+      unless branch = with.branches[name]
+        raise Branch::UnknownBranchError.new("Could not find branch {{error:#{name}}}")
+      end
+      
+      with.lookup(with.merge_base(branch.target_id, with.head.target_id))
+    rescue Rugged::ReferenceError
+      raise Branch::UnknownBranchError.new("Could not find branch {{error:#{name}}}")
+    end
+
+    alias to_s name
+  end
+end

data/lib/rfix/branches/reference.rb

@@ -0,0 +1,19 @@
+module Rfix
+  class Branch::Reference < Branch::Base
+    attr_reader :reference
+
+    def initialize(reference)
+      @reference = reference
+    end
+
+    def resolve(with:)
+      Branch::Name.new(reference).resolve(with: with)
+    rescue Branch::UnknownBranchError
+      revparse(using: with, ref: reference)
+    rescue Rugged::InvalidError
+      raise Branch::UnknownBranchError.new("Branch with reference {{error:#{reference}}} not found")
+    end
+
+    alias to_s reference
+  end
+end

data/lib/rfix/branches/upstream.rb

@@ -0,0 +1,11 @@
+module Rfix
+  class Branch::Upstream < Branch::Base
+    def resolve(with:)
+      with.rev_parse("@{upstream}")
+    end
+
+    def to_s
+      "upstream"
+    end
+  end
+end

data/lib/rfix/cmd.rb

@@ -9,20 +9,15 @@ module Rfix::Cmd
 
   def cmd(*args, quiet: false)
     out, err, status = Open3.capture3(*args)
-    say_debug "[Cmd] {{command:#{args.join(' ')}}}"
-    
-    unless status.success?
-      return yield if block_given?
-      return if quiet
-
-      say_error "[Cmd] {{italic:#{args.join(' ')}}}"
-      say_error "[Pwd] {{italic:#{Dir.pwd}}}"
-      say_error "[Err] {{error:#{err.strip}}}"
-
-      exit status.exitstatus
-    end
-
-    out.lines.map(&:chomp)
+    box = Rfix::Box.new(out, err, status, args, quiet)
+    return box.stdout if box.success?
+    return yield if block_given?
+    return if quiet
+
+    box.render(color: :red)
+    exit box.exit_status
+  ensure
+    # box.render(debug: false)
   end
 
   def cmd_succeeded?(*cmd)

data/lib/rfix/commands/all.rb

@@ -0,0 +1,26 @@
+# helper("help", binding)
+# helper("rubocop", binding)
+# helper("args", binding)
+#
+# summary "All"
+#
+# run do |opts, args, cmd|
+#   setup(opts, args) do |repo, files|
+#     q1 = "Are you sure you want to {{warning:auto-fix}} the {{warning:the entire folder}}"
+#     q2 = "Are you sure you want to {{warning:auto-fix}} everything in {{warning:#{files.join(", ")}?}}"
+#
+#     begin
+#       if files.empty?
+#         unless CLI::UI.confirm(q1)
+#           exit 1
+#         end
+#       elsif CLI::UI.confirm(q2)
+#         exit 1
+#       end
+#     rescue Interrupt
+#       exit 1
+#     end
+#
+#     Rfix.global_enable!
+#   end
+# end

data/lib/rfix/commands/branch.rb

@@ -0,0 +1,15 @@
+r_args = []
+
+helper("help", binding)
+helper("rubocop", binding)
+helper("args", binding)
+
+param :branch
+usage "rfix branch BRANCH [opts] [-p path ..]"
+option :p, :path, "Path to be passed to RuboCop", argument: :required, multiple: true
+summary "Fix changes made between HEAD and <branch>"
+
+run do |opts, args, _cmd|
+  branch = Rfix::Branch::Reference.new(args[:branch])
+  setup(r_args, opts, args, files: opts[:path] || [], reference: branch)
+end

data/lib/rfix/commands/extensions/options.rb

@@ -0,0 +1,8 @@
+module Rfix::Ext::Opt
+  def define_options
+    @define_options ||= super
+  end
+  alias opts define_options
+end
+
+RuboCop::Options.prepend(Rfix::Ext::Opt)

data/lib/rfix/commands/help.rb

@@ -0,0 +1,7 @@
+extend Rfix::Log
+
+summary "Displays help"
+
+run do |_opts, _args, cmd|
+  prt cmd.supercommand.help
+end

data/lib/rfix/commands/helper/args.rb

@@ -0,0 +1,137 @@
+option :r, :root, "{{*}} Project root path", default: Dir.pwd, argument: :required
+option :b, :"main-branch", "{{*}} Branch to use", default: "master", argument: :required
+option :l, :limit, "{{*}} Limit number of files", argument: :required, transform: method(:Integer)
+
+flag nil, :dry, "{{*}} Run in dry mode"
+flag nil, :untracked, "{{*}} Load untracked files"
+flag nil, :"clear-cache", "{{*}} Clear Rubocop`s cache"
+flag nil, :test, "{{*}} Used in tests"
+
+def validate!(files:)
+  return [] unless files.is_a?(Array)
+
+  files.each do |file|
+    unless File.exist?(file)
+      say_abort "Passed file {{error:#{file}}} does not exist"
+    end
+  end
+
+  files
+end
+
+def setup(r_args = [], opts, _args, files: [], reference:)
+  # files    = validate!(files: files)
+  options  = RuboCop::Options.new
+  store    = RuboCop::ConfigStore.new
+
+  params = {
+    force_exclusion: true,
+    formatters: ["Rfix::Formatter"],
+    auto_correct: true
+  }
+
+  if opts.key?(:format)
+    params.delete(:formatters)
+  end
+
+  if opts.key?(:dry)
+    params[:auto_correct] = false
+  end
+
+  if opts.key?(:test)
+    params.delete(:formatters)
+    params[:format] = "json"
+    params[:cache] = "false"
+    Rfix.test = true
+
+    unless opts.key?(:root)
+      raise "No --root passed with --test"
+    end
+
+    unless opts.key?(:config)
+      raise "No --config passed with --test"
+    end
+  end
+
+  if opts[:cache] == "false"
+    params[:cache] = "false"
+  end
+
+  begin
+    Rfix.repo = repo = Rfix::Repository.new(
+      root_path: opts[:root],
+      load_untracked: opts[:untracked],
+      reference: reference,
+      paths: files || []
+    )
+  rescue Rugged::RepositoryError => e
+    say_abort e.to_s
+  rescue Rfix::Error => e
+    say_abort e.to_s
+  end
+
+  # RuboCop::ResultCache.cleanup(store, true)
+
+  if opts[:"clear-cache"]
+    RuboCop::ResultCache.cleanup(store, true)
+    params[:cache] = "false"
+    say_debug "Cleared Rubocop`s cache"
+  end
+
+  if block_given?
+    yield(repo, [])
+  end
+
+  begin
+    params2, paths = options.parse(r_args)
+  rescue OptionParser::MissingArgument => e
+    say_abort e.to_s
+  end
+
+  params2.merge!(params)
+
+  begin
+    if config = opts[:config]
+      store.options_config = config
+    elsif root_path = opts[:root]
+      store.for(root_path)
+    end
+  rescue RuboCop::Error => e
+    say_abort e.to_s
+  rescue TypeError => e
+    say_abort e.to_s
+  rescue Psych::SyntaxError => e
+    say_abort e.to_s
+  end
+
+  # unless files.empty?
+  #   say "Loading files from {{italic:#{files.join(', ')}}}"
+  # end
+
+  if !files.empty?
+    paths = files
+  elsif paths.empty? && repo.paths.empty?
+    if opts[:format] == "json"
+      prt JSON.pretty_generate({"files": []})
+      exit 0
+    else
+      say_exit "Everything looks good, nothing to lint"
+    end
+  elsif paths.empty?
+    paths = repo.paths
+  end
+
+  if limit = opts[:limit]
+    paths = paths.take(limit)
+  end
+
+  env = RuboCop::CLI::Environment.new(params2, store, paths)
+
+  begin
+    exit RuboCop::CLI::Command::ExecuteRunner.new(env).run
+  rescue RuboCop::Runner::InfiniteCorrectionLoop => e
+    say_abort e.to_s
+  rescue RuboCop::Error => e
+    say_abort e.to_s
+  end
+end

data/lib/rfix/commands/helper/help.rb

@@ -0,0 +1,6 @@
+extend Rfix::Log
+
+flag   :h,  :help, "show help for this command" do |_value, cmd|
+  prt cmd.help
+  exit 0
+end

data/lib/rfix/commands/helper/loader.rb

@@ -0,0 +1,6 @@
+module Rfix::Loader
+  def helper(file, bind)
+    path = File.join(__dir__, file + ".rb")
+    eval(IO.read(path), bind, path)
+  end
+end

data/lib/rfix/commands/helper/rubocop.rb

@@ -0,0 +1,17 @@
+RuboCop::Options.new.opts.instance_eval("@stack", __FILE__, __LINE__).map(&:list).flatten.each do |opt|
+  short = opt.short.map { |arg| arg.delete_prefix("-") }
+  long = opt.long.map { |arg| arg.delete_prefix("--") }
+
+  short.unshift(nil) if opt.short.empty?
+  long.unshift(nil) if opt.long.empty?
+
+  if opt.arg
+    option(*short, *long, opt.desc.join(" "), argument: :optional) do |value|
+      r_args.append(*opt.long, value)
+    end
+  else
+    flag(*short, *long, opt.desc.join(" ")) do
+      r_args.append(*opt.long)
+    end
+  end
+end

data/lib/rfix/commands/info.rb

@@ -0,0 +1,30 @@
+require "rbconfig"
+require "rugged"
+
+extend Rfix::Log
+extend Rfix::Cmd
+
+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
+
+helper("help", binding)
+
+summary "Display runtime dependencies and their version"
+
+run do |_opts, _args|
+  say "Using RuboCop {{info:#{RuboCop::Version.version}}}"
+  say "Using Rugged {{info:#{Rugged::VERSION}}}"
+  say "Using Rfix {{info:#{Rfix::VERSION}}}"
+  say "Using OS {{info:#{current_os}}}"
+  say "Using Git {{info:#{git_version}}}"
+  say "Using Ruby {{info:#{ruby_version}}}"
+end