rfix 1.4.1 → 2.0.0

data/lib/rfix/file/untracked.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "dry/types"
+
+module Rfix
+  module File
+    class Untracked < Base
+      attribute :status, Types::Status::Untracked
+
+      def untracked?
+        true
+      end
+
+      def include?(*)
+        true
+      end
+
+    end
+  end
+end

data/lib/rfix/formatter.rb

@@ -1,128 +1,167 @@
 # frozen_string_literal: true
 
-require "rubocop"
-require "rouge"
-require "rainbow"
-require "shellwords"
+require "active_support/core_ext/module/delegation"
+require "rubocop/formatter/simple_text_formatter"
+require "rubocop/cop/offense"
+require "dry/core/constants"
+require "dry/initializer"
+require "tty/screen"
+require "tty/prompt"
+require "tty/box"
+
+RuboCop::Cop::Offense.prepend(Rfix::Extension::Offense)
 
 module Rfix
   class Formatter < RuboCop::Formatter::SimpleTextFormatter
-    include Rfix::Log
+    attr_reader :indicator
+
+    include Dry::Core::Constants
+    extend Dry::Initializer
+    include Log
+
+    option :indicator, default: -> { Indicator.new }
+    option :reported_offenses
+    option :options
+    option :output
+
+    PROMPT = TTY::Prompt.new(symbols: { marker: ">" })
+    SPACE = " "
+
+    delegate :say, to: :PROMPT
+
+    class NullRepository
+      include Singleton
+
+      def include_file?(*)
+        true
+      end
+    end
+
+    def initialize(output, options = EMPTY_HASH)
+      super(output: output, options: options, reported_offenses: EMPTY_ARRAY.dup)
+    end
 
     def started(files)
-      theme      = Rouge::Themes::Gruvbox.new
-      @formatter = Rouge::Formatters::TerminalTruecolor.new(theme)
-      @current   = 0
-      @total     = files.count
-      @files     = {}
-      @lexer     = Rouge::Lexers::Ruby.new
-      @pg        = CLI::UI::Progress.new
-      @all_files = files
+      # indicator.start("{{italic:rfix}} is linting {{bold:#{files.count}}} files, hold on ...")
     end
 
-    def truncate(path)
-      path.sub(::File.join(Dir.getwd, "/"), "")
+    # @files [Array<File>]
+    def finished(files)
+      # @indicator.stop
+      mark_command_line
+      report_summary(files)
     end
 
-    def render_files(files)
-      return unless Rfix.test?
+    # @file [File]
+    # @offenses [Array<Offence>]
+    def file_finished(*, offenses)
+      @reported_offenses += offenses
 
-      files.each do |file|
-        offenses = @files.fetch(file)
-        corrected = offenses.select(&:corrected?)
+      # @indicator.stop if offenses?
 
-        if offenses.empty?
-          say truncate(file)
-        elsif offenses.count == corrected.count
-          say truncate(file)
-        else
-          say_error truncate(file)
+      length = offenses.length - 1
+      offenses.each_with_index do |offense, _index|
+        framed(offense) do
+          report_line_with_highlight(offense)
         end
+
+        puts
       end
     end
 
-    def finished(files)
-      render_files(files)
+    private
 
-      files.each do |file|
-        render_file(file, @files.fetch(file))
+    using(Module.new do
+      refine String do
+        def surround(value)
+          value + self + value
+        end
       end
-
-      offenses = @files.values.flatten
-      corrected = offenses.select(&:corrected?)
-      out("\n") unless @total.zero?
-      report_summary(files.size, offenses.count, corrected.count)
+    end)
+
+    def framed(offense, &block)
+      puts TTY::Box.frame({
+        width: TTY::Screen.width,
+        padding: [1, 1, 0, 1],
+        title: {
+          top_left: "#{offense.icon} #{offense.msg}".surround(SPACE),
+          bottom_left: offense.clickable_severity&.surround(SPACE),
+          bottom_right: offense.clickable_path&.surround(SPACE)
+        }.compact
+      }, &block)
     end
 
-    def render_file(file, offenses)
-      return if offenses.empty?
-
-      offenses.each do |offense|
-        out("\n\n")
-        CLI::UI::Frame.open("#{offense.icon} #{offense.msg}", color: :reset)
-        report_line(file, offense, offense.location, offense.highlighted_area)
-        CLI::UI::Frame.close("#{offense.clickable_severity} » #{offense.clickable_path}", color: :reset)
-      end
+    def report_summary(files)
+      super(*stats.insert(0, files.count).take(arity))
     end
 
-    def mark
-      CLI::UI::ANSI::ESC + "]1337;SetMark" + "\x07"
+    def arity
+      method(:report_summary).super_method.arity
     end
 
-    def file_finished(file, offenses)
-      out("\n") if @current == 0.0
-      @current += 1.0
-      unless Rfix.test?
-        @pg.tick(set_percent: (@current / @total))
-      end
-      @files[file] = offenses
+    def mark_command_line
+      # "#{ESC}]1337;SetMark\a"
+      "" # TODO: Activate
     end
 
-    def out(msg, format: true)
-      CLI::UI.puts(msg, to: output, format: format)
+    def report(msg, format: true)
+      msg
     end
 
-    def fmt(msg)
-      CLI::UI.fmt(msg, enable_color: true)
+    def newline(amount = 1)
+      report("\n" * amount)
     end
 
-    def dim(value)
-      Rainbow(value).lightgray
+    def report_line_with_highlight(offense)
+      location = offense.location
+
+      unless location.respond_to?(:source_buffer)
+        return "Source not found"
+      end
+
+      buffer = location.source_buffer
+
+      source = buffer.source
+      line = location.line
+      last_line = buffer.last_line
+      surrounding_lines = 2
+
+      min_line = [line - surrounding_lines * 2, 1].max
+      max_line = [line + surrounding_lines * 2, last_line].min
+
+      begin_index = buffer.line_range(min_line).begin_pos
+      end_index = buffer.line_range(max_line).end_pos
+
+      visible = begin_index...end_index
+      highlight = location.to_range
+
+      highlighter = Highlighter.new(
+        visible_lines: (min_line..max_line),
+        highlight: highlight,
+        visible: visible
+      )
+
+      (method(:report) << highlighter).call(source)
     end
 
-    def highlighted_source_line(offense)
-      source_before_highlight(offense) +
-        hightlight_source_tag(offense) +
-        source_after_highlight(offense)
-     end
+    def corrected
+      reported_offenses.select(&:corrected?)
+    end
 
-    def hightlight_source_tag(offense)
-      offense.highlighted_area.source
-   end
+    def correctable
+      reported_offenses.select(&:correctable?)
+    end
 
-    def source_before_highlight(offense)
-      source_line = offense.location.source_line
-      source_line[0...offense.highlighted_area.begin_pos]
+    def stats
+      [reported_offenses.count, corrected.count, correctable.count]
     end
 
-    def source_after_highlight(offense)
-      source_line = offense.location.source_line
-      source_line[offense.highlighted_area.end_pos..-1]
+    def offenses?
+      reported_offenses.any?
     end
 
-    def report_line(_file, offense, _location, highlighted_area)
-      extra = "  "
-      src = highlighted_source_line(offense).lines.map { |line| extra + line }.join("\n")
-      indent = Indentation.new(src, extra_indentation: 2)
-      src = indent.call
-      lines = @formatter.format(@lexer.lex(src)).gsub('\\e', CLI::UI::ANSI::ESC).lines.map(&:chomp)
-      out("\n\n")
-      out(lines.join("\n"), format: false)
-      b_pos = highlighted_area.begin_pos + extra.length * 2 - indent.min_indentation
-      e_pos = highlighted_area.end_pos + extra.length * 2 - indent.min_indentation
-      size =  e_pos - b_pos
-      out((" " * b_pos) + Rainbow((" " * [size, 0].max)).underline.bold)
-      out("\n\n")
+    def repository
+      NullRepository.instance
     end
   end
 end

data/lib/rfix/highlighter.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+require "dry/initializer"
+require "dry/types"
+require "rouge"
+require "pastel"
+
+module Rfix
+  class Highlighter < Rouge::Formatters::TerminalTruecolor
+    tag "highlighter"
+
+    TEXT = Rouge::Token::Tokens::Text
+    NEWLINE = "\n"
+    SPACE = " "
+
+    include Dry::Core::Constants
+    extend Dry::Initializer
+
+    module Types
+      include Dry::Types()
+    end
+
+    param :theme, default: -> { Rouge::Themes::Gruvbox.new }
+    param :lexer, default: -> { Rouge::Lexers::Ruby.new }
+    option :visible_lines, type: Types::Range
+    option :highlight, type: Types::Range
+    option :visible, type: Types::Range
+
+    def call(source)
+      unless source.is_a?(String)
+        raise Error, "Source must be a string"
+      end
+
+      unless source.end_with?(NEWLINE)
+        return call(source + NEWLINE)
+      end
+
+      format(lexer.lex(source))
+    end
+
+    def stream(tokens, &block)
+      max_with = TTY::Screen.width
+      lines = token_lines(tokens)
+      pastel = Pastel.new
+      prefix_spaces = 2
+
+      indentation = lines.map.with_index(1) do |tokens, lineno|
+        next unless visible_lines.include?(lineno)
+
+        text = tokens.map(&:last).join
+
+        next if text.empty?
+
+        text.chars.take_while do |char|
+          char.strip.empty?
+        end.length
+      end.compact.min || 0
+
+      is_h = lines.reduce([0, 1, EMPTY_HASH]) do |(position, lineno, lookup), tokens|
+        tokens.reduce([position, lineno, lookup.dup]) do |(index, lineno, lookup), (_, value)|
+          [index + value.length, lineno, lookup].tap do
+            if highlight.include?(index)
+              lookup[lineno] = true
+            end
+          end
+        end.then do |index, lineno, lookup|
+          [index.succ, lineno.succ, lookup]
+        end
+      end.last
+
+      lines.reduce([0, 1]) do |(position, lineno), tokens|
+        print_line_number = lambda do
+          block.call(SPACE * 2)
+
+          style = is_h[lineno] ? pastel.yellow.detach : pastel.dim.detach
+          (block << style).call(lineno.to_s.ljust(4, SPACE) + SPACE)
+        end
+
+        tokens.reduce(position) do |index, (token, value)|
+          (index + value.length).tap do
+            if index == position
+              value = value.chars.drop(indentation).join
+
+              if visible_lines.include?(lineno)
+                print_line_number.call
+              end
+            end
+
+            if highlight.include?(index) && visible_lines.include?(lineno)
+              if index == position
+                head = value.chars.take_while(&:blank?).join
+                tail = value.chars.drop_while(&:blank?).join
+
+                super([[TEXT, head]], &block)
+                super([[token, tail]], &block)
+              else
+                super([[token, value]], &block)
+              end
+            elsif visible_lines.include?(lineno)
+              super([[token, value]], &block)
+            end
+          end
+        end.tap do |new_position|
+          if visible_lines.include?(lineno)
+            if position == new_position
+              print_line_number.call
+            end
+
+            super([[TEXT, NEWLINE]], &block)
+          end
+        end.then do |position|
+          [position.succ, lineno.succ]
+        end
+      end
+    end
+  end
+end

data/lib/rfix/indicator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rfix
+  class Indicator
+    include Dry::Core::Constants
+
+    def initialize
+      @spinners = []
+    end
+
+    def start(title)
+
+    end
+
+    def stop
+
+    end
+  end
+end

data/lib/rfix/log.rb

@@ -1,132 +1,23 @@
 # frozen_string_literal: true
 
-require "rfix"
-require "cli/ui"
+require "tty/box"
+require "tty/prompt"
+require "tty/screen"
 
-module Rfix::Log
-  extend self
-  def say(message)
-    prt("{{v}} #{message}")
-  end
-
-  def say_error(message)
-    prt("{{x}} #{message}")
-  end
-
-  def say_error_sub(message)
-    prt(message.to_s)
-  end
-
-  def error_box(title)
-    box(title, color: :red) { yield }
-  end
-
-  def abort_box(title)
-    error_box(title) { yield }
-    exit 1
-  end
+module Rfix
+  module Log
+    module_function
 
-  def say_test(message)
-    prt("{{i}} #{strip(message)}")
-  end
-
-  def say_debug(message)
-    if debug? || test?
-      prt("{{i}} #{strip(message)}", to: $stderr)
+    def prompt
+      @prompt ||= TTY::Prompt.new
     end
-  end
-
-  def say_abort(message)
-    prt("{{x}} #{message}")
-    exit 1
-  end
-
-  def debug?
-    return false unless defined?(RSpec)
-
-    return RSpec.configuration.debug?
-  end
-
-  def test?
-    Rfix.test?
-  end
-
-  def say_exit(message)
-    prt("{{v}} #{message}")
-    exit 0
-  end
-
-  def say_plain(message)
-    prt(message)
-  end
 
-  def debug_box(title)
-    unless_debug do
-      box(title) { yield }
+    def say(message)
+      prompt.ok(message)
     end
-  end
-
-  def prt(*args)
-    CLI::UI.puts(*args)
-  end
-
-  def fmt(*args)
-    CLI::UI.fmt(*args)
-  end
-
-  alias ftm fmt
 
-  def log_items(items, title:)
-    box("#{title} (#{items.count})") do
-      return margin(2) do
-        prt "{{warning:No items found}}"
-      end if items.empty?
-
-      items.each do |item|
-        if block_given?
-          say strip(yield item)
-        else
-          say strip(item.to_s)
-        end
-      end
+    def say!(message)
+      prompt.warn(message)
     end
   end
-
-  def box(title, color: :reset)
-    margin do
-      CLI::UI::Frame.open(title, color: color) do
-        margin(2) do
-          yield
-        end
-      end
-    end
-  end
-
-  def strip(msg)
-    msg
-    # msg.gsub(current_path, "").gsub(Dir.pwd, ".").chomp
-  end
-
-  def current_path
-    File.join(Dir.pwd, "/")
-  end
-
-  def div(title, **args)
-    CLI::UI::Frame.divider(title, **args)
-    margin { yield }
-  end
-
-  def margin(n = 1)
-    new_line(n)
-    yield
-    new_line(n)
-  end
-
-  def new_line(n = 1)
-    say_plain("\n" * n)
-  end
-
-  def unless_debug
-    yield unless Rfix.debug?
-  end
 end