ccru 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66fdeba1e23df9b584d0b8f8f8ea2624497a2c570fce20b135a1b6f70babd39d
+  data.tar.gz: ec06b11b0728bf84c00f49770829b345ce62f7d95748885e82a54d418160b748
+SHA512:
+  metadata.gz: d06a3bcb1bad991407f3b367bc9ccdd7fa7bbd5d329c148c1524d5434847c572cfcc1a65e790a0465e14da5c1367c9a6ed5d0eaa5d7f18286d3b4bb2a3df509a
+  data.tar.gz: 46298743b4620789e3a3452f12994dd4e69ba5492145dcee2101372b7a599fe1fa9c892a209f6d5e26f1302b71ce35c8f0987f3a2dcbc95b738555c8ac4895cf

data/.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Ruby ${{ matrix.ruby }}
+    strategy:
+      matrix:
+        ruby:
+          - '3.3.0'
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Run the default task
+      run: bundle exec rake

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.0
+  NewCops: enable
+  SuggestExtensions: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Metrics/ClassLength:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,79 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2025-08-29
+
+### Added
+- **JavaScript ES6 Syntax Checking**: New feature to detect ES6+ syntax violations in JavaScript files
+- **Multi-language Support**: Now supports both Ruby (.rb) and JavaScript (.js) files
+- **File Type Detection**: Automatic detection of file types and appropriate linter selection
+- **ES6 Violation Rules**: Built-in detection for:
+  - Arrow functions (`=>`)
+  - const/let declarations
+  - Template literals (`` `string ${var}` ``)
+  - Destructuring assignments
+  - Spread operator (`...`)
+  - ES6 classes
+  - ES6 modules (import/export)
+  - Default parameters
+  - Rest parameters
+- **JavaScript Code Quality Rules**: Comprehensive code quality checking including:
+  - **Code Style & Formatting**:
+    - Trailing whitespace detection
+    - Missing final newline detection
+    - Line length checking (120 characters)
+  - **Best Practices**:
+    - Console statement warnings (console.log, console.debug, etc.)
+    - Eval usage errors (security risk)
+    - With statement errors (deprecated)
+    - Document write warnings (performance/security)
+  - **Potential Bug Detection**:
+    - Loose equality warnings (== vs ===, allows == null/undefined)
+    - Loose inequality warnings (!= vs !==)
+    - Unused variable detection
+    - Missing semicolon detection (with smart detection)
+    - Inline comment warnings
+  - **Performance & Security**:
+    - innerHTML usage warnings (XSS risk)
+    - Global variable pollution warnings
+- **ERB Template Support**: Custom ERB linter for convention checking:
+  - Proper spacing validation (`<% code %>` vs `<%code%>`)
+  - Comment format validation (`<%# comment %>` vs `<% # comment %>`)
+  - Output spacing validation (`<%= code %>` vs `<%=code%>`)
+- **Enhanced CLI Options**: Support for RuboCop options via `--` separator
+- **Improved Output Format**: Consistent violation reporting across all linters
+
+### Changed
+- **Architecture Refactor**: Restructured code to support multiple linters
+- **Module Organization**: Clean separation of concerns with dedicated modules:
+  - `LinterRunner`: Main orchestration module
+  - `RuboCopRunner`: Ruby file processing
+  - `JavaScriptLinterRunner`: JavaScript file processing
+  - `ErbLinterRunner`: ERB template processing
+- **Git Diff Enhancement**: Extended to detect and process multiple file types
+- **Violation Formatting**: Unified output format for all linter types
+
+### Technical Improvements
+- **Modular Design**: Clean separation of concerns with dedicated modules
+- **Extensible Architecture**: Easy to add support for new file types and linters
+- **Backward Compatibility**: Existing Ruby-only functionality preserved
+- **Performance**: Maintains the same fast git-diff-based approach
+- **Error Handling**: Improved error handling and file reading safety
+
+### New Command Line Options
+- Support for passing RuboCop options: `bundle exec ccru -- --auto-correct`
+
+### Notes
+- Staged changes support is implemented in the code but not exposed via command line options
+- Base branch can only be specified via environment variable `CCRU_BASE`
+
+## [0.1.0] - 2024-12-19
+
+### Added
+- Initial release
+- RuboCop integration for Ruby files
+- Git diff-based change detection
+- Line-level filtering for modified files
+- Base branch specification via environment variable
+- Basic file handling and offense printing

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ccru.gemspec
+gemspec
+
+gem "pry", "0.15.2"

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    ccru (0.1.0)
+      rubocop (>= 0.5, < 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.3)
+    coderay (1.1.3)
+    json (2.13.2)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    method_source (1.1.0)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.4.0)
+    pry (0.15.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.11.2)
+    rubocop (1.79.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.46.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.46.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (3.1.5)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+
+PLATFORMS
+  arm64-darwin-24
+  ruby
+
+DEPENDENCIES
+  ccru!
+  pry (= 0.15.2)
+
+BUNDLED WITH
+   2.5.22

data/README.md

@@ -0,0 +1,88 @@
+# ccru – Code Changed Rules (RuboCop + ES6 Syntax + ERB Checker)
+
+RuboCop on diff for Ruby files + ES6 syntax checker for JavaScript files + ERB template support: lint only what's new/changed
+
+## Install
+
+```ruby
+group :development, :test
+  gem 'ccru', require: false
+end
+```
+
+## Usage
+
+### Basic Usage
+
+```bash
+# Check changed Ruby, JavaScript, and ERB files in git diff (compared to merge-base)
+bundle exec ccru
+
+# Check specific files
+bundle exec ccru path/to/file.rb path/to/script.js path/to/template.erb
+```
+
+### Environment Variables
+
+```bash
+# Set default base branch for git diff comparison
+export CCRU_BASE=develop
+bundle exec ccru
+```
+
+## Supported File Types
+
+- **Ruby files**: `.rb` - Checked with RuboCop
+- **JavaScript files**: `.js` - Checked for ES6 syntax violations + code quality
+- **ERB templates**: `.erb` - Checked with custom ERB linter for conventions
+
+## ERB Template Support
+
+### Ruby ERB Templates (`.erb`)
+- Automatically checks ERB conventions and formatting
+- Validates proper spacing: `<% code %>` instead of `<%code%>`
+- Checks comment format: `<%# comment %>` instead of `<% # comment %>`
+- Ensures proper output spacing: `<%= code %>` instead of `<%=code%>`
+- Maps violations back to original ERB line numbers
+
+## JavaScript ES6 Violations Checked
+
+The following ES6+ syntax patterns are detected and flagged as errors:
+
+- **Arrow functions**: `=>` syntax
+- **const/let**: `const` and `let` declarations
+- **Template literals**: `` `string ${variable}` ``
+- **Destructuring**: `{ prop } = obj` assignments
+- **Spread operator**: `...` syntax
+- **ES6 classes**: `class` declarations
+- **ES6 modules**: `import`/`export` statements
+- **Default parameters**: `function(param = value)`
+- **Rest parameters**: `function(...args)`
+
+## JavaScript Code Quality Rules
+
+### Code Style & Formatting
+- **Trailing whitespace**: Detects spaces at end of lines
+- **Missing final newline**: Ensures files end with newline
+- **Line length**: Maximum line length checking (120 characters)
+
+### Best Practices
+- **Console statements**: Warns about `console.log`, `console.debug`, etc.
+- **Eval usage**: Errors on dangerous `eval()` calls
+- **With statement**: Errors on deprecated `with` statements
+- **Document write**: Warns about `document.write()` usage
+
+### Potential Bugs
+- **Loose equality**: Warns about `==` vs `===` usage (allows `== null` and `== undefined`)
+- **Loose inequality**: Warns about `!=` vs `!==` usage
+- **Unused variables**: Detects potentially unused variable declarations
+- **Missing semicolons**: Identifies missing semicolons (with smart detection)
+- **Inline comments**: Warns about inline comments at end of code lines
+
+### Performance Issues
+- **innerHTML usage**: Warns about potential XSS vulnerabilities
+- **Global variables**: Warns about global scope pollution
+
+## License
+
+This project is licensed under the MIT License.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ccru"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ccru.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/ccru/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ccru"
+  spec.version = Ccru::VERSION
+  spec.authors = ["thucpt"]
+  spec.email = ["thucpt@zigexn.vn"]
+
+  spec.summary = "Multi-language linter wrapper that checks only changed lines/files (Ruby, JavaScript, ERB)"
+  spec.description = "Checks only new files fully and modified files only for changed lines based on git diff.\
+  Supports Ruby (RuboCop), JavaScript (ES6 syntax + code quality), and ERB templates (conventions)."
+  spec.homepage = "https://github.com/thuczige/ccru"
+  spec.required_ruby_version = ">= 2.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/thuczige/ccru"
+  spec.metadata["changelog_uri"] = "https://github.com/thuczige/ccru/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  File.basename(__FILE__)
+  spec.files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  spec.add_dependency "rubocop", ">= 0.5", "< 2.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/exe/ccru

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "ccru"
+
+# CLI will be autoloaded when accessed
+exit Ccru::CLI.new.run(ARGV)

data/lib/ccru/cli.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "git_diff"
+require_relative "linter_runner"
+
+require "pry"
+
+module Ccru
+  # Command-line interface for ccru
+  class CLI
+    def run(argv)
+      puts "\n[START] #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}\n\n"
+      opts = { base: ENV.fetch("CCRU_BASE", nil), staged: false, files: argv }
+
+      # Check if there are specific files provided
+      return run_on_specific_files(opts[:files]) if opts[:files] && opts[:files].any?
+
+      files = Ccru::GitDiff.changed_files(opts[:base], opts[:staged])
+      return no_changes if files.empty?
+
+      run_on_files(files)
+    end
+
+    private
+
+    include LinterRunner
+
+    def run_on_specific_files(file_paths)
+      has_errors = false
+
+      file_paths.each do |path|
+        result = process_specific_file(path)
+        has_errors = true if result == 1
+      end
+
+      return 1 if has_errors
+
+      puts_all_ok
+      0
+    end
+
+    def process_specific_file(path)
+      return 0 unless valid_file?(path)
+
+      file_type = FileTypeDetector.file_type(path)
+      meta = { type: :new, lines: nil, file_type: file_type }
+
+      run_linter_file(path, meta)
+    end
+
+    def valid_file?(path)
+      File.exist?(path) && FileTypeDetector.supported_file?(path)
+    end
+
+    def no_changes
+      puts_all_ok
+      0
+    end
+
+    def run_on_files(files)
+      has_errors = false
+
+      files.each do |path, meta|
+        result = process_file(path, meta)
+        has_errors = true if result == 1
+      end
+
+      return 1 if has_errors
+
+      puts_all_ok
+      0
+    end
+
+    def process_file(path, meta)
+      return run_linter_file(path, meta) if meta[:type] == :new
+
+      run_linter_filtered(path, meta)
+    end
+
+    def puts_all_ok
+      puts "ccru: All OK - No violations found\n\n"
+    end
+  end
+end

data/lib/ccru/erb_linter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "usual_linter"
+
+module Ccru
+  # ERB linter that checks basic ERB conventions
+  class ErbLinter
+    include UsualLinter
+
+    def initialize
+      @offenses = []
+    end
+
+    # ERB convention violations
+    ERB_VIOLATIONS = {
+      # Bad comment format: <% # comment %> instead of <%# comment %>
+      bad_comment_format: {
+        pattern: /<%\s+#[^%]*%>/,
+        message: "Use <%# comment %> instead of <% # comment %> for ERB comments",
+        cop_name: "BadCommentFormat",
+        severity: "error"
+      },
+      # Bad spacing: <%foo%> instead of <% foo %>
+      bad_spacing: {
+        pattern: /<%(?!=)[^\s#][^%]*%>/,
+        message: "<% your_code %> for better readability",
+        cop_name: "BadSpacing",
+        severity: "warning"
+      },
+      # Bad output spacing: <%=foo%> instead of <%= foo %>
+      bad_output_spacing: {
+        pattern: /<%=[^\s][^%]*%>/,
+        message: "<%= your_code %> for better readability",
+        cop_name: "BadOutputSpacing",
+        severity: "warning"
+      },
+      # Bad comment spacing: <%#foo%> instead of <%# foo %>
+      bad_comment_spacing: {
+        pattern: /<%#[^\s][^%]*%>/,
+        message: "<%# your_comment %> for better readability",
+        cop_name: "BadCommentSpacing",
+        severity: "warning"
+      }
+    }.freeze
+
+    def lint_file(content)
+      check_final_newline(content)
+      check_erb_conventions(content)
+      check_trailing_whitespace(content)
+
+      @offenses
+    end
+
+    def lint_filtered(content, changed_lines)
+      changed_lines.each do |line_number|
+        line_content = content.lines[line_number - 1]
+        next unless line_content
+
+        check_line_conventions(line_content, line_number)
+      end
+
+      @offenses
+    end
+
+    def check_erb_conventions(content)
+      content.lines.each_with_index do |line_content, index|
+        next if line_content.strip.empty?
+
+        line_number = index + 1
+        check_line_conventions(line_content, line_number)
+      end
+    end
+
+    def check_line_conventions(line_content, line_number)
+      ERB_VIOLATIONS.each do |rule_name, rule|
+        next if line_content.match(rule[:pattern]).nil?
+
+        add_offense(rule_name, rule, line_content, line_number)
+        break
+      end
+    end
+  end
+end

data/lib/ccru/erb_linter_runner.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "erb_linter"
+require_relative "file_handler"
+require_relative "offense_printer"
+
+module Ccru
+  # ERB linter runner methods
+  module ErbLinterRunner
+    include FileHandler
+    include OffensePrinter
+
+    def run_erb_linter_file(path)
+      content = safe_read_file(path)
+      return 0 unless content
+
+      erb_linter = ErbLinter.new
+      offenses = erb_linter.lint_file(content)
+      return 0 if offenses.empty?
+
+      print_offenses(path, offenses)
+      1
+    end
+
+    def run_erb_linter_filtered(path, meta)
+      content = safe_read_file(path)
+      return 0 unless content && meta[:lines].any?
+
+      erb_linter = ErbLinter.new
+      offenses = erb_linter.lint_filtered(content, meta[:lines])
+      return 0 if offenses.empty?
+
+      print_offenses(path, offenses)
+      1
+    end
+  end
+end

data/lib/ccru/file_handler.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Ccru
+  # Handles file operations for RuboCop
+  module FileHandler
+    def safe_read_file(path)
+      File.read(path)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/ccru/file_type_detector.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ccru
+  # Detects file types and determines which linter to use
+  module FileTypeDetector
+    SUPPORTED_EXTENSIONS = {
+      ".rb" => :ruby,
+      ".js" => :javascript,
+      ".erb" => :erb
+    }.freeze
+
+    class << self
+      def supported_file?(path)
+        SUPPORTED_EXTENSIONS.key?(File.extname(path))
+      end
+
+      def file_type(path)
+        extension = File.extname(path)
+        SUPPORTED_EXTENSIONS[extension]
+      end
+
+      def ruby_file?(path)
+        file_type(path) == :ruby
+      end
+    end
+  end
+end