code_qualia 0.1.0

data/lib/code_qualia/pattern_expander.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'pathname'
+
+module CodeQualia
+  class PatternExpander
+    def self.expand_brace_patterns(pattern)
+      new.expand_brace_patterns(pattern)
+    end
+
+    def expand_brace_patterns(pattern)
+      parts = pattern.split('{', 2)
+      return [pattern] unless parts.length == 2
+
+      prefix = parts[0]
+      suffix_and_rest = parts[1].split('}', 2)
+      return [pattern] unless suffix_and_rest.length == 2
+
+      options = suffix_and_rest[0].split(',')
+      suffix = suffix_and_rest[1]
+
+      expanded = []
+      options.each do |option|
+        expanded_pattern = "#{prefix}#{option}#{suffix}"
+        if expanded_pattern.include?('{') && expanded_pattern.include?('}')
+          expanded.concat(expand_brace_patterns(expanded_pattern))
+        else
+          expanded << expanded_pattern
+        end
+      end
+      expanded
+    end
+
+    def self.extract_base_directories(patterns)
+      new.extract_base_directories(patterns)
+    end
+
+    def extract_base_directories(patterns)
+      directories = Set.new
+
+      Array(patterns).each do |pattern|
+        expanded_patterns = if pattern.include?('{') && pattern.include?('}')
+                              expand_brace_patterns(pattern)
+                            else
+                              [pattern]
+                            end
+
+        expanded_patterns.each do |expanded_pattern|
+          base_dirs = extract_base_directory_from_pattern(expanded_pattern)
+
+          # Handle both single directory (string) and multiple directories (array)
+          base_dirs = Array(base_dirs)
+          base_dirs.each do |base_dir|
+            directories.add("#{base_dir}/") if base_dir && !base_dir.empty?
+          end
+        end
+      end
+
+      directories.to_a
+    end
+
+    private
+
+    def extract_base_directory_from_pattern(pattern)
+      if pattern.include?('**')
+        base_path = pattern.split('**').first.chomp('/')
+
+        # Handle special case of '**/*.rb' - detect common Ruby project directories
+        return detect_ruby_project_directories if base_path.empty? && pattern == '**/*.rb'
+
+        base_path
+      elsif pattern.include?('*')
+        # Handle patterns like 'app/models/*.rb' -> 'app'
+        pattern.split('*').first.chomp('/')
+      elsif File.directory?(pattern)
+        # Handle direct directory paths
+        pattern.chomp('/')
+      elsif pattern.end_with?('.rb')
+        # Handle direct file paths
+        dir = File.dirname(pattern)
+        dir == '.' ? nil : dir
+      else
+        # Assume it's a directory pattern
+        pattern.chomp('/')
+      end
+    end
+
+    private
+
+    def detect_ruby_project_directories
+      # Use Pathname.glob to find all Ruby files, then extract their top-level directories
+      ruby_files = Pathname.glob('**/*.rb')
+
+      # Extract unique top-level directories that contain Ruby files
+      ruby_files
+        .map { |file| extract_top_level_directory(file) } # Get top-level directory directly from file
+        .compact # Remove nils
+        .uniq                             # Remove duplicates
+        .map(&:to_s)                      # Convert back to strings
+        .sort                             # Sort for consistency
+    end
+
+    # Extract the top-level directory from a path
+    # Examples:
+    #   app/models/user.rb -> app
+    #   lib/my_gem/version.rb -> lib
+    #   src/main.rb -> src
+    #   script/console.rb -> script
+    #   user.rb -> nil (root level file)
+    def extract_top_level_directory(pathname)
+      parts = pathname.each_filename.to_a
+      return nil if parts.length < 2 # Skip root-level files (need at least dir/file.rb)
+
+      parts.first
+    end
+  end
+end

data/lib/code_qualia/score_calculator.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'config_helper'
+
+module CodeQualia
+  class ScoreCalculator
+    def initialize(config)
+      @config = config
+    end
+
+    def calculate(coverage_data:, complexity_data:, git_data:)
+      results = []
+
+      # Get target patterns from configuration using ConfigHelper
+      target_patterns = ConfigHelper.get_target_patterns
+
+      # Collect files from configured patterns and data sources
+      config_files = []
+      target_patterns.each do |pattern|
+        config_files.concat(Dir.glob(pattern))
+      end
+
+      all_files = (
+        config_files +
+        coverage_data.keys +
+        complexity_data.keys +
+        git_data.keys
+      ).uniq
+
+      all_files.each do |file_path|
+        next if @config.excluded?(file_path)
+
+        file_methods = extract_methods_for_file(file_path, coverage_data, complexity_data, git_data)
+        results.concat(file_methods)
+      end
+
+      results.sort_by { |method| -method[:score] }
+    end
+
+    private
+
+    def extract_methods_for_file(file_path, coverage_data, complexity_data, git_data)
+      methods = []
+
+      # Get complexity data for this file
+      complexity_methods = complexity_data[file_path] || []
+
+      # If no complexity data, try to extract methods from file
+      complexity_methods = extract_methods_from_file(file_path) if complexity_methods.empty?
+
+      complexity_methods.each do |method_data|
+        method_info = {
+          file_path: file_path,
+          method_name: method_data[:method_name],
+          line_number: method_data[:line_number],
+          score: calculate_method_score(file_path, method_data, coverage_data, git_data),
+          details: calculate_method_details(file_path, method_data, coverage_data, git_data)
+        }
+
+        methods << method_info
+      end
+
+      methods
+    end
+
+    def extract_methods_from_file(file_path)
+      return [] unless File.exist?(file_path)
+
+      methods = []
+      File.readlines(file_path).each_with_index do |line, index|
+        next unless line.strip.match?(/^\s*def\s+(\w+)/)
+
+        method_name = line.strip.match(/^\s*def\s+(\w+)/)[1]
+        methods << {
+          method_name: method_name,
+          line_number: index + 1,
+          complexity: 1 # Default complexity
+        }
+      end
+
+      methods
+    end
+
+    def calculate_method_score(file_path, method_data, coverage_data, git_data)
+      quality_score = calculate_quality_score(file_path, method_data, coverage_data)
+      importance_score = calculate_importance_score(file_path, git_data)
+      
+      final_score = quality_score * importance_score
+      final_score.round(2)
+    end
+
+    def calculate_quality_score(file_path, method_data, coverage_data)
+      score = 0.0
+
+      if @config.quality_weights['test_coverage'] > 0
+        coverage_factor = calculate_coverage_factor(file_path, method_data, coverage_data)
+        score += @config.quality_weights['test_coverage'] * coverage_factor
+      end
+
+      if @config.quality_weights['cyclomatic_complexity'] > 0
+        complexity_factor = method_data[:complexity] || 1
+        score += @config.quality_weights['cyclomatic_complexity'] * complexity_factor
+      end
+
+      score
+    end
+
+    def calculate_importance_score(file_path, git_data)
+      score = 0.0
+
+      if @config.importance_weights['change_frequency'] > 0
+        git_factor = git_data[file_path] || 0
+        score += @config.importance_weights['change_frequency'] * git_factor
+      end
+
+      if @config.importance_weights['architectural_importance'] > 0
+        architectural_factor = @config.architectural_weight_for(file_path)
+        score += @config.importance_weights['architectural_importance'] * architectural_factor
+      end
+
+      score
+    end
+
+    def calculate_coverage_factor(file_path, _method_data, coverage_data)
+      file_coverage = coverage_data[file_path]
+      return 1.0 unless file_coverage # No coverage data means 0% coverage
+
+      # For simplicity, use file-level coverage as method-level coverage
+      # In a more sophisticated implementation, we would calculate method-level coverage
+      1.0 - file_coverage[:coverage_rate]
+    end
+
+    def calculate_method_details(file_path, method_data, coverage_data, git_data)
+      file_coverage = coverage_data[file_path]
+
+      {
+        coverage: file_coverage ? file_coverage[:coverage_rate] : 0.0,
+        complexity: method_data[:complexity] || 1,
+        git_commits: git_data[file_path] || 0
+      }
+    end
+  end
+end

data/lib/code_qualia.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+require_relative 'code_qualia/coverage_analyzer'
+require_relative 'code_qualia/complexity_analyzer'
+require_relative 'code_qualia/git_analyzer'
+require_relative 'code_qualia/score_calculator'
+require_relative 'code_qualia/config'
+require_relative 'code_qualia/config_installer'
+require_relative 'code_qualia/cli'
+require_relative 'code_qualia/logger'
+
+module CodeQualia
+  class Error < StandardError; end
+  
+  DEFAULT_CONFIG_FILE = 'qualia.yml'
+
+  class << self
+    def analyze(config_path = './qualia.yml', verbose: false)
+      Logger.verbose = verbose
+      Logger.log_step('Analysis')
+
+      config = Config.load(config_path)
+      Logger.log('Configuration loaded')
+
+      coverage_data = if config.quality_weights['test_coverage'] > 0
+                        Logger.log_step('Coverage analysis')
+                        result = CoverageAnalyzer.analyze
+                        Logger.log_result('Coverage analysis', result.size)
+                        result
+                      else
+                        Logger.log_skip('Coverage analysis', 'weight is 0')
+                        {}
+                      end
+
+      complexity_data = if config.quality_weights['cyclomatic_complexity'] > 0
+                          Logger.log_step('Complexity analysis')
+                          result = ComplexityAnalyzer.analyze
+                          Logger.log_result('Complexity analysis', result.values.sum(&:size))
+                          result
+                        else
+                          Logger.log_skip('Complexity analysis', 'weight is 0')
+                          {}
+                        end
+
+      git_data = if config.importance_weights['change_frequency'] > 0
+                   Logger.log_step('Git history analysis')
+                   result = GitAnalyzer.analyze(config.git_history_days)
+                   Logger.log_result('Git history analysis', result.size)
+                   result
+                 else
+                   Logger.log_skip('Git history analysis', 'weight is 0')
+                   {}
+                 end
+
+      Logger.log_step('Score calculation')
+      results = ScoreCalculator.new(config).calculate(
+        coverage_data: coverage_data,
+        complexity_data: complexity_data,
+        git_data: git_data
+      )
+      Logger.log_result('Score calculation', results.size)
+
+      results
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: code_qualia
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- euglena1215
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Code Qualia helps developers express their subjective understanding and
+  feelings about code quality to AI systems by combining quantitative metrics (coverage,
+  complexity, git activity) with configurable weights that reflect development priorities
+  and intuitions.
+email:
+- teppest1215@gmail.com
+executables:
+- code-qualia
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/code-qualia
+- bin/update_smoke_tests
+- lib/code_qualia.rb
+- lib/code_qualia/cli.rb
+- lib/code_qualia/complexity_analyzer.rb
+- lib/code_qualia/config.rb
+- lib/code_qualia/config_helper.rb
+- lib/code_qualia/config_installer.rb
+- lib/code_qualia/coverage_analyzer.rb
+- lib/code_qualia/git_analyzer.rb
+- lib/code_qualia/logger.rb
+- lib/code_qualia/pattern_expander.rb
+- lib/code_qualia/score_calculator.rb
+homepage: https://github.com/euglena1215/code-qualia
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: A tool for communicating developer intuition and code quality perception
+  to AI through configurable parameters
+test_files: []