solid_score 0.2.0

data/lib/solid_score/formatters/html_formatter.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Formatters
+    class HtmlFormatter < BaseFormatter
+      def format(results)
+        return empty_html if results.empty?
+
+        build_html(results)
+      end
+
+      private
+
+      def empty_html
+        build_page("No classes found to analyze.", "")
+      end
+
+      def build_html(results)
+        summary = build_summary(results)
+        chart = build_chart(results)
+        table = build_table(results)
+
+        build_page(summary + chart, table)
+      end
+
+      def build_page(header_content, body_content)
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1">
+            <title>solid-score Report</title>
+            <style>#{css}</style>
+          </head>
+          <body>
+            <div class="container">
+              <h1>solid-score Report <span class="version">v#{VERSION}</span></h1>
+              #{header_content}
+              #{body_content}
+              <footer>Generated by solid-score v#{VERSION}</footer>
+            </div>
+          </body>
+          </html>
+        HTML
+      end
+
+      def build_summary(results)
+        avg_total = (results.sum(&:total) / results.size).round(1)
+        avgs = %i[srp ocp lsp isp dip].map do |p|
+          [p, (results.sum(&p) / results.size).round(1)]
+        end.to_h
+
+        <<~HTML
+          <div class="summary">
+            <div class="summary-card summary-total">
+              <div class="summary-label">Average Score</div>
+              <div class="summary-value #{score_color_class(avg_total)}">#{avg_total}</div>
+            </div>
+            <div class="summary-card">
+              <div class="summary-label">Classes Analyzed</div>
+              <div class="summary-value">#{results.size}</div>
+            </div>
+            #{avgs.map { |p, v| principle_card(p, v) }.join}
+          </div>
+        HTML
+      end
+
+      def principle_card(principle, value)
+        <<~HTML
+          <div class="summary-card">
+            <div class="summary-label">#{principle.to_s.upcase}</div>
+            <div class="summary-value #{score_color_class(value)}">#{value}</div>
+          </div>
+        HTML
+      end
+
+      def build_chart(results)
+        avgs = %i[srp ocp lsp isp dip].map do |p|
+          [p.to_s.upcase, (results.sum(&p) / results.size).round(1)]
+        end
+
+        bar_height = 32
+        gap = 8
+        chart_height = avgs.size * (bar_height + gap) + 20
+        label_width = 40
+        chart_width = 500
+
+        bars = avgs.each_with_index.map do |(label, value), i|
+          y = i * (bar_height + gap) + 10
+          bar_w = [(value / 100.0 * (chart_width - label_width - 60)).round(1), 0].max
+          color = score_hex_color(value)
+
+          <<~SVG
+            <text x="#{label_width - 5}" y="#{y + bar_height / 2 + 5}" text-anchor="end" class="chart-label">#{label}</text>
+            <rect x="#{label_width}" y="#{y}" width="#{bar_w}" height="#{bar_height}" rx="4" fill="#{color}" />
+            <text x="#{label_width + bar_w + 5}" y="#{y + bar_height / 2 + 5}" class="chart-value">#{value}</text>
+          SVG
+        end.join
+
+        <<~HTML
+          <div class="chart-container">
+            <h2>Score Overview</h2>
+            <svg width="#{chart_width}" height="#{chart_height}" class="chart">
+              #{bars}
+            </svg>
+          </div>
+        HTML
+      end
+
+      def build_table(results)
+        rows = results.sort_by(&:total).map { |r| table_row(r) }.join
+
+        <<~HTML
+          <h2>Details (#{results.size} classes)</h2>
+          <div class="table-wrapper">
+            <table>
+              <thead>
+                <tr>
+                  <th>Class</th>
+                  <th>File</th>
+                  <th>SRP</th>
+                  <th>OCP</th>
+                  <th>LSP</th>
+                  <th>ISP</th>
+                  <th>DIP</th>
+                  <th>Total</th>
+                </tr>
+              </thead>
+              <tbody>
+                #{rows}
+              </tbody>
+            </table>
+          </div>
+        HTML
+      end
+
+      def table_row(result)
+        <<~HTML
+          <tr>
+            <td class="class-name">#{escape_html(result.class_name)}</td>
+            <td class="file-path">#{escape_html(result.file_path)}</td>
+            #{score_cell(result.srp)}
+            #{score_cell(result.ocp)}
+            #{score_cell(result.lsp)}
+            #{score_cell(result.isp)}
+            #{score_cell(result.dip)}
+            #{score_cell(result.total.round(1))}
+          </tr>
+        HTML
+      end
+
+      def score_cell(value)
+        %(<td class="score #{score_color_class(value)}">#{value}</td>)
+      end
+
+      def score_color_class(score)
+        if score >= 80
+          "score-green"
+        elsif score >= 50
+          "score-yellow"
+        else
+          "score-red"
+        end
+      end
+
+      def score_hex_color(score)
+        if score >= 80
+          "#22c55e"
+        elsif score >= 50
+          "#eab308"
+        else
+          "#ef4444"
+        end
+      end
+
+      def escape_html(text)
+        text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+      end
+
+      def css
+        <<~CSS
+          * { margin: 0; padding: 0; box-sizing: border-box; }
+          body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #f8fafc; color: #1e293b; line-height: 1.6; }
+          .container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
+          h1 { font-size: 1.5rem; margin-bottom: 1.5rem; }
+          h1 .version { font-weight: normal; color: #64748b; font-size: 0.875rem; }
+          h2 { font-size: 1.125rem; margin: 1.5rem 0 0.75rem; }
+
+          .summary { display: flex; flex-wrap: wrap; gap: 0.75rem; margin-bottom: 1.5rem; }
+          .summary-card { background: #fff; border: 1px solid #e2e8f0; border-radius: 8px; padding: 0.75rem 1rem; min-width: 100px; text-align: center; }
+          .summary-total { border-width: 2px; }
+          .summary-label { font-size: 0.75rem; color: #64748b; text-transform: uppercase; letter-spacing: 0.05em; }
+          .summary-value { font-size: 1.5rem; font-weight: 700; }
+
+          .chart-container { background: #fff; border: 1px solid #e2e8f0; border-radius: 8px; padding: 1rem; margin-bottom: 1.5rem; }
+          .chart-label { font-size: 13px; fill: #475569; font-family: inherit; }
+          .chart-value { font-size: 13px; fill: #475569; font-family: inherit; }
+
+          .table-wrapper { overflow-x: auto; }
+          table { width: 100%; border-collapse: collapse; background: #fff; border: 1px solid #e2e8f0; border-radius: 8px; font-size: 0.875rem; }
+          thead { background: #f1f5f9; }
+          th { padding: 0.625rem 0.75rem; text-align: left; font-weight: 600; border-bottom: 2px solid #e2e8f0; }
+          td { padding: 0.5rem 0.75rem; border-bottom: 1px solid #f1f5f9; }
+          tr:hover { background: #f8fafc; }
+          .class-name { font-weight: 500; white-space: nowrap; }
+          .file-path { color: #64748b; font-size: 0.8rem; max-width: 300px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+          .score { text-align: right; font-variant-numeric: tabular-nums; font-weight: 500; }
+
+          .score-green { color: #16a34a; }
+          .score-yellow { color: #ca8a04; }
+          .score-red { color: #dc2626; }
+
+          footer { margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #e2e8f0; color: #94a3b8; font-size: 0.75rem; text-align: center; }
+        CSS
+      end
+    end
+  end
+end

data/lib/solid_score/formatters/json_formatter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SolidScore
+  module Formatters
+    class JsonFormatter < BaseFormatter
+      def format(results)
+        data = {
+          version: VERSION,
+          classes: results.map { |r| format_result(r) },
+          summary: build_summary(results)
+        }
+
+        JSON.pretty_generate(data)
+      end
+
+      private
+
+      def format_result(result)
+        {
+          class_name: result.class_name,
+          file_path: result.file_path,
+          srp: result.srp,
+          ocp: result.ocp,
+          lsp: result.lsp,
+          isp: result.isp,
+          dip: result.dip,
+          total: result.total.round(1),
+          confidence: result.confidence.transform_values(&:to_s),
+          subscores: result.subscores
+        }
+      end
+
+      def build_summary(results)
+        return { total_classes: 0, average_score: 0.0 } if results.empty?
+
+        {
+          total_classes: results.size,
+          average_score: (results.sum(&:total) / results.size).round(1)
+        }
+      end
+    end
+  end
+end

data/lib/solid_score/formatters/text_formatter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Formatters
+    class TextFormatter < BaseFormatter
+      def format(results)
+        return "No classes found to analyze.\n" if results.empty?
+
+        lines = []
+        lines << "solid-score v#{VERSION}\n"
+        lines << "Analyzed #{results.size} class(es)\n\n"
+        lines << header_line
+        lines << separator_line
+
+        results.each { |r| lines << result_line(r) }
+
+        lines << separator_line
+        lines << average_line(results)
+        lines << ""
+
+        lines.join("\n")
+      end
+
+      private
+
+      def header_line
+        "Class                                      SRP   OCP   LSP   ISP   DIP   Total"
+      end
+
+      def separator_line
+        "-" * 75
+      end
+
+      def result_line(result)
+        Kernel.format("%-40s %5.1f %5.1f %5.1f %5.1f %5.1f %7.1f",
+                      truncate(result.class_name, 40),
+                      result.srp, result.ocp, result.lsp, result.isp, result.dip, result.total)
+      end
+
+      def average_line(results)
+        avg = ->(method) { results.sum(&method) / results.size.to_f }
+
+        Kernel.format("%-40s %5.1f %5.1f %5.1f %5.1f %5.1f %7.1f",
+                      "Average",
+                      avg.call(:srp), avg.call(:ocp), avg.call(:lsp),
+                      avg.call(:isp), avg.call(:dip), avg.call(:total))
+      end
+
+      def truncate(str, max)
+        str.length > max ? "#{str[0..(max - 4)]}..." : str
+      end
+    end
+  end
+end

data/lib/solid_score/models/class_info.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Models
+    class ClassInfo
+      attr_reader :name, :file_path, :line_start, :line_end,
+                  :methods, :superclass, :includes, :extends,
+                  :instance_variables, :attr_readers, :attr_writers,
+                  :kind, :dsl_calls
+
+      def initialize(name:, file_path: "", line_start: 0, line_end: 0,
+                     methods: [], superclass: nil, includes: [], extends: [],
+                     instance_variables: [], attr_readers: [], attr_writers: [],
+                     kind: :class, dsl_calls: [])
+        @name = name
+        @file_path = file_path
+        @line_start = line_start
+        @line_end = line_end
+        @methods = methods
+        @superclass = superclass
+        @includes = includes
+        @extends = extends
+        @instance_variables = instance_variables
+        @attr_readers = attr_readers
+        @attr_writers = attr_writers
+        @kind = kind
+        @dsl_calls = dsl_calls
+      end
+
+      def module?
+        kind == :module
+      end
+
+      def public_methods_list
+        methods.select { |m| m.public? && m.name != :initialize }
+      end
+
+      def has_superclass?
+        !superclass.nil? && !superclass.empty?
+      end
+
+      def data_class?
+        all_attrs = attr_readers + attr_writers
+        return false if all_attrs.empty?
+
+        non_init_methods = methods.reject { |m| m.name == :initialize }
+        non_init_methods.all? { |m| all_attrs.include?(m.name) }
+      end
+
+      # Phase 2c: レイヤー判別
+      # file_pathからRailsのレイヤーを自動判別する
+      def layer
+        @layer ||= determine_layer
+      end
+
+      # Phase 2c: フレームワーク基盤クラスかどうか
+      # ApplicationController, ApplicationRecord 等
+      def framework_base_class?
+        return false unless has_superclass?
+
+        FRAMEWORK_DIRECT_BASES.include?(superclass)
+      end
+
+      # Issue #9: Inspection / diagnostic class detection.
+      # Console-only or read-only diagnostic helpers grow naturally and should
+      # not be penalised for their public surface.
+      #
+      # Suffixes are anchored with `\z` to avoid matching mid-word names
+      # (e.g. `DiagnosticReport` should not be treated as a diagnostic
+      # helper). `Tools` and `Debug` are intentionally narrow because they
+      # appear in many domain models.
+      INSPECTION_NAME_PATTERNS = [
+        /Inspect\z/, /Console\z/, /Debug\z/,
+        /Diagnostic\z/, /Diagnostics\z/, /Tools\z/
+      ].freeze
+      INSPECTION_PATH_PATTERN = %r{/(inspectors?|diagnostics?|debug)/}
+
+      def inspection_class?
+        return true if INSPECTION_NAME_PATTERNS.any? { |p| name.match?(p) }
+        return true if file_path.match?(INSPECTION_PATH_PATTERN)
+
+        false
+      end
+
+      # Phase 2c: HTTPクライアントパターンかどうか
+      # 全publicメソッドが共通のクライアント系インスタンス変数を参照する構造
+      def http_client_pattern?
+        client_ivars = instance_variables.select do |iv|
+          iv.to_s.match?(/client|http|connection|api/)
+        end
+        return false if client_ivars.empty?
+
+        pub = public_methods_list
+        return false if pub.size < 2
+
+        pub.all? do |method|
+          client_ivars.any? { |iv| method.instance_variables.include?(iv) }
+        end
+      end
+
+      private
+
+      FRAMEWORK_DIRECT_BASES = %w[
+        ActiveRecord::Base ActionController::Base ActionController::API
+        ActiveJob::Base ActionMailer::Base
+        ActionCable::Channel::Base ActionCable::Connection::Base
+      ].freeze
+
+      LAYER_PATH_PATTERNS = {
+        controller: "/controllers/",
+        model: "/models/",
+        service: "/services/",
+        job: "/jobs/",
+        mailer: "/mailers/",
+        form: "/forms/",
+        presenter: "/presenters/",
+        serializer: "/serializers/",
+        validator: "/validators/",
+        lib: "/lib/"
+      }.freeze
+
+      SUPERCLASS_LAYERS = {
+        "ApplicationRecord" => :model,
+        "ActiveRecord::Base" => :model,
+        "ApplicationController" => :controller,
+        "ActionController::Base" => :controller,
+        "ActionController::API" => :controller,
+        "ApplicationJob" => :job,
+        "ActiveJob::Base" => :job,
+        "ApplicationMailer" => :mailer,
+        "ActionMailer::Base" => :mailer
+      }.freeze
+
+      def determine_layer
+        # file_pathから判別（最も確実）
+        LAYER_PATH_PATTERNS.each do |layer, pattern|
+          return layer if file_path.include?(pattern)
+        end
+
+        # superclassから判別（file_pathで判別できない場合のフォールバック）
+        if has_superclass?
+          layer = SUPERCLASS_LAYERS[superclass]
+          return layer if layer
+        end
+
+        :unknown
+      end
+    end
+  end
+end

data/lib/solid_score/models/method_info.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Models
+    # Represents information about a single method call.
+    # Phase 1 改善: レシーバ情報を収集するために追加
+    class MethodCallInfo
+      attr_reader :method_name, :receiver, :receiver_type
+
+      # @param method_name [Symbol] メソッド名
+      # @param receiver [String, nil] レシーバの名前（定数名、変数名など）
+      # @param receiver_type [Symbol] レシーバの種類 (:const, :ivar, :lvar, :self, :unknown)
+      def initialize(method_name:, receiver: nil, receiver_type: :unknown)
+        @method_name = method_name
+        @receiver = receiver
+        @receiver_type = receiver_type
+      end
+
+      # Check if this is a .new call on a constant (class instantiation)
+      def new_call_on_const?
+        method_name == :new && receiver_type == :const
+      end
+    end
+
+    class MethodInfo
+      attr_reader :name, :visibility, :line_start, :line_end,
+                  :instance_variables, :called_methods, :parameters,
+                  :cyclomatic_complexity, :raises, :calls_super,
+                  :method_calls, :case_when_count, :kind,
+                  :effective_statement_count, :memoized_factory_receiver
+
+      def initialize(name:, visibility: :public, line_start: 0, line_end: 0,
+                     instance_variables: [], called_methods: [], parameters: [],
+                     cyclomatic_complexity: 1, raises: [], calls_super: false,
+                     method_calls: [], case_when_count: 0, kind: :instance,
+                     effective_statement_count: 0,
+                     memoized_factory_receiver: nil, memoized_factory: nil)
+        @name = name
+        @visibility = visibility
+        @line_start = line_start
+        @line_end = line_end
+        @instance_variables = instance_variables
+        @called_methods = called_methods
+        @parameters = parameters
+        @cyclomatic_complexity = cyclomatic_complexity
+        @raises = raises
+        @calls_super = calls_super
+        @method_calls = method_calls
+        @case_when_count = case_when_count
+        @kind = kind
+        @effective_statement_count = effective_statement_count
+        # Issue #12: store the receiver constant of a memoised factory call
+        # (e.g. "ProvisioningService" for `@svc ||= ProvisioningService.new`).
+        # Older callers used `memoized_factory: true/false` as a boolean flag;
+        # accept that for backwards-compat in tests by mapping `true` to a
+        # placeholder string. New code should provide the receiver name.
+        @memoized_factory_receiver = memoized_factory_receiver
+        @memoized_factory_receiver ||= "<unknown>" if memoized_factory == true
+      end
+
+      def public?
+        visibility == :public
+      end
+
+      def memoized_factory?
+        !@memoized_factory_receiver.nil?
+      end
+
+      def class_method?
+        kind == :class
+      end
+
+      def instance_method?
+        kind == :instance
+      end
+
+      def empty?
+        line_start == line_end
+      end
+    end
+  end
+end

data/lib/solid_score/models/score_result.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Models
+    class ScoreResult
+      DEFAULT_WEIGHTS = {
+        srp: 0.30,
+        ocp: 0.15,
+        lsp: 0.10,
+        isp: 0.20,
+        dip: 0.25
+      }.freeze
+
+      # 基本信頼度（解析手法の本質的な精度）
+      BASE_CONFIDENCE = {
+        srp: :high,
+        ocp: :medium,
+        lsp: :medium,
+        isp: :medium_high,
+        dip: :high
+      }.freeze
+
+      CONFIDENCE_ORDER = %i[low low_medium medium medium_high high].freeze
+
+      attr_reader :class_name, :file_path, :srp, :ocp, :lsp, :isp, :dip,
+                  :weights, :class_info, :subscores
+
+      def initialize(class_name:, file_path: "", srp: 0.0, ocp: 0.0, lsp: 0.0, isp: 0.0, dip: 0.0,
+                     weights: DEFAULT_WEIGHTS, class_info: nil, subscores: {})
+        @class_name = class_name
+        @file_path = file_path
+        @srp = srp
+        @ocp = ocp
+        @lsp = lsp
+        @isp = isp
+        @dip = dip
+        @weights = weights
+        @class_info = class_info
+        @subscores = subscores
+      end
+
+      def total
+        (srp * weights[:srp]) +
+          (ocp * weights[:ocp]) +
+          (lsp * weights[:lsp]) +
+          (isp * weights[:isp]) +
+          (dip * weights[:dip])
+      end
+
+      # Phase 2b: class_infoに基づく動的な信頼度計算
+      def confidence
+        return BASE_CONFIDENCE unless class_info
+
+        {
+          srp: adjusted_confidence(:srp),
+          ocp: adjusted_confidence(:ocp),
+          lsp: adjusted_confidence(:lsp),
+          isp: adjusted_confidence(:isp),
+          dip: adjusted_confidence(:dip)
+        }
+      end
+
+      private
+
+      def adjusted_confidence(principle)
+        base = BASE_CONFIDENCE[principle]
+
+        # メソッド数が少ない場合、全原則の信頼度が低下
+        base = lower_confidence(base) if few_methods?
+
+        case principle
+        when :lsp
+          # モジュールの場合はLSPは常にhigh（継承なしで100点固定）
+          return :high if class_info.module?
+          # 継承なしもhigh
+          return :high unless class_info.has_superclass?
+        when :srp
+          # メソッド数が非常に少ない場合、LCOM4の意味が薄い
+          base = lower_confidence(base) if class_info.methods.size <= 2
+        end
+
+        base
+      end
+
+      def few_methods?
+        class_info.methods.size <= 1
+      end
+
+      def lower_confidence(level)
+        idx = CONFIDENCE_ORDER.index(level) || 0
+        CONFIDENCE_ORDER[[idx - 1, 0].max]
+      end
+    end
+  end
+end