misogi 0.1.0

data/lib/misogi/cli.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Misogi
+  # コマンドラインインターフェース
+  class CLI
+    attr_reader :options
+
+    def initialize(argv = ARGV)
+      @argv = argv
+      @options = {
+        rules: nil, # nilの場合は設定ファイルを使用
+        base_path: nil,
+        pattern: nil,
+        config_path: ".misogi.yml"
+      }
+    end
+
+    # CLIを実行
+    # @return [Integer] 終了コード
+    def run
+      parse_options
+
+      # Railsルールが必要な場合はRails環境を読み込む
+      load_rails_environment_if_needed
+
+      files = collect_files
+      if files.empty?
+        warn "検証対象のファイルが見つかりませんでした"
+        return 1
+      end
+
+      # CLIオプションでルールが明示的に指定されている場合は従来通りの動作
+      violations = if @options[:rules]
+                     validate_with_cli_rules(files)
+                   else
+                     validate_with_config(files)
+                   end
+
+      display_violations(violations)
+
+      violations.empty? ? 0 : 1
+    end
+
+    private
+
+    # Railsルールが使用される場合にRails環境を読み込む
+    def load_rails_environment_if_needed
+      needs_rails = if @options[:rules]
+                      @options[:rules].include?(:rails)
+                    else
+                      # 設定ファイルをチェック
+                      config = load_configuration
+                      config.rules.key?(:rails) || config.rules.key?("rails")
+                    end
+
+      return unless needs_rails
+
+      load_rails_environment
+    end
+
+    # Rails環境を読み込む
+    def load_rails_environment
+      # config/boot.rbが存在するかチェック
+      boot_file = "config/boot.rb"
+      environment_file = "config/environment.rb"
+
+      unless File.exist?(boot_file)
+        warn "警告: #{boot_file} が見つかりません。Railsプロジェクトのルートディレクトリで実行してください。"
+        return
+      end
+
+      unless File.exist?(environment_file)
+        warn "警告: #{environment_file} が見つかりません。Railsプロジェクトのルートディレクトリで実行してください。"
+        return
+      end
+
+      # Rails環境を読み込む
+      require File.expand_path(boot_file)
+      require File.expand_path(environment_file)
+
+      # Rails アプリケーションを初期化（既に初期化されていない場合）
+      ::Rails.application.eager_load! if defined?(::Rails)
+    rescue StandardError => e
+      warn "警告: Rails環境の読み込みに失敗しました: #{e.message}"
+    end
+
+    # オプションをパース
+    def parse_options
+      parser = OptionParser.new do |opts|
+        opts.banner = "使い方: misogi [オプション] [ファイル...]"
+
+        opts.on("-r", "--rules RULES", Array, "使用するルール (ruby_standard,rails,rspec)") do |rules|
+          @options[:rules] = rules.map(&:to_sym)
+        end
+
+        opts.on("-b", "--base-path PATH", "ベースパス (デフォルト: lib)") do |path|
+          @options[:base_path] = path
+        end
+
+        opts.on("-p", "--pattern PATTERN", "検証するファイルパターン") do |pattern|
+          @options[:pattern] = pattern
+        end
+
+        opts.on("-c", "--config PATH", "設定ファイルのパス (デフォルト: .misogi.yml)") do |path|
+          @options[:config_path] = path
+        end
+
+        opts.on("-h", "--help", "ヘルプを表示") do
+          puts opts
+          exit 0
+        end
+
+        opts.on("-v", "--version", "バージョンを表示") do
+          puts "Misogi #{Misogi::VERSION}"
+          exit 0
+        end
+      end
+
+      parser.parse!(@argv)
+    rescue OptionParser::InvalidOption => e
+      warn "エラー: #{e.message}"
+      warn parser.help
+      exit 1
+    end
+
+    # 検証対象のファイルを収集
+    # @return [Array<String>] ファイルパスのリスト
+    def collect_files
+      if @argv.any?
+        # コマンドライン引数で指定されたファイル
+        @argv
+      elsif @options[:pattern]
+        # パターンで指定されたファイル
+        Dir.glob(@options[:pattern])
+      else
+        # デフォルト: lib, app, spec配下のRubyファイル
+        default_pattern = "{lib,app,spec}/**/*.rb"
+        Dir.glob(default_pattern)
+      end
+    end
+
+    # CLIルールで検証
+    # @param files [Array<String>] ファイルパスのリスト
+    # @return [Array<Violation>] 違反のリスト
+    def validate_with_cli_rules(files)
+      rules = @options[:rules].map do |rule_name|
+        create_rule(rule_name)
+      end.compact
+
+      validator = Validator.new(rules: rules)
+      validator.validate_files(files)
+    end
+
+    # 設定ファイルベースで検証
+    # @param files [Array<String>] ファイルパスのリスト
+    # @return [Array<Violation>] 違反のリスト
+    def validate_with_config(files)
+      config = load_configuration
+
+      # 除外パターンを適用
+      files = files.reject { |file| config.excluded?(file) }
+
+      # ファイルごとに適用するルールを決定して検証
+      files.flat_map do |file|
+        applicable_rules_config = config.rules_for(file)
+        next [] if applicable_rules_config.empty?
+
+        rules = applicable_rules_config.map do |rule_name, rule_config|
+          create_rule_from_config(rule_name, rule_config[:config])
+        end.compact
+
+        validator = Validator.new(rules: rules)
+        validator.validate_file(file)
+      end
+    end
+
+    # 設定ファイルをロード
+    # @return [Configuration]
+    def load_configuration
+      config = if File.exist?(@options[:config_path])
+                 Configuration.new(config_path: @options[:config_path])
+               else
+                 Configuration.default
+               end
+
+      # CLIオプションでbase_pathが指定されている場合は設定を上書き
+      if @options[:base_path] && config.rules.key?(:ruby_standard)
+        config.rules[:ruby_standard][:config]["base_path"] = @options[:base_path]
+      end
+
+      config
+    end
+
+    # ルールを作成（CLIオプションから）
+    # @param rule_name [Symbol] ルール名
+    # @return [Rule::Base, nil] ルールインスタンス
+    def create_rule(rule_name)
+      case rule_name
+      when :ruby_standard
+        Rule::RubyStandard.new(base_path: @options[:base_path] || "lib")
+      when :rails
+        Rule::Rails.new
+      when :rspec
+        Rule::RSpec.new
+      else
+        warn "警告: 不明なルール '#{rule_name}' がスキップされました"
+        nil
+      end
+    end
+
+    # ルールを作成（設定ファイルから）
+    # @param rule_name [String, Symbol] ルール名
+    # @param config [Hash] ルール設定
+    # @return [Rule::Base, nil] ルールインスタンス
+    def create_rule_from_config(rule_name, config)
+      rule_name_sym = rule_name.to_sym
+
+      case rule_name_sym
+      when :ruby_standard
+        base_path = config["base_path"] || config[:base_path] || "lib"
+        Rule::RubyStandard.new(base_path: base_path)
+      when :rails
+        inflections_path = config["inflections_path"] || config[:inflections_path]
+        Rule::Rails.new(inflections_path: inflections_path)
+      when :rspec
+        Rule::RSpec.new
+      else
+        warn "警告: 不明なルール '#{rule_name}' がスキップされました"
+        nil
+      end
+    end
+
+    # 違反を表示
+    # @param violations [Array<Violation>] 違反のリスト
+    def display_violations(violations)
+      if violations.empty?
+        puts "✓ 違反は見つかりませんでした"
+      else
+        puts "✗ #{violations.size}件の違反が見つかりました:\n\n"
+        violations.each do |violation|
+          puts violation
+        end
+      end
+    end
+  end
+end

data/lib/misogi/configuration.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Misogi
+  # 設定を管理するクラス
+  class Configuration
+    DEFAULT_CONFIG = {
+      "rules" => {
+        "ruby_standard" => {
+          "patterns" => ["lib/**/*.rb"],
+          "base_path" => "lib"
+        }
+      },
+      "exclude" => []
+    }.freeze
+
+    attr_reader :rules, :exclude
+
+    # @param config_path [String, nil] 設定ファイルのパス
+    def initialize(config_path: ".misogi.yml")
+      @config_path = config_path
+      @config = load_config
+      @rules = parse_rules(@config["rules"] || {})
+      @exclude = @config["exclude"] || []
+    end
+
+    # ファイルが除外対象かどうかをチェック
+    # @param file_path [String] ファイルパス
+    # @return [Boolean]
+    def excluded?(file_path)
+      @exclude.any? { |pattern| File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+    end
+
+    # 指定されたファイルに適用すべきルールを取得
+    # @param file_path [String] ファイルパス
+    # @return [Hash] ルール名とその設定のハッシュ
+    def rules_for(file_path)
+      @rules.select do |_rule_name, rule_config|
+        rule_config[:patterns].any? do |pattern|
+          File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+        end
+      end
+    end
+
+    # デフォルト設定を使用
+    # @return [Configuration]
+    def self.default
+      config = new(config_path: nil)
+      config.instance_variable_set(:@config, DEFAULT_CONFIG)
+      config.instance_variable_set(:@rules, parse_rules(DEFAULT_CONFIG["rules"]))
+      config.instance_variable_set(:@exclude, DEFAULT_CONFIG["exclude"])
+      config
+    end
+
+    # ルール設定をパース
+    # @param rules_config [Hash] ルール設定
+    # @return [Hash] パースされたルール設定
+    def self.parse_rules(rules_config)
+      rules_config.transform_keys(&:to_sym).transform_values do |config|
+        {
+          patterns: Array(config["patterns"] || config[:patterns]),
+          config: config.except("patterns", :patterns)
+        }
+      end
+    end
+
+    private
+
+    # 設定ファイルを読み込む
+    # @return [Hash]
+    def load_config
+      if @config_path && File.exist?(@config_path)
+        YAML.load_file(@config_path) || {}
+      else
+        DEFAULT_CONFIG.dup
+      end
+    rescue Psych::SyntaxError => e
+      warn "警告: 設定ファイルの読み込みに失敗しました: #{e.message}"
+      warn "デフォルト設定を使用します"
+      DEFAULT_CONFIG.dup
+    end
+
+    def parse_rules(rules_config)
+      self.class.parse_rules(rules_config)
+    end
+  end
+end

data/lib/misogi/parsed_content.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Misogi
+  # ファイルのパース結果を保持するクラス
+  class ParsedContent
+    attr_reader :namespaces
+
+    # @param namespaces [Array<String>] ファイル内で定義されている名前空間のリスト
+    #   例: ["Misogi::Rule::Base"] は Misogi::Rule::Base クラスが定義されていることを示す
+    def initialize(namespaces: [])
+      @namespaces = namespaces
+    end
+
+    # 指定された名前空間が定義されているかチェック
+    # @param namespace [String] チェックする名前空間
+    # @return [Boolean]
+    def include?(namespace)
+      namespaces.include?(namespace)
+    end
+
+    # パース結果が空かどうか
+    # @return [Boolean]
+    def empty?
+      namespaces.empty?
+    end
+  end
+end

data/lib/misogi/parser/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Misogi
+  module Parser
+    # すべてのパーサーの基底クラス
+    class Base
+      # ファイル内容をパースする
+      # @param content [String] ファイルの内容
+      # @return [ParsedContent] パース結果
+      def parse(content)
+        raise NotImplementedError, "#{self.class}#parseを実装してください"
+      end
+
+      # ファイルをパースできるか判定する
+      # @param file_path [String] ファイルパス
+      # @return [Boolean]
+      def parsable?(file_path)
+        raise NotImplementedError, "#{self.class}#parsable?を実装してください"
+      end
+    end
+  end
+end

data/lib/misogi/parser/ruby.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Misogi
+  module Parser
+    # Rubyファイルのパーサー
+    # Ripperを使用してRubyコードを解析し、定義されているクラス/モジュールを抽出する
+    class Ruby < Base
+      # @param file_path [String] ファイルパス
+      # @return [Boolean] .rbファイルかどうか
+      def parsable?(file_path)
+        File.extname(file_path) == ".rb"
+      end
+
+      # @param content [String] Rubyファイルの内容
+      # @return [ParsedContent] パース結果
+      def parse(content)
+        namespaces = extract_namespaces(content)
+        ParsedContent.new(namespaces: namespaces)
+      end
+
+      private
+
+      # Rubyコードから名前空間を抽出する
+      # @param content [String] Rubyコードの内容
+      # @return [Array<String>] 名前空間のリスト
+      def extract_namespaces(content)
+        sexp = Ripper.sexp(content)
+        return [] unless sexp
+
+        namespaces = []
+        traverse_sexp(sexp, [], namespaces)
+        namespaces
+      end
+
+      # S式を再帰的に走査して、クラス/モジュール定義を見つける
+      # @param node [Array] S式のノード
+      # @param current_namespace [Array<String>] 現在の名前空間のスタック
+      # @param namespaces [Array<String>] 見つかった名前空間を格納する配列
+      def traverse_sexp(node, current_namespace, namespaces)
+        return unless node.is_a?(Array)
+
+        case node[0]
+        when :class
+          # クラス定義: [:class, [:const_ref, [:@const, "ClassName", ...]], ...]
+          class_name = extract_const_path(node[1])
+          if class_name
+            full_name = (current_namespace + [class_name]).join("::")
+            namespaces << full_name
+            # クラス本体を再帰的に処理
+            traverse_sexp(node[3], current_namespace + [class_name], namespaces) if node[3]
+          end
+        when :module
+          # モジュール定義: [:module, [:const_ref, [:@const, "ModuleName", ...]], ...]
+          module_name = extract_const_path(node[1])
+          if module_name
+            full_name = (current_namespace + [module_name]).join("::")
+            namespaces << full_name
+            # モジュール本体を再帰的に処理
+            traverse_sexp(node[2], current_namespace + [module_name], namespaces) if node[2]
+          end
+        else
+          # その他のノードは子ノードを再帰的に処理
+          node.each do |child|
+            traverse_sexp(child, current_namespace, namespaces) if child.is_a?(Array)
+          end
+        end
+      end
+
+      # 定数パスから名前を抽出する
+      # @param node [Array] 定数パスのノード
+      # @return [String, nil] 定数名
+      def extract_const_path(node)
+        return nil unless node.is_a?(Array)
+
+        case node[0]
+        when :const_ref
+          # [:const_ref, [:@const, "Name", ...]]
+          node[1][1] if node[1] && node[1][0] == :@const
+        when :const_path_ref
+          # [:const_path_ref, parent, [:@const, "Name", ...]]
+          # 例: Foo::Bar の場合
+          parent = extract_const_path(node[1])
+          child = node[2][1] if node[2] && node[2][0] == :@const
+          parent && child ? "#{parent}::#{child}" : nil
+        when :const_path_field
+          # [:const_path_field, parent, [:@const, "Name", ...]]
+          # クラス定義でのコンパクト記法の場合
+          parent = extract_const_path(node[1])
+          child = node[2][1] if node[2] && node[2][0] == :@const
+          parent && child ? "#{parent}::#{child}" : nil
+        when :top_const_ref
+          # [:top_const_ref, [:@const, "Name", ...]]
+          # 例: ::Foo の場合
+          node[1][1] if node[1] && node[1][0] == :@const
+        when :top_const_field
+          # [:top_const_field, [:@const, "Name", ...]]
+          # トップレベル定数のフィールド
+          node[1][1] if node[1] && node[1][0] == :@const
+        when :var_ref
+          # [:var_ref, [:@const, "Name", ...]]
+          # 定数の参照
+          node[1][1] if node[1] && node[1][0] == :@const
+        end
+      end
+    end
+  end
+end

data/lib/misogi/rule/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Misogi
+  module Rule
+    # すべてのルールの基底クラス
+    # カスタムルールを作成する場合は、このクラスを継承して#validateメソッドを実装する
+    class Base
+      # ルール名を返す（デフォルトはクラス名）
+      # @return [String]
+      def name
+        self.class.name.split("::").last
+      end
+
+      # ファイルパスとパース結果を検証する
+      # @param file_path [String] 検証対象のファイルパス
+      # @param parsed_content [ParsedContent] パース結果
+      # @return [Array<Violation>] 検出された違反のリスト
+      def validate(file_path, parsed_content)
+        raise NotImplementedError, "#{self.class}#validateを実装してください"
+      end
+
+      protected
+
+      # 違反を作成するヘルパーメソッド
+      # @param file_path [String] ファイルパス
+      # @param message [String] 違反メッセージ
+      # @return [Violation]
+      def violation(file_path:, message:)
+        Violation.new(file_path: file_path, message: message, rule_name: name)
+      end
+    end
+  end
+end

data/lib/misogi/rule/rails.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Misogi
+  module Rule
+    # Railsの規約に従ってファイルパスとクラス/モジュール名の対応をチェックするルール
+    # 例:
+    #   app/models/user.rb -> User
+    #   app/controllers/users_controller.rb -> UsersController
+    #   app/services/foo/bar_service.rb -> Foo::BarService
+    class Rails < Base
+      # Railsのディレクトリとその規約のマッピング
+      DIRECTORY_PATTERNS = {
+        "app/models" => { suffix: "" },
+        "app/controllers" => { suffix: "" },
+        "app/helpers" => { suffix: "" },
+        "app/mailers" => { suffix: "" },
+        "app/jobs" => { suffix: "" },
+        "app/services" => { suffix: "" },
+        "app/decorators" => { suffix: "" },
+        "app/presenters" => { suffix: "" },
+        "app/validators" => { suffix: "" },
+        "app/policies" => { suffix: "" },
+        "app/channels" => { suffix: "" },
+        "app/mailboxes" => { suffix: "" }
+      }.freeze
+
+      def initialize(inflections_path: nil)
+        super()
+        @inflections_path = inflections_path # 後方互換性のため残すが使用しない
+        @active_support_available = check_active_support
+      end
+
+      # @param file_path [String] 検証対象のファイルパス
+      # @param parsed_content [ParsedContent] パース結果
+      # @return [Array<Violation>] 検出された違反のリスト
+      def validate(file_path, parsed_content)
+        pattern_info = find_matching_pattern(file_path)
+        return [] unless pattern_info
+
+        violations = []
+
+        if parsed_content.empty?
+          violations << violation(
+            file_path: file_path,
+            message: "ファイルにクラスまたはモジュールが定義されていません"
+          )
+          return violations
+        end
+
+        # concernsディレクトリ内のファイルでは、名前空間に"Concerns::"を含んではいけない
+        if file_path.include?("/concerns/")
+          concerns_violation = check_concerns_namespace(file_path, parsed_content)
+          violations << concerns_violation if concerns_violation
+          return violations if concerns_violation
+        end
+
+        # 定義されている各名前空間について期待されるパスを計算
+        base_path = pattern_info[:base_path]
+        expected_paths = parsed_content.namespaces.flat_map do |namespace|
+          namespace_to_paths(namespace, base_path, file_path)
+        end
+
+        # 実際のファイルパスが期待されるパスのいずれかと一致するか確認
+        unless expected_paths.include?(file_path)
+          expected_paths_str = expected_paths.map { |p| "`#{p}`" }.join(" または ")
+          defined_namespaces = parsed_content.namespaces.join(", ")
+          violations << violation(
+            file_path: file_path,
+            message: "名前空間 '#{defined_namespaces}' は #{expected_paths_str} に配置すべきです"
+          )
+        end
+
+        violations
+      end
+
+      private
+
+      # concernsディレクトリ内のファイルの名前空間をチェック
+      # @param file_path [String] ファイルパス
+      # @param parsed_content [ParsedContent] パース結果
+      # @return [Violation, nil] 違反がある場合はViolationオブジェクト
+      def check_concerns_namespace(file_path, parsed_content)
+        # concernsディレクトリ内のファイルでは、名前空間に"Concerns::"を含んではいけない
+        invalid_namespaces = parsed_content.namespaces.select do |namespace|
+          namespace.start_with?("Concerns::") || namespace.include?("::Concerns::")
+        end
+
+        return nil if invalid_namespaces.empty?
+
+        violation(
+          file_path: file_path,
+          message: "concernsディレクトリ内のファイルでは、名前空間に 'Concerns::' を含めるべきではありません。" \
+                   "定義されている名前空間: #{invalid_namespaces.join(", ")}"
+        )
+      end
+
+      # ファイルパスに一致するパターンを見つける
+      # @param file_path [String] ファイルパス
+      # @return [Hash, nil] パターン情報
+      def find_matching_pattern(file_path)
+        DIRECTORY_PATTERNS.each do |base_path, options|
+          return { base_path: base_path, **options } if file_path.start_with?(base_path)
+        end
+        nil
+      end
+
+      # 名前空間から期待されるファイルパスを生成する（複数の可能性を返す）
+      # @param namespace [String] 名前空間（例: "Foo::Bar"）
+      # @param base_path [String] ベースパス（例: "app/models"）
+      # @param current_file_path [String] 現在検証中のファイルパス
+      # @return [Array<String>] 期待されるファイルパスのリスト
+      def namespace_to_paths(namespace, base_path, current_file_path)
+        # 名前空間をパーツに分割
+        parts = namespace.split("::")
+
+        # 各パーツをスネークケースに変換
+        snake_parts = parts.map { |part| underscore(part) }
+
+        paths = []
+
+        # 通常のパス
+        paths << "#{File.join(base_path, *snake_parts)}.rb"
+
+        # concernsディレクトリ内のパス
+        # 現在のファイルがconcernsディレクトリ内にある場合、
+        # かつ名前空間が"Concerns::"で始まらない場合のみ、concernsパスも候補に含める
+        # （concernsディレクトリは名前空間に含めないRailsの規約のため）
+        if current_file_path.include?("/concerns/") && !namespace.start_with?("Concerns::")
+          paths << "#{File.join(base_path, "concerns", *snake_parts)}.rb"
+        end
+
+        paths
+      end
+
+      # ActiveSupportが利用可能かチェック
+      # @return [Boolean] ActiveSupportが利用可能かどうか
+      def check_active_support
+        # Rails環境が読み込まれている場合は、ActiveSupportも利用可能
+        return true if defined?(::Rails)
+
+        # Rails環境がない場合は、ActiveSupportを直接読み込んでみる
+        require "active_support/inflector"
+        true
+      rescue LoadError
+        false
+      end
+
+      # キャメルケースをスネークケースに変換
+      # @param str [String] キャメルケースの文字列
+      # @return [String] スネークケースの文字列
+      def underscore(str)
+        if @active_support_available
+          # ActiveSupportが利用可能な場合はそれを使用（inflectionsを考慮）
+          ActiveSupport::Inflector.underscore(str)
+        else
+          # フォールバック: 単純な変換
+          str
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+        end
+      end
+    end
+  end
+end