ccru 0.1.0

data/lib/ccru/git_diff.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "set"
+require "open3"
+
+require_relative "file_type_detector"
+
+module Ccru
+  # Parse git diff to figure changed files and changed line ranges
+  class GitDiff
+    def initialize(base_ref, only_staged)
+      @base_ref = base_ref
+      @only_staged = only_staged
+    end
+
+    # Returns a Hash: {
+    #   "path/to/file.rb" => { type: :new, lines: nil, file_type: :ruby }
+    #   "path/script.js" => { type: :new, lines: nil, file_type: :javascript }
+    #   "path/mod.rb" => { type: :mod, lines: Set[3,4,10], file_type: :ruby }
+    # }
+    def self.changed_files(base_ref, only_staged)
+      new(base_ref, only_staged).changed_files
+    end
+
+    def changed_files
+      files = parse_changed_files
+
+      add_changed_lines!(files)
+
+      files
+    end
+
+    def parse_changed_files
+      files = {}
+
+      each_status_line do |code, path|
+        next unless FileTypeDetector.supported_file?(path)
+
+        file_info = build_file_info(code, path)
+        files[path] = file_info if file_info
+      end
+
+      files
+    end
+
+    def build_file_info(code, path)
+      case code
+      when "A"
+        { type: :new, lines: nil, file_type: FileTypeDetector.file_type(path) }
+      when "M", "R"
+        { type: :mod, lines: Set.new, file_type: FileTypeDetector.file_type(path) }
+      end
+    end
+
+    def each_status_line
+      # Get all supported file types
+      extensions = FileTypeDetector::SUPPORTED_EXTENSIONS.keys.map { |ext| "*#{ext}" }
+      status_cmd = ["git", "diff", "--name-status", diff_scope, "--", *extensions].flatten
+
+      capture(status_cmd).each_line do |line|
+        next if line.strip.empty?
+
+        code, path = parse_status_line(line)
+        yield code, path if code && path
+      end
+    end
+
+    def add_changed_lines!(files)
+      mod_paths = files.select { |_, v| v[:type] == :mod }.keys
+      return if mod_paths.empty?
+
+      diff_cmd = ["git", "diff", "--unified=0", diff_scope, "--", *mod_paths]
+      parse_diff_hunks(capture(diff_cmd), files)
+    end
+
+    def parse_diff_hunks(diff_out, files)
+      current = nil
+
+      diff_out.each_line do |line|
+        if line.start_with?("+++ b/")
+          current = line.sub("+++ b/", "").strip
+        elsif line =~ /^@@ [^+]*\+(\d+)(?:,(\d+))? @@/
+          add_hunk_lines!(files, current, Regexp.last_match(1), Regexp.last_match(2))
+        end
+      end
+    end
+
+    def add_hunk_lines!(files, current, start_str, count_str)
+      return unless current && files[current]
+
+      start = start_str.to_i
+      count = (count_str || "1").to_i
+      files[current][:lines].merge(start...(start + count))
+    end
+
+    def diff_scope
+      if @only_staged
+        ["--staged"]
+      else
+        [merge_base, "...", "HEAD"].join
+      end
+    end
+
+    def merge_base
+      # Prefer user-specified base or auto-detect main/master
+      base = @base_ref
+      return base if base && !base.empty?
+
+      # Try origin/main then origin/master then main/master
+      candidates = ["origin/main", "origin/master", "main", "master"]
+
+      candidates.each do |ref|
+        ok = system({ "LC_ALL" => "C" }, "git", "rev-parse", "--verify", ref, out: File::NULL, err: File::NULL)
+        return ref if ok
+      end
+
+      # Fallback to HEAD~1 if nothing else
+      "HEAD~1"
+    end
+
+    def parse_status_line(line)
+      # Supports lines like: "A\tpath.rb", "M\tpath.rb", "R100\told.rb\tnew.rb"
+      parts = line.strip.split("\t")
+      code = parts[0]
+
+      if code && code.start_with?("R") && parts.size == 3
+        ["R", parts[2]]
+      else
+        [code, parts[1]]
+      end
+    end
+
+    def capture(cmd)
+      out, err, status = Open3.capture3(*Array(cmd))
+
+      warn("ccru: failed to run #{Array(cmd).join(" ")}\n#{err}") unless status.success?
+
+      out
+    end
+  end
+end

data/lib/ccru/javascript_linter.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require_relative "usual_linter"
+
+require "pry"
+
+module Ccru
+  # JavaScript linter that checks for ES6+ syntax violations and basic code quality
+  class JavaScriptLinter
+    include UsualLinter
+
+    def initialize
+      @offenses = []
+    end
+
+    DEFAULT_PARAMS_PATTERN = Regexp.new(
+      [
+        # function f(a = 1) {}
+        '(?:\b(?:async\s+)?function\b[^(]*\([^)]*=[^)]*\))',
+        # (a = 1) => ...
+        '(?:\b(?:async\s*)?\([^)]*=[^)]*\)\s*=>)',
+        # method m(a = 1) { ... }
+        '(?:(?:^|\{|;)\s*(?:async\s+)?(?:get|set\s+)?' \
+        '(?!if\b|for\b|while\b|switch\b|catch\b)' \
+        '[A-Za-z_$][\w$]*\s*\([^)]*=[^)]*\)\s*\{)'
+      ].join("|"),
+      Regexp::MULTILINE
+    )
+
+    # ES6+ syntax violations
+    ES6_VIOLATIONS = {
+      arrow_functions: {
+        pattern: /=>/,
+        message: "Arrow functions (ES6) are not allowed. Use function() syntax instead.",
+        cop_name: "ArrowFunctions",
+        severity: "error"
+      },
+      const_let: {
+        pattern: /\b(const|let)\b/,
+        message: "const/let (ES6) are not allowed. Use var instead.",
+        cop_name: "ConstLet",
+        severity: "error"
+      },
+      template_literals: {
+        pattern: /`[^`]*\$\{[^}]*\}[^`]*`/,
+        message: "Template literals (ES6) are not allowed. Use string concatenation instead.",
+        cop_name: "TemplateLiterals",
+        severity: "error"
+      },
+      destructuring: {
+        pattern: /\{[^}]*\s*=\s*[^}]*\}/,
+        message: "Destructuring assignment (ES6) is not allowed.",
+        cop_name: "Destructuring",
+        severity: "error"
+      },
+      spread_operator: {
+        pattern: /\.\.\./,
+        message: "Spread operator (ES6) is not allowed.",
+        cop_name: "SpreadOperator",
+        severity: "error"
+      },
+      classes: {
+        pattern: /\bclass\s+\w+/,
+        message: "ES6 classes are not allowed. Use function constructors instead.",
+        cop_name: "Classes",
+        severity: "error"
+      },
+      modules: {
+        pattern: /\b(import|export)\b/,
+        message: "ES6 modules (import/export) are not allowed. Use traditional script loading.",
+        cop_name: "Modules",
+        severity: "error"
+      },
+      default_parameters: {
+        pattern: DEFAULT_PARAMS_PATTERN,
+        message: "Default parameters (ES6) are not allowed.",
+        cop_name: "DefaultParameters",
+        severity: "error"
+      },
+      rest_parameters: {
+        pattern: /\.\.\.\w+/,
+        message: "Rest parameters (ES6) are not allowed.",
+        cop_name: "RestParameters",
+        severity: "error"
+      }
+    }.freeze
+
+    # Basic code quality rules
+    CODE_QUALITY_RULES = {
+      multiple_empty_lines: {
+        pattern: /\n\s*\n/,
+        message: "Multiple consecutive empty lines found. Use maximum 1 empty lines.",
+        cop_name: "MultipleEmptyLines",
+        severity: "warning"
+      },
+      line_too_long: {
+        pattern: /^.{121,}$/,
+        message: "Line is too long (over 120 characters). Consider breaking it into multiple lines.",
+        cop_name: "LineTooLong",
+        severity: "warning"
+      },
+      console_statements: {
+        pattern: /\bconsole\.(log|debug|info|warn|error)\s*\(/,
+        message: "Console statements should not be left in production code. Remove or use proper logging.",
+        cop_name: "ConsoleStatements",
+        severity: "warning"
+      },
+      no_inline_comment: {
+        pattern: %r{[^\s].*//.+},
+        message: "Avoid inline comments at the end of code lines.",
+        cop_name: "InlineComment",
+        severity: "warning"
+      },
+      eval_usage: {
+        pattern: /\beval\s*\(/,
+        message: "eval() is dangerous and should not be used. Use safer alternatives.",
+        cop_name: "EvalUsage",
+        severity: "error"
+      },
+      with_statement: {
+        pattern: /\bwith\s*\(/,
+        message: "with statement is deprecated and can cause scope confusion. Avoid using it.",
+        cop_name: "WithStatement",
+        severity: "error"
+      },
+      document_write: {
+        pattern: /\bdocument\.write\s*\(/,
+        message: "document.write() can cause performance issues and security risks. Use DOM manipulation instead.",
+        cop_name: "DocumentWrite",
+        severity: "warning"
+      },
+      loose_equality: {
+        pattern: /==(?!\s*null|\s*undefined)/,
+        message: "Use strict equality (===) instead of loose equality (==) to avoid type coercion issues.",
+        cop_name: "LooseEquality",
+        severity: "warning"
+      },
+      loose_inequality: {
+        pattern: /!=(?!\s*null|\s*undefined)/,
+        message: "Use strict inequality (!==) instead of loose inequality (!=) to avoid type coercion issues.",
+        cop_name: "LooseInequality",
+        severity: "warning"
+      },
+      unused_variables: {
+        pattern: /\bvar\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/,
+        message: "Variable is declared but may not be used. Consider removing if unused.",
+        cop_name: "UnusedVariables",
+        severity: "warning"
+      },
+      missing_semicolon: {
+        pattern: /[^;{}]\s*$/,
+        message: "Missing semicolon at end of statement. Add semicolon for consistency.",
+        cop_name: "MissingSemicolon",
+        severity: "warning"
+      },
+      innerhtml_usage: {
+        pattern: /\.innerHTML\s*=/,
+        message: "innerHTML can cause XSS vulnerabilities. Use textContent or proper sanitization.",
+        cop_name: "InnerhtmlUsage",
+        severity: "warning"
+      },
+      global_variables: {
+        pattern: /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=/,
+        message: "Global variable declaration detected. Consider using var to avoid global scope pollution.",
+        cop_name: "GlobalVariables",
+        severity: "warning"
+      }
+    }.freeze
+
+    def lint_file(content)
+      check_final_newline(content)
+      check_js_conventions(content)
+      check_trailing_whitespace(content)
+
+      @offenses
+    end
+
+    def check_js_conventions(content)
+      @current_code = content.lines
+
+      @current_code.each_with_index do |line_content, index|
+        next if line_content.strip.empty?
+
+        line_number = index + 1
+
+        next if commment?(line_content, line_number)
+
+        check_line_conventions(line_content, line_number)
+      end
+    end
+
+    # rubocop:disable Metrics
+    def check_line_conventions(line_content, line_number)
+      ES6_VIOLATIONS.merge(CODE_QUALITY_RULES).each do |rule_name, rule|
+        next if line_content.match(rule[:pattern]).nil?
+        next if rule_name == :missing_semicolon && no_need_semicolon?(line_content)
+        next if rule_name == :unused_variables && used_variable?(line_content, line_number)
+        next if rule_name == :loose_equality && line_content.include?("!==")
+
+        add_offense(rule_name, rule, line_content, line_number)
+        break
+      end
+    end
+    # rubocop:enable Metrics
+
+    def used_variable?(line_content, line_number)
+      # Extract variable name from var declaration
+      match = line_content.match(/\bvar\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/)
+      return false unless match
+
+      variable_name = match[1]
+
+      count_occurrences(variable_name, line_number) > 0
+    end
+
+    def count_occurrences(variable_name, line_number)
+      # Count occurrences of the variable name
+      # Exclude the declaration line itself
+      total_occurrences = 0
+
+      @current_code.each_with_index do |code_line, index|
+        # Skip the declaration line
+        next if index <= line_number - 1
+        next if code_line.match(/(?<![A-Za-z0-9_])#{Regexp.escape(variable_name)}(?![A-Za-z0-9_])/).nil?
+
+        total_occurrences += 1
+        break
+      end
+
+      total_occurrences
+    end
+
+    # rubocop:disable Metrics
+    def no_need_semicolon?(line_content)
+      line = line_content.strip
+      return true if line.empty?
+
+      # Already have ; no need to check
+      return true if line.end_with?(";") || line.end_with?(",")
+
+      # End with { or } (block, function, class, etc.)
+      return true if line.end_with?("{") || line == "}"
+
+      # Open or close array/object literal, grouping
+      return true if line.match(/[\[\(]\s*$/) || line.match(/^[\])]\s*$/)
+
+      # Control statements don't need ;
+      return true if line.match(/^(if|else|for|while|switch|try|catch|finally)\b/)
+
+      # function / class declaration
+      return true if line.match(/^function\b/) || line.match(/^class\b/)
+
+      # Control flow keywords (return, break, continue, throw)
+      # Actually, it may be necessary to have ; if the expression behind starts with ( or [
+      # but JS ASI will handle it, I consider it unnecessary
+      return true if line.match(/^(return|break|continue|throw)\b/)
+
+      false
+    end
+    # rubocop:enable Metrics
+
+    def commment?(line_content, line_number)
+      line = line_content.strip
+      return true if line.start_with?("//") || line.start_with?("/*") || line.end_with?("*/")
+
+      in_block_comment?(line_number)
+    end
+
+    def in_block_comment?(line_number)
+      in_block = false
+
+      @current_code.each_with_index do |code_line, idx|
+        in_block = true if code_line.strip.start_with?("/*")
+        return true if in_block && idx == line_number - 1
+
+        in_block = false if code_line.strip.end_with?("*/")
+      end
+
+      false
+    end
+  end
+end

data/lib/ccru/javascript_linter_runner.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "file_handler"
+require_relative "javascript_linter"
+
+module Ccru
+  # JavaScript-specific linter methods
+  module JavaScriptLinterRunner
+    include FileHandler
+
+    def run_javascript_linter_file(path)
+      content = safe_read_file(path)
+      return 0 unless content
+
+      js_linter = JavaScriptLinter.new
+      offenses = js_linter.lint_file(content)
+      return 0 if offenses.empty?
+
+      print_offenses(path, offenses)
+      1
+    end
+
+    def run_javascript_linter_filtered(path, meta)
+      content = safe_read_file(path)
+      return 0 unless content && meta[:lines].any?
+
+      linter = JavaScriptLinter.new
+      result = linter.lint_code(content, path, meta[:lines])
+      result[:status]
+    end
+  end
+end

data/lib/ccru/linter_runner.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "rubocop_runner"
+require_relative "erb_linter_runner"
+require_relative "javascript_linter_runner"
+
+module Ccru
+  # Handles execution of different linters (RuboCop for Ruby, custom for JavaScript, ERB parsing)
+  module LinterRunner
+    include RuboCopRunner
+    include ErbLinterRunner
+    include JavaScriptLinterRunner
+
+    def run_linter_file(path, meta)
+      case meta[:file_type]
+      when :ruby
+        run_rubocop_file(path)
+      when :javascript
+        run_javascript_linter_file(path)
+      when :erb
+        run_erb_linter_file(path)
+      else
+        0
+      end
+    end
+
+    def run_linter_filtered(path, meta)
+      case meta[:file_type]
+      when :ruby
+        run_rubocop_filtered(path, meta)
+      when :javascript
+        run_javascript_linter_filtered(path, meta)
+      when :erb
+        run_erb_linter_filtered(path, meta)
+      else
+        0
+      end
+    end
+  end
+end

data/lib/ccru/offense_printer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ccru
+  # Handles printing of RuboCop offenses
+  module OffensePrinter
+    def print_offenses(path, offenses)
+      offenses.each { |offense| print_single_offense(path, offense) }
+    end
+
+    def print_single_offense(path, offense)
+      location = offense["location"]
+      print_offense_summary(path, offense, location)
+      print_offense_code(path, location)
+    end
+
+    def print_offense_summary(path, offense, location)
+      line = location["line"]
+      column = location["column"]
+      severity_flag = offense["severity"][0].upcase
+      cop_name = offense["cop_name"]
+      message = offense["message"]
+      puts "#{path}:#{line}:#{column}: #{severity_flag}: #{cop_name}: #{message}"
+    end
+
+    def print_offense_code(path, location)
+      return unless File.exist?(path)
+
+      code_lines = File.readlines(path)
+      line_content = code_lines[location["line"] - 1]
+      return unless line_content
+
+      puts line_content.rstrip
+      puts_target_flags(line_content, location)
+    rescue StandardError
+      # Skip if cannot read file
+    end
+
+    def puts_target_flags(line_content, location)
+      return puts if location["column"] == 1
+
+      target = "#{" " * (location["column"] - 1)}#{"^" * location["length"]}"
+      puts target[0...line_content.length]
+    end
+  end
+end

data/lib/ccru/rubocop_runner.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+require_relative "file_handler"
+require_relative "offense_printer"
+
+module Ccru
+  # RuboCop-specific linter methods
+  module RuboCopRunner
+    include FileHandler
+    include OffensePrinter
+
+    def run_rubocop_file(path)
+      content = safe_read_file(path)
+      return 0 unless content
+
+      result = run_rubocop_and_parse(path, content)
+      return result unless result.is_a?(Array)
+
+      print_offenses(path, result)
+      1
+    end
+
+    def run_rubocop_filtered(path, meta)
+      content = safe_read_file(path)
+      return 0 unless content && meta[:lines].any?
+
+      result = run_rubocop_and_parse(path, content)
+      return result unless result.is_a?(Array)
+
+      offenses = filter_offenses_by_lines(result, meta[:lines])
+      return 0 if offenses.empty?
+
+      print_offenses(path, offenses)
+      1
+    end
+
+    def run_rubocop_and_parse(path, content)
+      out, = run_rubocop_json(path, content)
+      data = safe_parse_json(path, out)
+      return 1 unless data
+
+      files = data["files"] || []
+      (files.first && files.first["offenses"]) || []
+    end
+
+    def run_rubocop_json(path, content)
+      cmd = ["rubocop", "--format", "json", "--force-exclusion", "--stdin", path]
+      Open3.capture3(*cmd, stdin_data: content)
+    end
+
+    def safe_parse_json(path, out)
+      JSON.parse(out)
+    rescue StandardError
+      warn("ccru: failed to parse rubocop json for #{path}")
+      nil
+    end
+
+    def filter_offenses_by_lines(offenses, changed_lines)
+      offenses.select { |offense| changed_lines.include?(offense["location"]["line"]) }
+    end
+  end
+end

data/lib/ccru/usual_linter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Ccru
+  # Handles execution of different linters (RuboCop for Ruby, custom for JavaScript, ERB parsing)
+  module UsualLinter
+    USUAL_VIOLATIONS = {
+      # Trailing whitespace
+      trailing_whitespace: {
+        pattern: /\s+$/,
+        message: "Remove trailing whitespace",
+        cop_name: "TrailingWhitespace",
+        severity: "warning"
+      },
+      # Missing final newline
+      missing_final_newline: {
+        pattern: /[^\n]$/,
+        message: "Add final newline at end of file",
+        cop_name: "MissingFinalNewline",
+        severity: "warning"
+      }
+    }.freeze
+
+    def check_trailing_whitespace(content)
+      content.lines.each_with_index do |line_content, index|
+        line_number = index + 1
+        check_line_trailing_whitespace(line_content, line_number)
+      end
+    end
+
+    def check_final_newline(content)
+      return if content.empty? || content.end_with?("\n")
+
+      rule_name = :missing_final_newline
+      rule = USUAL_VIOLATIONS[rule_name]
+      add_offense(rule_name, rule, "End of file", content.lines.count)
+    end
+
+    def check_line_trailing_whitespace(line_content, line_number)
+      rule_name = :trailing_whitespace
+      rule = USUAL_VIOLATIONS[rule_name]
+      return if line_content.match(rule[:pattern]).nil? || line_content.gsub("\n", "")[-1] != " "
+
+      add_offense(rule_name, rule, line_content, line_number)
+    end
+
+    def add_offense(rule_name, violation, line_content, line_number)
+      @offenses << {
+        "rule" => rule_name,
+        "line_content" => line_content,
+        "message" => violation[:message],
+        "severity" => violation[:severity],
+        "cop_name" => violation[:cop_name],
+        "location" => { "line" => line_number, "column" => 1 }
+      }
+    end
+  end
+end

data/lib/ccru/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ccru
+  VERSION = "0.1.0"
+end

data/lib/ccru.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "ccru/cli"
+require_relative "ccru/version"
+
+module Ccru
+  class Error < StandardError; end
+end

data/sig/ccru.rbs

@@ -0,0 +1,4 @@
+module Ccru
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end