linter_changes 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9301ea21335f7cf36dcd50ec8006aca9c52e9a6df09a2560b7345b8807ae804f
-  data.tar.gz: 2c860bef46256629516fbdb98cc2141bfe6f92cdbc41a0081a695ffbcf07cfa1
+  metadata.gz: 5724a288156947b1ab1eca983b1ad38fc831e4523a504f2f574fb59f15a3bf72
+  data.tar.gz: e5c14aeda697cd7e68dc0b8812c0289e6eb2396960ead4c5517599bd56fa94a9
 SHA512:
-  metadata.gz: 19a5488a61b01ba6e917e70f63e9a9af87de3aecc7e8a8e13db493f2a0e3116c460371b2e10ba9d7ecc1f2c79d126b7abb4400940d0588eb9e068822a7f66f78
-  data.tar.gz: 9d8ddf964fd9a130055bd754651de0eb72811456271b2051dd3b410099521d8eaf4cd84a66f6a8d60a62daf76ce3aa231e4206f7173be7ed6c978d186de794f8
+  metadata.gz: 1502bf26bea370f48f367107989f0cd51ccf0ee32df9f7df628808d126cd658f41d867c90cf951396ab93eb75a8e79ecac5da1de93f6962df51ea4ad16296c67
+  data.tar.gz: d1e82c6a623eddc5b784b95a61ebd379626473efb018bbf92ff0d9242228380bc50b3d78a25ba13d69f6638ac39161498d92ee9d089050930f673ec1d370c2ea

data/README.md

@@ -4,7 +4,7 @@ LinterChanges is a Ruby gem that runs linters on files changed between your curr
 
 **What sets LinterChanges apart from other tools like Pronto is that it checks entire files rather than just the changed lines when raising errors. Additionally, if configuration changes for the linter occur, LinterChanges will run the linter on the entire repository, not just on the current changes.**
 
-Currently, **LinterChanges** supports **RuboCop** for Ruby code. Support for additional linters can be added in the future.
+Currently, **LinterChanges** supports **RuboCop** for Ruby code and **ESLint** for JavaScript/Vue. Support for additional linters can be added in the future.
 
 ---
 
@@ -15,8 +15,8 @@ Currently, **LinterChanges** supports **RuboCop** for Ruby code. Support for add
   - [Installation](#installation)
   - [Usage](#usage)
     - [Basic Usage](#basic-usage)
-    - [Specifying the Target Branch](#specifying-the-target-branch)
-    - [Customizing RuboCop Configuration](#customizing-rubocop-configuration)
+    - [CLI](#cli)
+    - [Customizing Configuration](#customizing-configuration)
   - [Contributing](#contributing)
   - [Running the test suite](#running-the-test-suite)
   - [Acknowledgments](#acknowledgments)
@@ -34,75 +34,108 @@ gem 'linter_changes', git: 'https://github.com/bukhr/linter_changes.git'
 ```bash
 bundle install
 ```
+
 ---
 
 ## Usage
 
-LinterChanges provides a command-line interface (CLI) to run RuboCop on the files changed between your current branch and the target branch.
+LinterChanges provides a command-line interface (CLI) to run Linters on the files changed between your current branch and the target branch. Also if you change a configuration file, it will run on the entire repository.
 
 ### Basic Usage
 
 By default, LinterChanges will:
 
-- Compare your current branch with the `main` branch.
-- Run the linters on the changed files that linter listen to.
+- Run globally on all files applying all linters specify in configuration.
+  - The linters will only run on files that the linter listen to.
+- Optionally, if you pass CHANGE_TARGET environment variable to run only on changed files between HEAD and the CHANGE_TARGET branch.
 
 **Command:**
 
 ```bash
-bin/linter_changes lint
+CHANGE_TARGET=origin/master bin/linter_changes lint
 ```
 
 **Example Output:**
 
+```bash
+❯ CHANGE_TARGET=master ./Jenkins/test-scripts/rubocop.sh
+[DEBUG] Using configuration file: .linter_changes.yml
+[DEBUG] Running Rubocop linter
+[DEBUG] Target branch: origin/master
+[DEBUG] Executing command: git diff --name-only origin/master...HEAD
+[DEBUG] Changed files: bin/linter_changes, packs/hcm/core/employee_management/app/models/employee.rb
+[DEBUG] Executing command: bin/rubocop --list-target-files
+[DEBUG] Linting files with [Rubocop]: packs/hcm/core/employee_management/app/models/employee.rb
+[DEBUG] [Rubocop] Executing command: bin/rubocop --parallel --extra-details --display-style-guide --fail-level convention --display-only-fail-level-offenses --format clang packs/hcm/core/employee_management/app/models/employee.rb
+
+1 file inspected, no offenses detected
 ```
-Running RuboCop linter
-Linting files with RuboCop: app/models/user.rb, app/controllers/users_controller.rb
-Inspecting 2 files
-..
-
-2 files inspected, no offenses detected
-```
-
-### Specifying the Target Branch
 
-If you want to compare against a different branch, you can specify it using the `--target-branch` option.
+### CLI
 
-**Command:**
+The `linter_changes` command provides several options to customize its behavior:
 
 ```bash
-bin/linter_changes lint --target-branch origin/master
+bin/linter_changes lint [options]
 ```
 
-This will compare your current branch with the `origin/master` branch.
+**Global Options:**
 
-### Customizing RuboCop Configuration
+- `--debug`: Enable debug mode to see detailed logging information
+- `--force_global`: Force running linters on all files, ignoring git diff
 
-You can customize the RuboCop configuration files and command options.
+**Lint Command Options:**
 
-**Specify Custom Config Files:**
+- `--linters=rubocop,eslint,...`: Specify which linters to run (comma-separated list)
+- `--config_file=PATH`: Path to the configuration file (default: `.linter_changes.yml`)
 
-Note: each config file passed is interpreted as regex on the full file path
+**Environment Variables:**
 
-```bash
-bin/linter_changes lint --config-files rubocop:rubocop,custom_rubocop.yml
-```
+- `CHANGE_TARGET`: Specify the target branch for comparison (e.g., `CHANGE_TARGET=origin/master`). If not specified, it will run on all files.
 
-**Specify Custom RuboCop Command:**
+**Examples:**
 
 ```bash
-bin/linter_changes lint --linter-command rubocop:"rubocop --parallel"
-```
+# Run with debug logging
+bin/linter_changes lint --debug
 
-**Combining Both:**
+# Force global run regardless of changed files
+bin/linter_changes lint --force_global
 
-```bash
-bin/linter_changes lint \
-  --config-files rubocop:.rubocop.yml,custom_rubocop.yml \
-  --linter-command rubocop:"rubocop --parallel"
+# Only run specific linters
+bin/linter_changes lint --linters=rubocop,eslint
+
+# Use a custom config file
+bin/linter_changes lint --config_file=custom_linter_config.yml
+
+# Combine options
+CHANGE_TARGET=main bin/linter_changes lint --debug --linters=rubocop
 ```
 
+### Customizing Configuration
+
+You can customize the configuration creating a file called `.linter_changes.yml` at the root of your proyect.
+
+Example:
+
+```yml
 ---
+rubocop:
+  linter_command: "bin/rubocop \
+    --parallel \
+    --extra-details \
+    --display-style-guide \
+    --fail-level convention \
+    --display-only-fail-level-offenses \
+    --format clang"
+  config_files:
+  - "rubocop"
+```
+
+each key represents a linter (e.g., `rubocop`) and inside it you can specify the linter command and the files that trigger a global run of the linter.
+In this example, if a file containing `rubocop` is edited, it would trigger a full run on all the proyect.
+
+Also, if you want to specify another yml file, you can pass it though the cli with the option `--config_file`. The default is `.linter_changes.yml`.
 
 ## Contributing
 
@@ -154,4 +187,4 @@ bundle exec rake test
 - **Full File Linting:** Unlike tools like Pronto that only check the changed lines, LinterChanges lints the entire files that have been modified. This ensures that any issues in the modified files are caught, not just those in the changed lines.
 - **Configuration Change Detection:** If a configuration file for the linter (e.g., `.rubocop.yml`) has changed, LinterChanges will run the linter on the entire repository. This ensures that any new or altered linting rules are applied across all files.
 
----
+---

data/bin/linter_changes

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'bundler/setup'
-require_relative '../lib/cli'
+require_relative '../lib/linter_changes/cli'
 
 LinterChanges::CLI.start(ARGV)

data/bin/tapioca

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")

data/lib/linter_changes/cli.rb

@@ -0,0 +1,75 @@
+# typed: true
+
+require 'bundler/setup'
+require 'thor'
+require 'sorbet-runtime'
+
+require_relative 'git_diff'
+require_relative 'logger'
+require_relative 'linter/base'
+require_relative 'linter/rubocop/adapter'
+require_relative 'linter/eslint/adapter'
+require_relative 'config'
+
+module LinterChanges
+  class CLI < Thor
+    extend T::Sig
+
+    class_option :debug, type: :boolean, default: false, desc: 'Enable debug mode'
+    class_option :force_global, type: :boolean, default: false, desc: 'Run all linters on global configuration'
+
+    method_option :linters, type: :array, default: [],
+                            desc: 'Specify linters to run (e.g., rubocop,eslint). If no option provided, will run everything at config file'
+    method_option :config_file, type: :string, default: LinterChanges::Config::USER_CONFIG_PATH,
+                        desc: 'Path to the configuration file. Default: $(pwd)/.linter_changes.yml'
+    desc 'lint', 'Run linters on changed files'
+
+    sig { returns(T.noreturn) }
+    def lint
+      Logger.debug_mode = options[:debug]
+
+      Logger.debug "Using configuration file: #{options[:config_file]}"
+      @config = LinterChanges::Config.load(config_file: options[:config_file])
+      overall_success = T.let(true, T::Boolean)
+
+      select_linters.each do |linter|
+        Logger.debug "Running #{linter.name.capitalize} linter"
+        overall_success &&= linter.run
+      end
+
+      exit(overall_success ? 0 : 1)
+    end
+
+    sig { returns(T::Boolean) }
+    def self.exit_on_failure?
+      true
+    end
+
+    no_commands do
+      def select_linters
+        linter_names = @config.keys && options[:linters]
+        if linter_names.empty?
+          Logger.error 'No linters specified on configuration file.'
+          exit 1
+        end
+        linter_names.map do |name|
+          klass = AVAILABLE_LINTERS[name]
+          unless klass
+            Logger.error "Unknown linter specified: #{name}"
+            exit 1
+          end
+
+          # TODO: raise if no command found
+          config_files = @config[name]['config_files'] || []
+          command = @config[name]['linter_command']
+          klass.new(config_files:, command:, force_global: options[:force_global])
+        end
+      end
+    end
+
+    AVAILABLE_LINTERS = {
+      'rubocop' => LinterChanges::Linter::RuboCop::Adapter,
+      'eslint' => LinterChanges::Linter::Eslint::Adapter
+    }.freeze
+  end
+end

data/lib/linter_changes/config.rb

@@ -0,0 +1,21 @@
+# typed: true
+
+require 'yaml'
+
+module LinterChanges
+  class Config
+    extend T::Sig
+    USER_CONFIG_PATH = '.linter_changes.yml'
+
+    sig { params(config_file: String).returns(T::Hash[String, T.untyped]) }
+    def self.load config_file: USER_CONFIG_PATH
+      config_file = File.join(Dir.pwd, config_file)
+      user_config = File.exist?(config_file) ? YAML.load_file(config_file) : nil
+      unless user_config
+        raise StandardError.new 'No configuration file provided, you need the file .linter_changes.yml at the base of your proyect'
+      end
+
+      user_config
+    end
+  end
+end

data/lib/linter_changes/git_diff.rb

@@ -0,0 +1,64 @@
+# typed: true
+
+require 'open3'
+
+module LinterChanges
+  class GitDiff
+    extend T::Sig
+    sig { params(target_branch: String).void }
+    def initialize(target_branch:)
+      @target_branch = target_branch
+    end
+
+    sig { returns(T::Array[String]) }
+    def changed_files
+      return @changed_files if defined? @changed_files
+
+      Logger.debug "Target branch: #{@target_branch}"
+      cmd = "git diff --name-only #{@target_branch}...HEAD"
+      Logger.debug "Executing command: #{cmd}"
+
+      stdout, stderr, status = Open3.capture3(cmd)
+      unless status.success?
+        Logger.error "Error obtaining git changes: #{stderr}"
+        exit 1
+      end
+
+      @changed_files = stdout.strip.split("\n")
+      Logger.debug "Changed files: #{@changed_files.join(', ')}"
+      @changed_files
+    end
+
+    sig { params(file: String, pattern: String).returns(T::Boolean) }
+    def changed_lines_contains? file:, pattern:
+      cmd = "git diff #{@target_branch}...HEAD -- #{file}"
+      stdout, stderr, status = Open3.capture3(cmd)
+      unless status.success?
+        Logger.error "Error obtaining git diff for #{file}: #{stderr}"
+        exit 1
+      end
+      stdout.include? pattern
+    end
+
+    sig { params(ref: String).returns(T::Boolean) }
+    def reference_exists?(ref)
+      !!system("git rev-parse --verify #{ref} > /dev/null 2>&1")
+    end
+
+    sig { returns(T::Boolean) }
+    def references_exists?
+      return @references_exist if defined?(@references_exists)
+
+      @references_exist = if !reference_exists?(@target_branch)
+                            Logger.debug("Reference for #{@target_branch} does not exists")
+                            false
+                          elsif !reference_exists?('HEAD')
+                            Logger.debug('Reference for HEAD does not exists')
+                            false
+                          else
+                            true
+                          end
+      @references_exist
+    end
+  end
+end

data/lib/linter_changes/linter/base.rb

@@ -0,0 +1,82 @@
+# typed: true
+
+module LinterChanges
+  module Linter
+    class Base
+      extend T::Sig
+      attr_reader :name
+
+      sig { params(config_files: T::Array[String], command: String, force_global: T::Boolean).void }
+      def initialize(config_files:, command:, force_global:)
+        @name = T.must(self.class.name).split('::')[-2].then do |adapter_name|
+          T.must(adapter_name).downcase
+        end
+        @config_files = config_files
+        @command = command
+        @base_command = @command.split(' ').first # used for listing files with in the adaptars
+        @target_branch = ENV['CHANGE_TARGET']
+        # We force origin if the target_branch is present
+        @target_branch = "origin/#{@target_branch}" if !@target_branch.nil? && !@target_branch['origin']
+        if @target_branch
+          @git_diff = GitDiff.new(target_branch: @target_branch)
+        end
+        @force_global = force_global || @target_branch.nil?
+        @force_global = true unless @git_diff&.references_exists?
+      end
+
+      sig { returns(T::Array[String]) }
+      def changed_files
+        @git_diff.changed_files
+      end
+
+      # Returns an array of files that the linter targets
+      sig { returns(T::Array[String]) }
+      def list_target_files
+        raise NotImplementedError, "#{self.class} must implement #list_target_files"
+      end
+
+      # Checks if any configuration files have changed
+      sig { returns(T::Boolean) }
+      def config_changed?
+        @config_files.any? do |pattern|
+          changed_files.any? { |file| file.match? Regexp.new(pattern) }
+        end
+      end
+
+      # Runs the linter on the specified files
+      sig { returns(T::Boolean) }
+      def run
+        if @force_global
+          if @target_branch.nil?
+            Logger.debug "[#{name.capitalize}] No git branch provided by CHANGE_TARGET enviroment variable, running globally."
+          elsif !@git_diff.references_exists?
+            Logger.debug "[#{name.capitalize}] Some git reference does not exists locally. Forced to run globally"
+          else
+            Logger.debug "[#{name.capitalize}] Forced to run globally."
+          end
+          execute_linter(@command)
+        elsif config_changed?
+          Logger.debug "[#{name.capitalize}] Configuration changed. Running linter globally."
+          execute_linter(@command)
+        else
+          files_to_lint = list_target_files & changed_files
+          if files_to_lint.empty?
+            Logger.debug "No files to lint for [#{name.capitalize}]."
+            true
+          else
+            Logger.debug "Linting files with [#{name.capitalize}]: #{files_to_lint.join(', ')}"
+            execute_linter("#{@command} #{files_to_lint.join(' ')}")
+          end
+        end
+      end
+
+      private
+
+      sig { params(command: String).returns(T::Boolean) }
+      def execute_linter(command)
+        Logger.debug "[#{name.capitalize}] Executing command: #{command}"
+        !!system(command)
+      end
+    end
+  end
+end

data/lib/linter_changes/linter/eslint/adapter.rb

@@ -0,0 +1,23 @@
+# typed: true
+
+module LinterChanges
+  module Linter
+    module Eslint
+      class Adapter < Base
+        extend T::Sig
+
+        # ESLint no ofrece un equivalente a `bin/rubocop --list-target-files`,
+        # asi que derivamos los archivos objetivo filtrando los cambiados por
+        # extension. `Base#run` los intersecta con los archivos del diff, de
+        # modo que solo se linteara lo modificado. Los archivos en `.eslintignore`
+        # que pasen este filtro son descartados por el propio ESLint.
+        EXTENSIONS = T.let(%w[.js .jsx .ts .tsx .vue .mjs .cjs].freeze, T::Array[String])
+
+        sig { returns(T::Array[String]) }
+        def list_target_files
+          changed_files.select { |file| EXTENSIONS.include?(File.extname(file)) }
+        end
+      end
+    end
+  end
+end

data/lib/{linter → linter_changes/linter}/rubocop/adapter.rb

@@ -1,15 +1,14 @@
-# lib/linter_changes/linter/rubocop/adapter.rb
+# typed: true
 
 module LinterChanges
   module Linter
     module RuboCop
       class Adapter < Base
-        # By default, anything containing rubocop on the file path will be consider a config file
-        DEFAULT_CONFIG_FILES = [/rubocop/].freeze
-        DEFAULT_COMMAND = 'bin/rubocop'.freeze
+        extend T::Sig
 
+        sig { returns(T.any(T::Array[String], T.noreturn)) }
         def list_target_files
-          cmd = "#{DEFAULT_COMMAND} --list-target-files"
+          cmd = "#{@base_command} --list-target-files"
           Logger.debug "Executing command: #{cmd}"
 
           stdout, stderr, status = Open3.capture3(cmd)
@@ -21,43 +20,20 @@ module LinterChanges
           stdout.strip.split("\n")
         end
 
-        def run(files: [])
-          cmd = if files.empty?
-                  @command
-                else
-                  "#{@command} #{files.join(' ')}"
-                end
-          execute_linter(cmd)
-        end
-
-        def config_changed?(changed_files)
+        sig { returns(T::Boolean) }
+        def config_changed?
           # Check if any of the config files have changed
           return true if super
 
           # TODO: get the location of Gemfile.lock with bundle command
           # Check if Gemfile.lock has changed and contains something related to rubocop
           if changed_files.include?('Gemfile.lock') && @git_diff.changed_lines_contains?(file: 'Gemfile.lock',
-                                                                                        pattern: 'rubocop')
+                                                                                         pattern: 'rubocop')
             Logger.debug 'Something related to rubocop gem version changed in Gemfile.lock'
             return true
           end
           false
         end
-
-        private
-
-        def default_config_files
-          DEFAULT_CONFIG_FILES
-        end
-
-        def default_command
-          DEFAULT_COMMAND
-        end
-
-        def execute_linter(command)
-          Logger.debug "Executing RuboCop command: #{command}"
-          system(command)
-        end
       end
     end
   end

data/lib/{logger.rb → linter_changes/logger.rb}

@@ -1,14 +1,17 @@
-# lib/your_linter_gem/logger.rb
+# typed: true
 
 module LinterChanges
   class Logger
     class << self
+      extend T::Sig
       attr_accessor :debug_mode
 
+      sig { params(message: String).void }
       def debug(message)
         puts "[DEBUG] #{message}" if debug_mode
       end
 
+      sig { params(message: String).void }
       def error(message)
         puts "[ERROR] #{message}"
       end

data/lib/{version.rb → linter_changes/version.rb}

@@ -1,5 +1,6 @@
+# typed: true
 # frozen_string_literal: true
 
 module LinterChanges
-  VERSION = '0.2.0'
+  VERSION = '0.3.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linter_changes
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Jose Lara
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-20 00:00:00.000000000 Z
+date: 2026-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -19,7 +19,7 @@ dependencies:
         version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,21 +29,21 @@ dependencies:
         version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
-  name: open3
+  name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -62,16 +62,22 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -184,7 +190,35 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
-description: 
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
 email:
 - jvlara@uc.cl
 executables:
@@ -195,18 +229,20 @@ files:
 - README.md
 - bin/linter_changes
 - bin/setup
-- lib/cli.rb
-- lib/git_diff.rb
-- lib/linter/base.rb
-- lib/linter/rubocop/adapter.rb
-- lib/linter/rubocop/default_config.yml
-- lib/logger.rb
-- lib/version.rb
+- bin/tapioca
+- lib/linter_changes/cli.rb
+- lib/linter_changes/config.rb
+- lib/linter_changes/git_diff.rb
+- lib/linter_changes/linter/base.rb
+- lib/linter_changes/linter/eslint/adapter.rb
+- lib/linter_changes/linter/rubocop/adapter.rb
+- lib/linter_changes/logger.rb
+- lib/linter_changes/version.rb
 homepage: https://github.com/bukhr/linter_changes
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -224,8 +260,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.15
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Runs linters on code changes based on Git, either globally or only on modified
   files, depending on the changes.

data/lib/cli.rb

@@ -1,89 +0,0 @@
-# lib/linter_changes/cli.rb
-
-require 'bundler/setup'
-require 'thor'
-require_relative 'git_diff'
-require_relative 'logger'
-require_relative 'linter/base'
-require_relative 'linter/rubocop/adapter'
-require 'pry-byebug'
-
-module LinterChanges
-  class CLI < Thor
-    class_option :debug, type: :boolean, default: false, desc: 'Enable debug mode'
-    class_option :target_branch, type: :string, default: nil, desc: 'Specify the target branch'
-
-    desc 'lint', 'Run linters on changed files'
-    method_option :linters, type: :array, default: [], desc: 'Specify linters to run (e.g., rubocop,eslint)'
-    method_option :config_files, type: :hash, default: {},
-                                 desc: 'Specify config files per linter (e.g., rubocop=.rubocop.yml)'
-    method_option :linter_command, type: :hash, default: {},
-                                   desc: 'Specify command per linter (e.g., rubocop="rubocop --parallel")'
-    def lint
-      Logger.debug_mode = options[:debug]
-
-      git_diff = GitDiff.new(target_branch: options[:target_branch])
-      changed_files = git_diff.changed_files
-      linters = select_linters git_diff
-      overall_success = true
-
-      linters.each do |linter|
-        Logger.debug "Running #{linter.name.capitalize} linter"
-        if linter.config_changed?(changed_files)
-          Logger.debug "#{linter.name.capitalize} configuration changed. Running linter globally."
-          success = linter.run
-        else
-          files_to_lint = linter.list_target_files & changed_files
-          if files_to_lint.empty?
-            Logger.debug "No files to lint for #{linter.name.capitalize}."
-            next
-          else
-            Logger.debug "Linting files with #{linter.name.capitalize}: #{files_to_lint.join(', ')}"
-            success = linter.run(files: files_to_lint)
-          end
-        end
-
-        overall_success &&= success
-      end
-
-      exit(overall_success ? 0 : 1)
-    end
-
-    def self.exit_on_failure?
-      true
-    end
-
-    no_commands do
-      def select_linters git_diff
-        linter_names = if options[:linters].empty?
-                         AVAILABLE_LINTERS.keys
-                       else
-                         options[:linters]
-                       end
-        linter_names.map do |name|
-          klass = AVAILABLE_LINTERS[name]
-          unless klass
-            Logger.error "Unknown linter specified: #{name}"
-            exit 1
-          end
-
-          # Pass custom config files and commands if provided
-          config_files = parse_config_files_option(name)
-          command = options[:linter_command][name]
-          klass.new(config_files:, command:, git_diff:)
-        end
-      end
-
-      def parse_config_files_option(linter_name)
-        config_files_option = options[:config_files][linter_name]
-        return nil unless config_files_option
-
-        config_files_option.split(',')
-      end
-    end
-
-    AVAILABLE_LINTERS = {
-      'rubocop' => LinterChanges::Linter::RuboCop::Adapter
-    }.freeze
-  end
-end

data/lib/git_diff.rb

@@ -1,39 +0,0 @@
-# lib/your_linter_gem/git_diff.rb
-
-require 'open3'
-
-module LinterChanges
-  class GitDiff
-    DEFAULT_TARGET_BRANCH = 'origin/master'
-
-    def initialize(target_branch: nil)
-      @target_branch = target_branch || ENV['CHANGE_TARGET'] || DEFAULT_TARGET_BRANCH
-      Logger.debug "Target branch: #{@target_branch}"
-    end
-
-    def changed_files
-      cmd = "git diff --name-only #{@target_branch}...HEAD"
-      Logger.debug "Executing command: #{cmd}"
-
-      stdout, stderr, status = Open3.capture3(cmd)
-      unless status.success?
-        Logger.error "Error obtaining git changes: #{stderr}"
-        exit 1
-      end
-
-      files = stdout.strip.split("\n")
-      Logger.debug "Changed files: #{files.join(', ')}"
-      files
-    end
-
-    def changed_lines_contains? file:, pattern:
-      cmd = "git diff #{@target_branch}...HEAD -- #{file}"
-      stdout, stderr, status = Open3.capture3(cmd)
-      unless status.success?
-        Logger.error "Error obtaining git diff for #{file}: #{stderr}"
-        exit 1
-      end
-      stdout.include? pattern
-    end
-  end
-end

data/lib/linter/base.rb

@@ -1,46 +0,0 @@
-# lib/linter_changes/linter/base.rb
-
-module LinterChanges
-  module Linter
-    class Base
-      attr_reader :name
-
-      def initialize(config_files: nil, command: nil, git_diff: nil)
-        @name = self.class.name.split('::')[-2].downcase
-        default_config_file = YAML.load_file("lib/linter/#{@name}/default_config.yml")
-        @config_files = config_files || default_config_file['config_files']
-        @command = command || default_config_file['command']
-        @git_diff = git_diff
-      end
-
-      # Returns an array of files that the linter targets
-      def list_target_files
-        raise NotImplementedError, "#{self.class} must implement #list_target_files"
-      end
-
-      # Checks if any configuration files have changed
-      def config_changed?(changed_files)
-        changed = @config_files.any? do |pattern|
-          changed_files.any? { |file| file.match? Regexp.new(pattern) }
-        end
-        Logger.debug "#{@name.capitalize} configuration changed: #{changed}"
-        changed
-      end
-
-      # Runs the linter on the specified files
-      def run(files: [])
-        raise NotImplementedError, "#{self.class} must implement #run"
-      end
-
-      private
-
-      def default_config_files
-        raise NotImplementedError, "#{self.class} must implement #default_config_files"
-      end
-
-      def default_command
-        raise NotImplementedError, "#{self.class} must implement #default_command"
-      end
-    end
-  end
-end

data/lib/linter/rubocop/default_config.yml

@@ -1,5 +0,0 @@
----
-# Only regex supported
-config_files:
-  - rubocop
-command: bin/rubocop