solidarity 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 27543cb4c591b8b62bbf07cbf83ad9165bb0e9a1650a0e29bb265f986fdba5cd
+  data.tar.gz: c1a8836ed00bb416303ed6a43a1ce26006483052e4d936c12359c5dd216842c3
+SHA512:
+  metadata.gz: c9304bfa105687a0ae8354e824a06978c5f542d7301de9d065d58dcacf1d1d9998e2370c70f8b54450eacf2d3ad79f4255f4d115b1def72a61d8f3fb2471636f
+  data.tar.gz: 308e3516157366177bdc0b449a5e9d2232563c29acf45709b58dedad5a496056e36974481fe7c6018aeee09abd9a28473f7942fe24ee4e87f577123992571898

data/exe/solidarity

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require "solidarity"
+
+# TODO: Add option parsing (e.g., using OptionParser)
+
+project_path = ARGV[0]
+
+unless project_path
+  warn "Usage: #{File.basename($PROGRAM_NAME)} <path_to_ruby_project>"
+  exit 1
+end
+
+begin
+  graph = Solidarity::RailRoadyRunner.run(project_path)
+  solid_results = Solidarity::SolidEvaluator.new(graph).evaluate_all
+  report = Solidarity::Reporter.generate_report(solid_results)
+  puts report
+rescue => e
+  warn "Error: #{e.message}"
+  exit 1
+end

data/lib/solidarity/ast_processor.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module Solidarity
+  class AstProcessor
+    attr_reader :classes, :modules, :inheritances, :includes
+
+    def initialize
+      @classes = []
+      @modules = []
+      @inheritances = [] # Format: [['ChildClass', 'ParentClass']]
+      @includes = []     # Format: [['ClassOrModule', 'IncludedModule']]
+    end
+
+    def process_file(file_path)
+      content = File.read(file_path)
+      ast = Parser::CurrentRuby.parse(content)
+      traverse_ast(ast, nil) # Pass initial context as nil
+    end
+
+    private
+
+    def traverse_ast(node, current_context)
+      return unless node.is_a?(Parser::AST::Node)
+
+      new_context = current_context
+
+      case node.type
+      when :class
+        class_name = extract_const_name(node.children[0])
+        superclass_name = extract_const_name(node.children[1])
+        @classes << class_name
+        @inheritances << [class_name, superclass_name] if superclass_name
+        new_context = class_name
+      when :module
+        module_name = extract_const_name(node.children[0])
+        @modules << module_name
+        new_context = module_name
+      when :send
+        if node.children[1] == :include
+          included_module = extract_const_name(node.children[2])
+          @includes << [current_context, included_module] if current_context && included_module
+        end
+      end
+
+      node.children.each { |child| traverse_ast(child, new_context) }
+    end
+
+    def extract_const_name(node)
+      return unless node.is_a?(Parser::AST::Node)
+
+      case node.type
+      when :const
+        parent = extract_const_name(node.children[0])
+        [parent, node.children[1]].compact.join('::')
+      when :cbase
+        '' # Absolute constant, e.g., ::MyClass
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/solidarity/graph.rb

@@ -0,0 +1,68 @@
+module Solidarity
+  class Graph
+    attr_reader :nodes, :edges
+
+    def initialize(ast_data)
+      @nodes = []
+      @edges = []
+
+      initialize_from_ast_data(ast_data)
+    end
+
+    def self.from_ast_data(ast_data)
+      new(ast_data)
+    end
+
+    def find_node(name)
+      @nodes.find { |node| node.name == name }
+    end
+
+    def outgoing_edges(node_name)
+      @edges.select { |edge| edge.source == node_name }
+    end
+
+    def incoming_edges(node_name)
+      @edges.select { |edge| edge.target == node_name }
+    end
+
+    private
+
+    def initialize_from_ast_data(ast_data)
+      ast_data[:classes].each do |class_name|
+        @nodes << Node.new(name: class_name, label: class_name, type: 'class')
+      end
+      ast_data[:modules].each do |module_name|
+        @nodes << Node.new(name: module_name, label: module_name, type: 'module')
+      end
+
+      ast_data[:inheritances].each do |child, parent|
+        @edges << Edge.new(source: parent, target: child, label: '', type: 'is-a')
+      end
+
+      ast_data[:includes].each do |includer, included|
+        @edges << Edge.new(source: includer, target: included, label: '', type: 'includes')
+      end
+    end
+
+    class Node
+      attr_reader :name, :label, :type
+
+      def initialize(data)
+        @name = data[:name]
+        @label = data[:label]
+        @type = data[:type]
+      end
+    end
+
+    class Edge
+      attr_reader :source, :target, :label, :type
+
+      def initialize(data)
+        @source = data[:source]
+        @target = data[:target]
+        @label = data[:label]
+        @type = data[:type]
+      end
+    end
+  end
+end

data/lib/solidarity/railroady_runner.rb

@@ -0,0 +1,52 @@
+require 'fileutils'
+require 'parser/current'
+require_relative 'ast_processor' # Add this line
+
+module Solidarity
+  class RailRoadyRunner
+    def self.run(project_path)
+      unless File.directory?(project_path)
+        raise ArgumentError, "Project path '#{project_path}' is not a valid directory."
+      end
+
+      # Remove Railroady's Rails-specific environment loading
+      # options = OptionsStruct.new(root: project_path, verbose: false, output: nil)
+      # diagram = ModelsDiagram.new(options)
+      # diagram.process
+      # diagram.generate
+      # diagram.graph
+
+      ruby_files = Dir.glob(File.join(project_path, "**", "*.rb"))
+      ast_data = process_ruby_files_with_ast(ruby_files)
+      Solidarity::Graph.from_ast_data(ast_data)
+    end
+
+    private
+
+    def self.process_ruby_files_with_ast(ruby_files)
+      processor = AstProcessor.new
+      ruby_files.each do |file_path|
+        processor.process_file(file_path)
+      end
+      { classes: processor.classes, modules: processor.modules, inheritances: processor.inheritances, includes: processor.includes }
+    end
+
+    def self.add_nodes_from_ast(graph, ast_data)
+      ast_data[:classes].each do |class_name|
+        graph.add_node(['class', class_name])
+      end
+      ast_data[:modules].each do |module_name|
+        graph.add_node(['module', module_name])
+      end
+    end
+
+    def self.add_edges_from_ast(graph, ast_data)
+      ast_data[:inheritances].each do |child, parent|
+        graph.add_edge(['is-a', parent, child]) unless parent.empty? # Railroady expects parent then child for 'is-a'
+      end
+      ast_data[:includes].each do |includer, included|
+        graph.add_edge(['includes', includer, included])
+      end
+    end
+  end
+end

data/lib/solidarity/reporter.rb

@@ -0,0 +1,28 @@
+module Solidarity
+  class Reporter
+    def self.generate_report(solid_results)
+      report = "# Ruby SOLID Principles Analysis Report\n\n"
+
+      solid_results.each do |principle, result|
+        report += "## #{principle.to_s.upcase} - #{full_principle_name(principle)}\n"
+        report += "Score: #{result[:score].round(2)}/100\n"
+        report += "Details: #{result[:details]}\n\n"
+      end
+
+      report
+    end
+
+    private
+
+    def self.full_principle_name(principle_symbol)
+      case principle_symbol
+      when :srp then "Single Responsibility Principle"
+      when :ocp then "Open/Closed Principle"
+      when :lsp then "Liskov Substitution Principle"
+      when :isp then "Interface Segregation Principle"
+      when :dip then "Dependency Inversion Principle"
+      else "Unknown Principle"
+      end
+    end
+  end
+end

data/lib/solidarity/solid_evaluator.rb

@@ -0,0 +1,74 @@
+module Solidarity
+  class SolidEvaluator
+    def initialize(graph)
+      @graph = graph
+    end
+
+    def evaluate_srp
+      # Single Responsibility Principle (SRP)
+      # Heuristic: High outgoing edges might indicate multiple responsibilities.
+      # For a more accurate measure, we'd need to analyze method calls/dependencies within each class.
+      srp_scores = {}
+      @graph.nodes.each do |node|
+        outgoing_count = @graph.outgoing_edges(node.name).count
+        srp_scores[node.name] = outgoing_count < 5 ? 100 : (100 - (outgoing_count - 5) * 10).clamp(0, 100)
+      end
+      { score: srp_scores.values.sum / srp_scores.size.to_f, details: srp_scores }
+    end
+
+    def evaluate_ocp
+      # Open/Closed Principle (OCP)
+      # Heuristic: Presence of inheritance/module inclusions. Hard to measure purely from dependency graph.
+      # A higher number of classes participating in inheritance/module inclusion might suggest better OCP.
+      ocp_score = 0
+      inheriting_nodes = @graph.edges.count { |edge| edge.type == :inheritance || edge.type == :includes }
+      ocp_score = (inheriting_nodes > @graph.nodes.count / 4) ? 100 : (inheriting_nodes * 100.0 / (@graph.nodes.count / 4)).clamp(0, 100)
+      { score: ocp_score, details: "Number of inheritance/inclusion relationships: #{inheriting_nodes}" }
+    end
+
+    def evaluate_lsp
+      # Liskov Substitution Principle (LSP)
+      # Very hard to evaluate statically from a dependency graph. Requires behavioral analysis.
+      # Placeholder: Assume a perfectly flat hierarchy (no deep inheritance) is better, but this is a very weak heuristic.
+      { score: 70, details: "LSP is difficult to assess statically from a dependency graph." }
+    end
+
+    def evaluate_isp
+      # Interface Segregation Principle (ISP)
+      # Heuristic: Could look for modules included by many classes but with few used methods by each class.
+      # Requires method-level analysis, which is not available from railroady's DOT output.
+      { score: 70, details: "ISP is difficult to assess without method-level dependency analysis." }
+    end
+
+    def evaluate_dip
+      # Dependency Inversion Principle (DIP)
+      # Heuristic: High-level modules should depend on abstractions, not concretions.
+      # We can look for dependencies from concrete classes to other concrete classes as a potential violation.
+      # This requires distinguishing between abstract/concrete classes, which railroady doesn't explicitly provide.
+      dip_score = 100
+      # For now, a very simplistic view: count edges between concrete classes.
+      # This needs significant refinement to be meaningful.
+      # concrete_to_concrete_dependencies = 0 # Placeholder
+      # @graph.edges.each do |edge|
+      #   source_node = @graph.find_node(edge.source)
+      #   target_node = @graph.find_node(edge.target)
+      #   if source_node&.type == :class && target_node&.type == :class # Assuming :class is concrete
+      #     concrete_to_concrete_dependencies += 1
+      #   end
+      # end
+      # dip_score = (100 - concrete_to_concrete_dependencies * 5).clamp(0, 100)
+
+      { score: dip_score, details: "DIP assessment requires distinguishing abstract from concrete classes." }
+    end
+
+    def evaluate_all
+      { 
+        srp: evaluate_srp,
+        ocp: evaluate_ocp,
+        lsp: evaluate_lsp,
+        isp: evaluate_isp,
+        dip: evaluate_dip
+      }
+    end
+  end
+end

data/lib/solidarity/version.rb

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

data/lib/solidarity.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "solidarity/version"
+require_relative "solidarity/railroady_runner"
+require_relative "solidarity/graph"
+require_relative "solidarity/solid_evaluator"
+require_relative "solidarity/reporter"
+
+module Solidarity
+  class Error < StandardError; end
+end

data/sig/solidarity.rbs

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

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: solidarity
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Your Name
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: This gem uses RailRoady to generate class diagrams and then analyzes
+  them to provide an assessment of SOLID principles.
+email:
+- your_email@example.com
+executables:
+- solidarity
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/solidarity
+- lib/solidarity.rb
+- lib/solidarity/ast_processor.rb
+- lib/solidarity/graph.rb
+- lib/solidarity/railroady_runner.rb
+- lib/solidarity/reporter.rb
+- lib/solidarity/solid_evaluator.rb
+- lib/solidarity/version.rb
+- sig/solidarity.rbs
+homepage: https://github.com/solidarity-gem/solidarity
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/solidarity-gem/solidarity
+  source_code_uri: https://github.com/solidarity-gem/solidarity
+  changelog_uri: https://github.com/solidarity-gem/solidarity/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: A Ruby gem for analyzing Ruby projects for SOLID principles adherence.
+test_files: []