colora 0.1.240114 → 1.0.250401

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3760588ff62affbf6a8f1c58a95e9d76415d77db9fd9d214a783e51dad1d177
-  data.tar.gz: 6422c39bc7dc14d01575da4af643f5029a06f8e7db15a22fff72655ba468b199
+  metadata.gz: aaeff7f365a7ed911d0a4e43ba1dc6f1db993a779d6fc5c7228581580f823979
+  data.tar.gz: 127b845d20c7380072a5f2bd8d8b542d403efc7713b0992ae00da3445e58b00b
 SHA512:
-  metadata.gz: 87dcb061cc8f77823edda88f80ad60f3c5abc3bccd199504cbab391c7615853b58e682b04d97b9fa2cee5665dfb9e46b2a8fe35e05184724c984d71526ac5b9b
-  data.tar.gz: c17e22167482923f6900ba3e614bdf25cee992496fe789d6a57cc344b0821653b9585cf22ed106960b483c0bac451780bff7035b929b82cdb5d83636cf2b43cd
+  metadata.gz: d618d434df2e56d75c50f94a6a26cb656c0b148a400f5b50feb04b2934f2f3f990718b9c219c582e6d2c048ea4b8e145172b5f52485346be15a78ec3b62905ba
+  data.tar.gz: 4f20a7ea99b7e1b4ed5641fe7f6810b0c789ccb51af5a78e1e7d1d8887e839cff492c4a5dfc542490d64cf038b2045b57efec520c253c40daa15ab0bf132398b

data/README.md

@@ -1,8 +1,8 @@
 # Colora
 
-* [VERSION 0.1.240114](https://github.com/carlosjhr64/colora/releases)
+* [VERSION 1.0.250401](https://github.com/carlosjhr64/colora/releases)
 * [github](https://www.github.com/carlosjhr64/colora)
-* [rubygems](https://rubygems.org/carlosjhr64/colora)
+* [rubygems](https://rubygems.org/gems/colora)
 
 ## DESCRIPTION
 
@@ -26,26 +26,24 @@ $ colora                 # Git-diff default
 
 ![Demo](img/demo.png)
 
-Colora will decorate your git-diff output with the following additional flags:
+Colora will color code your git-diff output:
 
-* Absent: `*`
-* Deleted: `<`
-* Inserted: `>`
-* Moved/Touched: `t`
-* Edited: `e`
-* Duplicated: `d`
+* Deleted: `:red`
+* Replaced: `:magenta`
+* Inserted: `:green`
+* Edited: `:black`
+* Moved/Touched: `:blue`
+* Duplicated: `:cyan`
+* Context: `:gray`
 
-The flags are the first three characters of the diff line,
-the first coming from git.
-The second and third refer to the code and comment of the diff line
-(Colora assumes comments as in Ruby).
 One can choose to filter(via command line options) the diff output to:
 
 * Filter out context lines(quiet)
-* Just view green(inserted lines)
-* Just view red(deleted lines)
+* Just view in(`+>`) lines
+* Just view out(`-<`) lines
 * Just view edited code or comments
 * Just view duplicated code or comments
+* Toggle on/off lines on regexp
 
 Additional features:
 
@@ -59,8 +57,8 @@ Usage:
   colora [:options+] [<file=FILE>]
 Options:
   -q --quiet
-  -g --green     	 Skip red:   /^[-<]/
-  -r --red       	 Skip green: /^[+>]/
+  --in           	 in lines, skip out lines
+  --out          	 out lines, skip in lines
   -c --code      	 Show only new(changed) code
   -C --comment   	 Show only new(changed) comments
   -d --dupcode   	 Show only duplicate code
@@ -69,11 +67,17 @@ Options:
   -t --tab       	 Swap tab with ⇥
   --theme=NAME   	 Rouge theme(default: github)
   --lang=NAME    	 Language being diffed(default: ruby)
+  --on=REGEXP    	 Start showing lines at this regexp
+  --off=REGEXP   	 Stop showing lines at this regexp
+  --fuzzy=FUZZY  	 Fuzzy match threshold (default: 0.618)
 Types:
-  FILE /^[-\w\.\/]+$/
-  NAME /^[\d.a-z_]+$/
+  FILE    /^[-\w\.\/]+$/
+  NAME    /^[\d.a-z_]+$/
+  REGEXP  /^\S+$/
+  FUZZY   /^0.\d+$/
 Exclusive:
-  green red
+  in out
+  code comment dupcode dupcomment
 # Notes: #
 When no FILE is given and STDIN in a TTY, git-diff is run.
 Known themes:
@@ -87,7 +91,7 @@ Known themes:
 ```
 ## LICENSE
 
-Copyright (c) 2024 CarlosJHR64
+Copyright (c) 2025 CarlosJHR64
 
 Permission is hereby granted, free of charge,
 to any person obtaining a copy of this software and

data/bin/colora

@@ -1,44 +1,46 @@
 #!/usr/bin/env ruby
-require 'colora'
+# frozen_string_literal: true
 
-def parse_argv
-  return nil if ARGV.empty?
+require 'colora'
 
-  require 'help_parser'
-  HelpParser[Colora::VERSION, <<~HELP]
-    Usage:
-      colora [:options+] [<file=FILE>]
-    Options:
-      -q --quiet
-      -g --green     \t Skip red:   /^[-<]/
-      -r --red       \t Skip green: /^[+>]/
-      -c --code      \t Show only new(changed) code
-      -C --comment   \t Show only new(changed) comments
-      -d --dupcode   \t Show only duplicate code
-      -D --dupcomment\t Show only duplicate comments
-      -G --git       \t Run git-diff
-      -t --tab       \t Swap tab with ⇥
-      --theme=NAME   \t Rouge theme(default: github)
-      --lang=NAME    \t Language being diffed(default: ruby)
-    Types:
-      FILE /^[-\\w\\.\\/]+$/
-      NAME /^[\\d.a-z_]+$/
-    Exclusive:
-      green red
-    # Notes: #
-    When no FILE is given and STDIN in a TTY, git-diff is run.
-    Known themes:
-      base16 base16.monokai base16.solarized bw
-      colorful
-      github gruvbox
-      igorpro
-      magritte molokai monokai monokai.sublime
-      pastie
-      thankful_eyes tulip
-  HELP
-end
+options = ARGV.empty? ? nil : Colora.parse_argv(<<~HELP)
+  Usage:
+    colora [:options+] [<file=FILE>]
+  Options:
+    -q --quiet
+    --in           \t in lines, skip out lines
+    --out          \t out lines, skip in lines
+    -c --code      \t Show only new(changed) code
+    -C --comment   \t Show only new(changed) comments
+    -d --dupcode   \t Show only duplicate code
+    -D --dupcomment\t Show only duplicate comments
+    -G --git       \t Run git-diff
+    -t --tab       \t Swap tab with ⇥
+    --theme=NAME   \t Rouge theme(default: github)
+    --lang=NAME    \t Language being diffed(default: ruby)
+    --on=REGEXP    \t Start showing lines at this regexp
+    --off=REGEXP   \t Stop showing lines at this regexp
+    --fuzzy=FUZZY  \t Fuzzy match threshold (default: 0.618)
+  Types:
+    FILE    /^[-\\w\\.\\/]+$/
+    NAME    /^[\\d.a-z_]+$/
+    REGEXP  /^\\S+$/
+    FUZZY   /^0.\\d+$/
+  Exclusive:
+    in out
+    code comment dupcode dupcomment
+  # Notes: #
+  When no FILE is given and STDIN in a TTY, git-diff is run.
+  Known themes:
+    base16 base16.monokai base16.solarized bw
+    colorful
+    github gruvbox
+    igorpro
+    magritte molokai monokai monokai.sublime
+    pastie
+    thankful_eyes tulip
+HELP
 
-options = parse_argv
 begin
   Colora.run(options)
 rescue Colora::Error => e

data/lib/colora/configure.rb

@@ -1,40 +1,123 @@
+# frozen_string_literal: true
+
+# Colora namespace.
+# Configuration file.
 module Colora
-  Config = OpenStruct.new
+  # Filter keys:
+  OPTIONS = %i[git file lang theme tab on off fuzzy].freeze
+  FILTERS = %i[quiet in out code comment dupcode dupcomment].freeze
+  CODES = %i[context deleted replaced duplicated edited inserted touched].freeze
 
-  # Options:
-  Config.file   = nil
-  Config.git    = false
-  Config.lang   = 'ruby'
-  Config.theme  = 'github'
-  Config.tab    = false
+  Struct.new('Config', *OPTIONS, *CODES, *FILTERS) do
+    # rubocop:disable Metrics
+    # :reek:TooManyStatements
+    def get(*keys)
+      keys.each do |key|
+        next unless (value = self[key])
 
-  # Filter keys:
-  FILTERS = %i[quiet green red code comment dupcode dupcomment]
-  FILTERS.each{Config[_1]=false}
-
-  # Flags colors:
-  Config.duplicated_flag = [:default, '#E0FFFF'] # LightCyan
-  Config.inserted_flag   = [:default, '#ADD8E6'] # LightBlue
-  Config.edited_flag     = [:default, '#90EE90'] # LightGreen
-
-  # Comments colors:
-  Config.moved_comment      = ['#A9A9A9', :default] # DarkGray
-  Config.duplicated_comment = ['#008B8B', :default] # DarkCyan
-  Config.inserted_comment   = ['#00008B', :default] # DarkBlue
-  Config.edited_comment     = ['#006400', :default] # DarkGreen
-
-  def self.configure(options)
-    # FILE:
-    Config.file = options.file if options.file
-
-    # Options:
-    Config.theme = options.theme if options.theme?
-    Config.lang  = options.lang if options.lang?
-    Config.git   = options.git?
-    Config.tab   = options.tab?
-
-    # Filters:
-    # Config.quiet=options.quiet? ...
-    FILTERS.each{Config[_1]=options.send("#{_1}?")}
+        return value
+      end
+      nil
+    end
+
+    # :reek:TooManyStatements
+    def reset
+      FILTERS.each { self[it] = false }
+
+      # Options:
+      self.file   = nil
+      self.git    = false
+      self.lang   = 'ruby'
+      self.theme  = 'github'
+      self.tab    = false
+      self.fuzzy  = 0.618034
+
+      # Colors:
+      # rubocop:disable Style/SymbolArray
+      self.context    = [:gray, :default]
+      self.deleted    = [:red, :default]
+      self.replaced   = [:magenta, :default]
+      self.duplicated = [:cyan, :default]
+      self.edited     = [:black, :default]
+      self.inserted   = [:green, :default]
+      self.touched    = [:blue, :default]
+      # rubocop:enable Style/SymbolArray
+    end
+
+    # :reek:TooManyStatements
+    def configure(options)
+      # FILE:
+      self.file = options.file if options.file?
+
+      # Options:
+      self.theme = options.theme if options.theme?
+      self.lang = options.lang if options.lang?
+      self.git = options.git?
+      self.tab = options.tab?
+      self.on = Regexp.new(options.on) if options.on?
+      self.off = Regexp.new(options.off) if options.off?
+      self.fuzzy = options.fuzzy.to_f if options.fuzzy?
+
+      FILTERS.each { self[it] = options.send("#{it}?") }
+      self.code = context if code
+      self.comment = context if comment
+      self.dupcode = context if dupcode
+      self.dupcomment = context if dupcomment
+
+      file_check
+    end
+
+    private
+
+    # :reek:UncommunicativeVariableName
+    def efd
+      e = File.exist?(file)
+      f = e && File.file?(file)
+      d = e && !f && File.directory?(file)
+      [e, f, d]
+    end
+
+    # :reek:UncommunicativeVariableName :reek:TooManyStatements
+    def file_check
+      return unless file
+
+      e, f, d = efd
+      raise Colora::Error, "Not a file or directory: #{file}" if e && !(f || d)
+      return if f # It is a file.
+
+      if git
+        return if d # It is a diff on directory.
+        return if gitlog
+      end
+      raise Colora::Error, "Does not exist: #{file}" unless e
+      raise Colora::Error, "Is a directory: #{file}" if d
+
+      raise "Unexpected error: #{file}" # Should not happen.
+    end
+
+    # :reek:UncommunicativeVariableName :reek:NilCheck :reek:TooManyStatements
+    def gitlog
+      return false unless (mdt = /^(\h+)(\.\.(\h+))?$/.match(file))
+
+      a, b = mdt.values_at(1, 3)
+      if a != b && /^\d$/.match?(a) && (b.nil? || /^\d$/.match?(b))
+        h = `git log --format='%h %s' -n 10`.lines
+                                            .map { it.strip.split(' ', 2) }
+        a, ma = h[a.to_i]
+        puts Paint["a: #{ma}", :bold]
+        if b
+          b, mb = h[b.to_i]
+          puts Paint["b: #{mb}", :bold]
+          self.file = "#{a}..#{b}"
+        else
+          self.file = a
+        end
+      end
+      true
+    end
+    # rubocop:enable Metrics
   end
+
+  Config = Struct::Config.new
+  Config.reset # Resets to default values.
 end

data/lib/colora/data.rb

@@ -1,74 +1,77 @@
+# frozen_string_literal: true
+
+# Colora namespace.
 module Colora
+  # Data class for processing git-diff lines.
+  # :reek:DuplicateMethodCall :reek:UncommunicativeVariableName
+  # :reek:TooManyStatements
   class Data
-    SPLIT = lambda do |line|
-      flag = line[0]
-      code, pounds, comment = line[1..].split(/(?<!['"])(\s*#+)(?!{)/, 2)
-      code = nil if code.empty?
-      comment ? [flag, code, pounds+comment] : [flag, code, nil]
+    def self.split(line)
+      case line[1..]
+      when /^\s*#/
+        [line[0], nil, line[1..]]
+      when %r{^(.*?)(\s*#[^`'")/\}\]]*)$}
+        [line[0], $LAST_MATCH_INFO[1], $LAST_MATCH_INFO[2]]
+      else
+        [line[0], line[1..], nil]
+      end
+      # [flag, code, comment]
     end
-    UPDATE = lambda do |hash, key, flag|
+
+    # :reek:NilCheck
+    def self.update(hash, key, flag)
       k = key.strip
       hash[k] = case hash[k]
                 when nil
-                    flag # added(+>) or removed(-<)
+                  flag # added or removed
                 when 'd', 't', flag
-                    'd' # duplicate
+                  'd' # duplicate
                 else
-                    't' # touched
+                  't' # touched
                 end
     end
 
-    def pre_process(line)
-      # rubocop:disable Lint/DuplicateBranch
-      case line.rstrip
-      when '', '+', '-', '---', /^[-+][-+][-+] [ab]/
-        line
-      when /^[-+<>]/
-        flag, code, comment = SPLIT[line]
-        f = flag=='-' ? '<' : flag=='+' ? '>' : flag
-        UPDATE[@codes, code, f] if code
-        UPDATE[@comments, comment, f] if comment
-        [flag, code, comment]
+    def self.reflag(flag)
+      if flag == '-'
+        '-'
       else
-        line
+        flag == '+' ? '+' : flag
       end
-      # rubocop:enable Lint/DuplicateBranch
     end
 
     attr_reader :lines
 
     def initialize(lines)
-      @lines,@codes,@comments,@edits = [],{},{},Set.new
-      while (line = lines.shift)
-        @lines << pre_process(line)
-      end
+      @lines = []
+      @codes = {}
+      @comments = {}
+      @edits = Set.new
+      populate_lines(lines)
       populate_edits
       @lines.each do |line|
         next unless line.is_a?(Array)
+
         post_process line
       end
-      @codes = @comments = @edits = nil # GC
     end
 
-    def populate_edits
-      partners = []
-      jarrow = FuzzyStringMatch::JaroWinkler.create(:pure) # Need pure for UTF-8
-      removed = @codes.select{|_,flag| '-<'.include?flag}.keys
-      added   = @codes.select{|_,flag| '+>'.include?flag}.keys
-      short, long = [removed, added].sort_by(&:length)
-      short.each do |a|
-        long.each do |b|
-          d = jarrow.getDistance(a, b)
-          partners.push([a, b, d]) if d > 0.618034
-        end
-      end
-      partners.sort_by(&:last).reverse.each do |a, b, _|
-        next if @edits.include?(a) || @edits.include?(b)
-        @edits.add(a)
-        @edits.add(b)
+    private
+
+    def flag_code_comment(line)
+      flag, code, comment = Data.split(line)
+      f = Data.reflag(flag)
+      Data.update(@codes, code, f) if code
+      Data.update(@comments, comment, f) if comment
+      [flag, code, comment]
+    end
+
+    def populate_lines(lines)
+      while (line = lines.shift)
+        @lines << pre_process(line)
       end
     end
 
+    # :reek:FeatureEnvy
     def post_process(line)
       if (code = line[1]&.strip)
         flag = @edits.include?(code) ? 'e' : @codes[code]
@@ -79,5 +82,48 @@ module Colora
         line[2] = [flag, line[2]]
       end
     end
+
+    def pre_process(line)
+      # rubocop:disable Lint/DuplicateBranch
+      case line.rstrip
+      when '', '+', '-', '---', %r{^[-+][-+][-+] [\w./]}
+        line
+      when /^[-+<>]/
+        flag_code_comment(line)
+      else
+        line
+      end
+      # rubocop:enable Lint/DuplicateBranch
+    end
+
+    def populate_edits
+      partners.sort_by(&:last).reverse.each do |a, b, _|
+        next if @edits.include?(a) || @edits.include?(b)
+
+        @edits.add(a)
+        @edits.add(b)
+      end
+    end
+
+    # :reek:NestedIterators
+    def partners
+      partners = []
+      short, long, jarrow = short_long_jarrow
+      short.each do |a|
+        long.each do |b|
+          d = jarrow.getDistance(a, b)
+          partners.push([a, b, d]) if d > Config.fuzzy
+        end
+      end
+      partners
+    end
+
+    def short_long_jarrow
+      jarrow = FuzzyStringMatch::JaroWinkler.create(:pure) # Need pure for UTF-8
+      removed = @codes.select { |_, flag| '-<'.include? flag }.keys
+      added   = @codes.select { |_, flag| '+>'.include? flag }.keys
+      short, long = [removed, added].sort_by(&:length)
+      [short, long, jarrow]
+    end
   end
 end

data/lib/colora/lines.rb

@@ -1,69 +1,148 @@
+# frozen_string_literal: true
+
+# Colora namespace
 module Colora
+  # Here we read lines and color each to be yielded out.
+  # rubocop:disable Metrics/ClassLength, Style/ClassVars
+  # :reek:TooManyInstanceVariables :reek:TooManyMethods :reek:ClassVariable
   class Lines
+    # :reek:DuplicateMethodCall :reek:UtilityFunction
+    def filehandle
+      if Config.git
+        IO.popen("git diff #{Config.file}")
+      elsif Config.file
+        File.open(Config.file)
+      else
+        $stdin
+      end
+    end
+
+    # :reek:FeatureEnvy
+    def get_lines(getter = filehandle)
+      getter.readlines.map(&:chomp)
+    ensure
+      getter.close
+    end
+
+    # :reek:DuplicateMethodCall
     def formatter
       theme = Rouge::Theme.find(Config.theme)
       raise Error, "Unrecognized theme: #{Config.theme}" unless theme
+
       Rouge::Formatters::Terminal256.new(theme.new)
     end
 
-    def get_lexer_by_file(file = Config.file)
+    def initialize
+      @formatter = formatter
+      @lines = get_lines
+      @lexer = @orig_lexer = guess_lexer
+      @tag   = @lexer.tag.to_sym
+      @lines = @tag == :diff ? Data.new(@lines).lines : @lines
+      @lang  = @orig_lang = Rouge::Lexer.find_fancy(Config.lang)
+      # `@on` is `true` unless there is a `Config.on` condition to be met
+      @on = Config.on ? false : true
+    end
+
+    def guess_lexer
+      return Rouge::Lexers::Diff if Config.git
+
+      guess_lexer_by_file || guess_lexer_by_source
+    end
+
+    # :reek:UtilityFunction
+    def guess_lexer_by_file(file = Config.file)
       return nil unless file && !File.extname(file).empty?
+
       Rouge::Lexer.guess_by_filename(file)
     end
 
-    def get_lexer_by_source(source)
+    def guess_lexer_by_source(source = @lines[0])
       case source
-      when /^---/, /^# /
-        Rouge::Lexer.guess_by_filename('*.md')
+      when /^---( #.*)?$/, /^# /
+        Rouge::Lexers::Markdown
+      when %r{^--- [\w./]}
+        Rouge::Lexers::Diff
       else
         Rouge::Lexer.guess_by_source(source)
       end
     end
 
-    def filehandle
-      Config.git ? IO.popen("git diff #{Config.file}") :
-      Config.file ? File.open(Config.file) :
-                    $stdin
+    # :reek:ControlParameter
+    def toggle(line)
+      if @on
+        @on = false if Config.off&.match?(line)
+      elsif Config.on&.match?(line)
+        @on = true
+      end
     end
 
-    def get_lines(fh = filehandle)
-      fh.readlines.map(&:chomp)
+    # rubocop:disable Metrics
+    # :reek:LongParameterList :reek:UncommunicativeParameterName
+    # :reek:UtilityFunction
+    def by_filters?(ary, ar0 = ary[0], dg1 = ary.dig(1, 0), dg2 = ary.dig(2, 0))
+      (Config.in && '-<'.include?(ar0)) ||
+        (Config.out && '+>'.include?(ar0)) ||
+        (Config.quiet && ((Config.code && [nil, 't'].include?(dg1)) ||
+                          (Config.comment && [nil, 't'].include?(dg2)) ||
+                          (Config.dupcode && dg1 == 'd') ||
+                          (Config.dupcomment && dg2 == 'd'))) ||
+        false
     end
+    # rubocop:enable Metrics
 
-    def initialize
-      @formatter = formatter
-      lines  = get_lines
-      @lexer = @orig_lexer = get_lexer_by_file || get_lexer_by_source(lines[0])
-      @tag   = @lexer.tag
-      @lines = @tag=='diff' ? Data.new(lines).lines : lines
-      @lang  = @orig_lang = Rouge::Lexer.find_fancy(Config.lang)
-      @pad0  = '    '
-      @pad1  = '  '
+    # :reek:ControlParameter
+    def filtered?(line, str = line.is_a?(String))
+      toggle(line) if str
+      return true unless @on
+      return false if str
+
+      by_filters?(line)
     end
 
-    def to_a = @lines
+    @@plugins = []
+    def self.plugins = @@plugins
 
-    def filtered?(line)
-      return false if line.is_a?(String)
+    def txt_formatter(line)
+      # Is there a plugin for @tag? If so, use it: Else use the lexer.
+      if Lines.plugins.include?(@tag)
+        send(@tag, line)
+      else
+        @formatter.format(@lexer.lex(line))
+      end
+    end
 
-      (Config.green && '-<'.include?(line[0])) ||
-        (Config.red && '+>'.include?(line[0])) ||
-        (Config.code && [nil,'t'].include?(line.dig 1,0)) ||
-        (Config.comment && [nil, 't'].include?(line.dig 2,0)) ||
-        (Config.dupcode && line.dig(1,0)=='d') ||
-        (Config.dupcomment && line.dig(2,0)=='d') ||
-        false
+    # :reek:TooManyStatements
+    def each
+      @lines.each do |line|
+        next if filtered?(line)
+
+        txt = txt_formatter(line)
+        yield txt if txt
+      end
+      reset_lexer
+      reset_lang
     end
 
-    def pad(line)
-      @pad0+line
+    # :reek:NilCheck
+    def reset_lexer(lang = nil)
+      @lexer = if lang.nil?
+                 @orig_lexer
+               else
+                 Rouge::Lexer.find_fancy(lang) || @orig_lexer
+               end
     end
 
-    def flags(line)
-        line[0] + (line.dig(1,0)||'*') + (line.dig(2,0)||'*') + @pad1
+    # :reek:NilCheck
+    def reset_lang(lang = nil)
+      @lang  = if lang.nil?
+                 @orig_lang
+               else
+                 Rouge::Lexer.find_fancy(lang) || @orig_lang
+               end
     end
 
-    def format(line, color=nil)
+    # :reek:NilCheck
+    def format(line, color = nil)
       case color
       when nil
         @formatter.format(@lexer.lex(line))
@@ -74,35 +153,15 @@ module Colora
       end
     end
 
-    def reset_lang_by_source(source)
-      @lang = Rouge::Lexer.guess_by_source(source)
-    end
-
     def reset_lang_by_filename(file)
       @lang = Rouge::Lexer.guess_by_filename(file)
     end
 
-    def reset_lexer(lang=nil)
-      @lexer = lang.nil? ? @orig_lexer :
-                           (Rouge::Lexer.find_fancy(lang) || @orig_lexer)
-    end
-
-    def reset_lang(lang=nil)
-      @lang  = lang.nil? ? @orig_lang :
-                           (Rouge::Lexer.find_fancy(lang) || @orig_lang)
+    def reset_lang_by_source(source)
+      @lang = Rouge::Lexer.guess_by_source(source)
     end
 
-    def each
-      @lines.each do |line|
-        next if filtered?(line)
-
-        # Is there a plugin for @tag? If so, use it: Else use the lexer.
-        txt = respond_to?(@tag) ? send(@tag, line) :
-                                  @formatter.format(@lexer.lex(line))
-        yield txt if txt
-      end
-      reset_lexer
-      reset_lang
-    end
+    def to_a = @lines
   end
+  # rubocop:enable Metrics/ClassLength, Style/ClassVars
 end

data/lib/colora/plugs/diff.rb

@@ -1,67 +1,107 @@
+# frozen_string_literal: true
+
+# Colora namespace
 module Colora
+  # Lines namespace
+  # :reek:DuplicateMethodCall :reek:NilCheck :reek:RepeatedConditional
   class Lines
+    plugins.push :diff
+
+    # Diff plugin
+    module Diff
+      # :reek:TooManyStatements
+      def self.flags(line)
+        case line[0]
+        when '-', '<'
+          ldg = line.dig(1, 0)
+          ['-', nil].any? { ldg == it } ? '- ' : '< '
+        when '+', '>'
+          ldg = line.dig(1, 0)
+          ['+', nil].any? { ldg == it } ? '+ ' : '> '
+        else
+          '* '
+        end
+      end
+
+      def self.pad(line)
+        " #{line}"
+      end
+    end
+
+    # category: method
+    # :reek:TooManyStatements
+    # rubocop:disable Metrics, Layout/LineLength
     def diff(line)
       case line
       when String
         case line
-        when /^[-+][-+][-+] [ab]\/(.*)$/
-          reset_lang_by_filename($~[1])
-          format(line)
+        when '-', '<'
+          format(line, Config.deleted)
+        when '+', '>'
+          format(line, Config.inserted)
+        when %r{^[-+][-+][-+] ([\w./].*)$}
+          reset_lang_by_filename($LAST_MATCH_INFO[1].strip.split.first)
+          format(line, :bold)
         when /^\s*#!/
           reset_lang_by_source(line)
           format(line) unless Config.quiet
         when /^ /
-          format(pad(line), :lang) unless Config.quiet
+          format(Diff.pad(line), Config.context) unless Config.quiet
         else
           format(line) unless Config.quiet
         end
       else
         # Initialized text variables
-        txt = ''
-        flags = flags(line)
-        code = line.dig(1,1)||''
-        comment = line.dig(2,1)||''
-        # txt << flags+code
+        txt = String.new
+        flags = Diff.flags(line)
+        code = line.dig(1, 1) || ''
+        comment = line.dig(2, 1) || ''
         case line[0]
         when '-', '<'
-          txt << format(flags+code+comment)
-          comment = '' # will skip commenting below
-        when '+', '>'
-          case line.dig(1,0)
-          when nil, 't'
-            txt << format(flags+code)
-          when 'd'
-            txt << format(flags, Config.dupplicated_flag)
-            txt << format(code, :lang)
-          when '>'
-            txt << format(flags, Config.inserted_flag)
-            txt << format(code, :lang)
-          when 'e'
-            txt << format(flags, Config.edited_flag)
-            txt << format(code, :lang)
-          else
-            warn "Unknown code type: #{line[0]}"
+          txt << format(flags, Config.deleted)
+          txt << case line.dig(1, 0)
+                 when '-'
+                   format(code, Config.get(:comment, :deleted))
+                 else
+                   format(code, Config.get(:comment, :replaced))
+                 end
+          unless comment.empty?
+            txt << case line.dig(2, 0)
+                   when '-'
+                     format(comment, Config.get(:code, :deleted))
+                   else
+                     format(comment, Config.get(:code, :replaced))
+                   end
           end
-        else
-          warn "Unknown line type: #{line[0]}"
-        end
-        # txt << comment
-        unless comment.empty?
-          case line.dig(2,0)
-          when 't'
-            txt << format(comment, Config.moved_comment)
-          when 'd'
-            txt << format(comment, Config.dupplicated_comment)
-          when '>'
-            txt << format(comment, Config.inserted_comment)
-          when 'e'
-            txt << format(comment, Config.edited_comment)
-          else
-            warn "Unknown comment type: #{line[0]}"
+          txt
+        when '+', '>'
+          txt << format(flags, Config.inserted)
+          txt << case line.dig(1, 0)
+                 when 'd'
+                   format(code, Config.get(:code, :comment, :dupcomment, :duplicated))
+                 when '+'
+                   format(code, Config.get(:comment, :dupcode, :dupcomment, :inserted))
+                 when 'e'
+                   format(code, Config.get(:comment, :dupcode, :dupcomment, :edited))
+                 else # t
+                   format(code, Config.get(:code, :comment, :dupcode, :dupcomment, :touched))
+                 end
+          unless comment.empty?
+            txt << case line.dig(2, 0)
+                   when 'd'
+                     format(comment, Config.get(:code, :comment, :dupcode, :duplicated))
+                   when '+'
+                     format(comment, Config.get(:code, :dupcode, :dupcomment, :inserted))
+                   when 'e'
+                     format(comment, Config.get(:code, :dupcode, :dupcomment, :edited))
+                   else # t
+                     format(comment, Config.get(:code, :comment, :dupcode, :dupcomment, :touched))
+                   end
           end
+          txt
         end
-        txt
       end
+      # rubocop:enable Metrics, Layout/LineLength
     end
   end
 end

data/lib/colora/plugs/markdown.rb

@@ -1,11 +1,21 @@
+# frozen_string_literal: true
+
+# Colora namespace
 module Colora
+  # Lines namespace
+  # :reek:DuplicateMethodCall
   class Lines
+    plugins.push :markdown
+
+    # Markdown plug
+    # :reek:TooManyStatements
+    # rubocop:disable Metrics
     def markdown(line)
       txt = nil
       case line
       when /^```(\w+)$/
         txt = format(line)
-        reset_lexer($~[1])
+        reset_lexer($LAST_MATCH_INFO[1])
       when /^```$/
         reset_lexer
         txt = format(line)
@@ -14,5 +24,6 @@ module Colora
       end
       txt
     end
+    # rubocop:enable Metrics
   end
 end

data/lib/colora/requires.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Standard libraries:
+require 'English'
+require 'ostruct'
+# Gems:
+require 'fuzzystringmatch'
+require 'paint'
+require 'rouge'
+# Colora:
+require_relative 'configure'
+require_relative 'data'
+require_relative 'lines'
+# Plugs:
+require_relative 'plugs/diff'
+require_relative 'plugs/markdown'

data/lib/colora.rb

@@ -1,32 +1,30 @@
+# frozen_string_literal: true
+
+# Colora colorizes output to the terminal.
 module Colora
-  class Error < RuntimeError; end
-  VERSION = '0.1.240114'
+  VERSION = '1.0.250401'
 
-  # Colora.run(options)
-  def self.run(options=nil)
-    # Standard libraries:
-    require 'ostruct'
-    # Gems:
-    require 'fuzzystringmatch'
-    require 'paint'
-    require 'rouge'
-    # Colora:
-    require_relative 'colora/configure'
-    require_relative 'colora/data'
-    require_relative 'colora/lines'
-    # Plugs:
-    require_relative 'colora/plugs/diff'
-    require_relative 'colora/plugs/markdown'
+  # Colora::Error for raised exceptions in Colora.
+  # Anything else is a bug.
+  class Error < RuntimeError
+  end
 
-    # Configure Colora:
-    Colora.configure(options) if options
-    # By default, run git-diff:
-    Config.git = true if $stdin.tty? && !Config.file
+  def self.parse_argv(help)
+    require 'help_parser'
+    HelpParser[VERSION, help]
+  end
 
-    # Puts Colora::Lines
+  # Colora.run(options)
+  # :reek:TooManyStatements
+  def self.run(options = nil)
+    require_relative 'colora/requires'
+    Config.configure(options) if options # Configure Colora:
+    # If stdin is a tty(we're not in a pipe) and no file is specified,
+    # then default to running git-diff.
+    Config.git = true if $stdin.tty? && !Config.file
     Lines.new.each do |line|
       line.gsub!("\t", '⇥') if Config.tab
-      puts line
+      puts line # Puts Colora::Lines
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: colora
 version: !ruby/object:Gem::Version
-  version: 0.1.240114
+  version: 1.0.250401
 platform: ruby
 authors:
 - CarlosJHR64
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-14 00:00:00.000000000 Z
+date: 2025-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuzzy-string-match
@@ -36,20 +35,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.2'
+        version: '9.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.2.230210
+        version: 9.0.240926
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.2'
+        version: '9.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.2.230210
+        version: 9.0.240926
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement
@@ -76,120 +75,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 4.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
-- !ruby/object:Gem::Dependency
-  name: colorize
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-- !ruby/object:Gem::Dependency
-  name: cucumber
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '9.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 9.1.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '9.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 9.1.1
-- !ruby/object:Gem::Dependency
-  name: parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.3.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.3.0
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.59'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.59.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.59'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.59.0
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.6.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.6.1
+        version: 4.5.1
 description: |
   Colorizes terminal outputs.
 
@@ -209,11 +108,11 @@ files:
 - lib/colora/lines.rb
 - lib/colora/plugs/diff.rb
 - lib/colora/plugs/markdown.rb
+- lib/colora/requires.rb
 homepage: https://github.com/carlosjhr64/colora
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -221,7 +120,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -229,8 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - 'git: 2.30'
-rubygems_version: 3.5.4
-signing_key: 
+rubygems_version: 3.6.6
 specification_version: 4
 summary: Colorizes terminal outputs.
 test_files: []