igata 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7be289ddd3a6be5183b8f8e64f3e5f175b9457a04c28d406a429646e8b6095c9
-  data.tar.gz: 92e060e8fb1751978e6dc579f3e7d5f66bb8cabbcc938c36ea63313b829a23e1
+  metadata.gz: 78199aa96fa495664cb461c46bbabdce3afa9a21f3083e5f49e41cb47e66f909
+  data.tar.gz: e2a0d35b071882c6b28ea13d1b88f846e3bb74adcf1ca92d7700aa7be635ee44
 SHA512:
-  metadata.gz: 942277698a8f0a1aaa4cb06a330d213e0e32494d9421fcdf4dd2220c4db936887ad553835406ef8fa3e4b93ca33ee2d18d6e75d78c674ec74c9311d6add62000
-  data.tar.gz: 1a30f0198426b5be82687c0b1492e3e18cb88e3eced706b36f4e5ecb64c54e4e4468dfc0ba5b0ce96da4d80e6549174b6eb1c08132ff07f34f15c2ae231f5902
+  metadata.gz: 4c5b75401c77c515dfdcb5968d44c7c4e8569ed10ebc03c5e7a7a8ab7e8225aa086cabcb66c99c7519f3c35fc5fb9f2789409d56d5d4961995c07ae79192df94
+  data.tar.gz: eb80ea990597cda4110a8b7e431d41d6c19c8af8bf5387e2e8ad270ea273e1b39f913107069ec8da2c8b836dbbe1efe8fe885aae9fc07afb26a53568efb49f26

data/.ruby-version

@@ -0,0 +1 @@
+3.4.7

data/CHANGELOG.md

@@ -1,5 +1,96 @@
 ## [Unreleased]
 
+## [0.2.0] - 2025-10-26
+
+### Added
+
+- Introduced Formatter architecture for supporting multiple test frameworks:
+  - `Formatters::Base`: Abstract base class for all formatters
+  - `Formatters::Minitest`: Minitest-specific formatter implementation
+  - `Formatters::RSpec`: RSpec-specific formatter implementation
+  - `MethodNotOverriddenError`: Custom error for abstract method violations
+  - Separated `Igata::Error` into dedicated file
+- Added CLI formatter option:
+  - `-f, --formatter FORMATTER`: Specify test framework formatter (minitest or rspec)
+- Added RSpec support:
+  - RSpec formatter generates `describe` and `it` blocks
+  - RSpec templates (class.erb and method.erb) for RSpec-style test generation
+  - Supports all branch and comparison analysis features in RSpec format
+  - Branch and comparison comments in RSpec tests (e.g., `# Branches: if (value > 0)`)
+  - Unit tests for RSpec formatter (6 tests)
+  - Integration tests for RSpec formatter (3 tests)
+- Added branch analysis functionality:
+  - `BranchInfo` value object: Stores branch information (type, condition)
+  - `BranchAnalyzer` extractor: Detects if/unless/case statements in methods
+  - `MethodInfo` now includes `branches` field for branch information
+  - Minitest template generates branch comments with condition information (e.g., `# Branches: if (age >= 18), unless (user.valid?)`)
+  - Extracts condition expressions for if/unless/case statements
+  - Handles method calls, comparisons, and variable references in conditions
+- Added comparison analysis functionality:
+  - `ComparisonInfo` value object: Stores comparison information (operator, left, right, context)
+  - `ComparisonAnalyzer` extractor: Detects comparison operators (>=, <=, >, <, ==, !=) in methods
+  - `MethodInfo` now includes `comparisons` field for comparison information
+  - Minitest template generates comparison comments (e.g., `# Comparisons: >= (age >= 18)`)
+  - Supports multiple comparisons with AND/OR operators (e.g., `value >= 0 && value <= 150`)
+  - Detects comparisons in various contexts: direct returns, if/unless conditions, nested expressions
+  - Handles different expression types: local variables, instance variables, integers, strings, symbols
+- Added comprehensive unit tests:
+  - Extractor tests: `ConstantPath` (10 tests), `MethodNames` (6 tests), `BranchAnalyzer` (6 tests), `ComparisonAnalyzer` (6 tests)
+  - Formatter tests: `Base` (3 tests), `Minitest` (6 tests)
+  - Total: 37 new unit tests added
+- Added integration tests for branch analysis:
+  - `class_with_branches` test fixture with if/unless/case statements
+  - 4 integration tests verifying branch comment generation
+- Added integration tests for comparison analysis:
+  - `class_with_comparisons` test fixture with various comparison operators
+  - 6 integration tests verifying comparison comment generation
+- Added ERB templates (class.erb and method.erb) to generate Minitest test code skeleton
+- Implemented test generation supporting various class/module nesting patterns:
+  - Simple classes: `class User`
+  - Regular nested classes: `class User; class Profile; end; end`
+  - Compact nested classes: `class User::Profile`
+  - Deep nested classes: `class App::User::Profile` (supports any depth)
+  - Mixed nested patterns: `class App::User; class Profile; end; end`
+  - Double compact nested: `class App::Model; class User::Profile; end; end`
+  - Triple nested with mixed patterns: `class App::Model; class Admin::User; class Profile; end; end; end`
+  - Compact nested modules: `module User::Updator`
+- Generated test files include properly indented method definitions with skip statements
+- Test methods are separated by blank lines for better readability
+- Implemented CLI with OptionParser support
+  - `-o, --output FILE`: Write output to file instead of stdout
+  - `-h, --help`: Display help message
+  - `-v, --version`: Display version information
+  - File argument support: `igata file.rb`
+  - Stdin support: `cat file.rb | igata`
+- Added CLI regression tests (test/cli_test.rb) covering all command-line options and input methods
+
+### Changed
+
+- Reorganized project structure for multi-formatter support:
+  - Moved templates to `lib/igata/formatters/templates/minitest/`
+  - Reorganized fixtures to `test/fixtures/integration/minitest/`
+  - Test type (integration/unit) is now the primary hierarchy, formatter (minitest) is secondary
+  - Separated tests into `test/integration/` and `test/unit/`
+- Refactored code generation to use Formatter pattern:
+  - `Igata` class delegates to formatter for code generation
+  - Accepts `formatter:` parameter (default: `:minitest`)
+  - Supports custom formatter classes
+- Refactored AST analysis logic into Extractor pattern for better separation of concerns
+- Introduced Value Objects (`ConstantPath`, `MethodInfo`, `BranchInfo`) using `Data.define` for immutable data structures
+- Implemented recursive traversal for deeply nested class/module definitions
+- AST extraction is now handled by specialized extractors:
+  - `Extractors::ConstantPath`: Extracts full constant paths from nested structures
+  - `Extractors::MethodNames`: Extracts method information from class nodes
+  - `Extractors::BranchAnalyzer`: Analyzes control flow branches in methods
+  - `Extractors::ComparisonAnalyzer`: Analyzes comparison operators in methods
+- `MethodNames` extractor now automatically runs `BranchAnalyzer` and `ComparisonAnalyzer` for each method
+
+### Fixed
+
+- Fixed empty class handling in Extractors:
+  - `ConstantPath` now handles BeginNode (empty classes) correctly
+  - `MethodNames` returns empty array for BeginNode instead of raising error
+
 ## [0.1.0] - 2025-10-25
 
 - Initial release

data/QUICKSTART.md

@@ -0,0 +1,168 @@
+# Quick Start Guide
+
+Get started with Igata in 5 minutes.
+
+## What is Igata?
+
+Igata (鋳型 = mold/template) generates test code templates from your Ruby classes. It analyzes your code structure and creates test skeletons with helpful comments about branches and comparisons, so you can focus on writing test logic instead of boilerplate.
+
+## Installation
+
+```bash
+gem install igata
+```
+
+Or add to your Gemfile:
+
+```bash
+bundle add igata
+```
+
+## Your First Test Generation
+
+### 1. Create a sample Ruby class
+
+Create a file `user.rb`:
+
+```ruby
+class User
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+
+  def adult?
+    @age >= 18
+  end
+
+  def greeting
+    if @name
+      "Hello, #{@name}!"
+    else
+      "Hello, Guest!"
+    end
+  end
+end
+```
+
+### 2. Generate Minitest (default)
+
+```bash
+igata user.rb > test/test_user.rb
+```
+
+Output:
+
+```ruby
+# frozen_string_literal: true
+
+require "test_helper"
+
+class UserTest < Minitest::Test
+  def test_initialize
+    skip "Not implemented yet"
+  end
+
+  def test_adult?
+    # Comparisons: >= (@age >= 18)
+    skip "Not implemented yet"
+  end
+
+  def test_greeting
+    # Branches: if (@name)
+    skip "Not implemented yet"
+  end
+end
+```
+
+### 3. Generate RSpec
+
+```bash
+igata user.rb -f rspec > spec/user_spec.rb
+```
+
+Output:
+
+```ruby
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe User do
+  describe "#initialize" do
+    it "works correctly" do
+      pending "Not implemented yet"
+    end
+  end
+
+  describe "#adult?" do
+    # Comparisons: >= (@age >= 18)
+    it "works correctly" do
+      pending "Not implemented yet"
+    end
+  end
+
+  describe "#greeting" do
+    # Branches: if (@name)
+    it "works correctly" do
+      pending "Not implemented yet"
+    end
+  end
+end
+```
+
+## Common Usage Patterns
+
+### Generate from stdin
+
+```bash
+cat lib/user.rb | igata
+```
+
+### Specify output file
+
+```bash
+igata lib/user.rb -o test/test_user.rb
+```
+
+### Multiple formatters
+
+```bash
+# Minitest (default)
+igata lib/user.rb > test/test_user.rb
+
+# RSpec
+igata lib/user.rb -f rspec > spec/user_spec.rb
+```
+
+## Understanding the Output
+
+Igata adds helpful comments to guide your test implementation:
+
+- **`# Branches:`** - Shows conditional logic (if/unless/case) with conditions
+- **`# Comparisons:`** - Shows comparison operators (>=, <=, >, <, ==, !=) suggesting boundary value tests
+
+These comments help you:
+1. Identify edge cases to test
+2. Write comprehensive test coverage
+3. Understand method complexity at a glance
+4. **Assist LLMs** - GitHub Copilot, Claude, ChatGPT, and other LLMs may use these comments as context to generate more appropriate test code
+
+## Next Steps
+
+- See [README.md](README.md) for complete documentation
+- Check [CHANGELOG.md](CHANGELOG.md) for feature details
+- Write your test logic inside the generated skeleton
+- Remove `skip` / `pending` statements as you implement tests
+
+## Tips
+
+1. **Nested classes work**: `class User::Profile` generates proper test structure
+2. **Run tests first**: Generated tests use `skip`/`pending` so they won't fail
+3. **Combine with TDD**: Generate template → Write test logic → Implement feature
+4. **Use comments**: Branch and comparison comments guide your test cases
+
+## Need Help?
+
+- [GitHub Issues](https://github.com/S-H-GAMELINKS/igata/issues)
+- [Full Documentation](README.md)

data/README.md

@@ -2,6 +2,8 @@
 
 Generate test code from AST node produces by Ruby's Parser
 
+**[📚 Quick Start Guide](QUICKSTART.md)** | [Full Documentation](#usage) | [Changelog](CHANGELOG.md)
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -18,10 +20,86 @@ gem install igata
 
 ## Usage
 
+### Basic Usage
+
+Generate Minitest tests (default):
+
 ```bash
 bundle exec igata lib/user.rb > test/test_user.rb
 ```
 
+Generate RSpec tests:
+
+```bash
+bundle exec igata lib/user.rb -f rspec > spec/user_spec.rb
+# or
+bundle exec igata lib/user.rb --formatter rspec > spec/user_spec.rb
+```
+
+### Supported Formatters
+
+- `minitest` (default): Generates Minitest-style tests
+- `rspec`: Generates RSpec-style tests
+
+### Example
+
+Given a Ruby class:
+
+```ruby
+class User
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+
+  def adult?
+    @age >= 18
+  end
+end
+```
+
+Minitest output:
+
+```ruby
+# frozen_string_literal: true
+
+require "test_helper"
+
+class UserTest < Minitest::Test
+  def test_initialize
+    skip "Not implemented yet"
+  end
+
+  def test_adult?
+    # Comparisons: >= (@age >= 18)
+    skip "Not implemented yet"
+  end
+end
+```
+
+RSpec output:
+
+```ruby
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe User do
+  describe "#initialize" do
+    it "works correctly" do
+      pending "Not implemented yet"
+    end
+  end
+
+  describe "#adult?" do
+    # Comparisons: >= (@age >= 18)
+    it "works correctly" do
+      pending "Not implemented yet"
+    end
+  end
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/exe/igata

@@ -2,3 +2,47 @@
 # frozen_string_literal: true
 
 require "igata"
+require "optparse"
+
+options = { formatter: :minitest }
+OptionParser.new do |opts|
+  opts.banner = "Usage: igata [options] [file]"
+  opts.version = Igata::VERSION
+
+  opts.on("-f", "--formatter FORMATTER", %i[minitest rspec],
+          "Test framework formatter (minitest, rspec)") do |formatter|
+    options[:formatter] = formatter
+  end
+
+  opts.on("-o", "--output FILE", "Write output to FILE instead of stdout") do |file|
+    options[:output] = file
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+
+  opts.on("-v", "--version", "Show version") do
+    puts Igata::VERSION
+    exit
+  end
+end.parse!
+
+# Read input from file or stdin
+source = if ARGV.empty?
+           $stdin.read
+         else
+           File.read(ARGV[0])
+         end
+
+# Generate test code
+igata = Igata.new(source, formatter: options[:formatter])
+output = igata.generate
+
+# Write output to file or stdout
+if options[:output]
+  File.write(options[:output], output)
+else
+  puts output
+end

data/lib/igata/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Igata
+  class Error < StandardError; end
+end

data/lib/igata/extractors/branch_analyzer.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+class Igata
+  module Extractors
+    class BranchAnalyzer
+      def self.extract(method_node)
+        new(method_node).extract
+      end
+
+      def initialize(method_node)
+        @method_node = method_node
+      end
+
+      def extract
+        return [] unless @method_node
+        return [] unless @method_node.respond_to?(:defn)
+
+        branches = []
+        # DefinitionNode has a defn field that contains ScopeNode
+        defn_node = @method_node.defn
+        traverse_node(defn_node, branches) if defn_node
+        branches
+      end
+
+      private
+
+      def traverse_node(node, branches) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return unless node
+
+        # Handle IfStatementNode (if/elsif/else)
+        if node.is_a?(Kanayago::IfStatementNode)
+          branches << Values::BranchInfo.new(
+            type: :if,
+            condition: extract_condition(node)
+          )
+          # Continue traversing child nodes
+          traverse_node(node.body, branches) if node.respond_to?(:body)
+          traverse_node(node.elsif, branches) if node.respond_to?(:elsif)
+          traverse_node(node.else, branches) if node.respond_to?(:else)
+        # Handle UnlessStatementNode
+        elsif node.is_a?(Kanayago::UnlessStatementNode)
+          branches << Values::BranchInfo.new(
+            type: :unless,
+            condition: extract_condition(node)
+          )
+          traverse_node(node.body, branches) if node.respond_to?(:body)
+          traverse_node(node.else, branches) if node.respond_to?(:else)
+        # Handle CaseNode (case/when)
+        elsif node.is_a?(Kanayago::CaseNode)
+          branches << Values::BranchInfo.new(
+            type: :case,
+            condition: extract_condition(node)
+          )
+          # Traverse when branches
+          traverse_node(node.body, branches) if node.respond_to?(:body)
+          traverse_node(node.else, branches) if node.respond_to?(:else)
+        # Handle ScopeNode (container node)
+        elsif node.is_a?(Kanayago::ScopeNode)
+          traverse_node(node.body, branches) if node.respond_to?(:body)
+        # Handle BlockNode (container for multiple statements)
+        elsif node.is_a?(Kanayago::BlockNode)
+          node.each { |child| traverse_node(child, branches) } if node.respond_to?(:each)
+        # Handle other container nodes
+        elsif node.respond_to?(:body) && node.body.respond_to?(:each)
+          node.body.each { |child| traverse_node(child, branches) }
+        end
+      end
+
+      def extract_condition(branch_node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        return nil unless branch_node
+
+        # Extract condition based on branch type
+        condition_node = if branch_node.is_a?(Kanayago::IfStatementNode) || branch_node.is_a?(Kanayago::UnlessStatementNode)
+                           branch_node.cond if branch_node.respond_to?(:cond)
+                         elsif branch_node.is_a?(Kanayago::CaseNode)
+                           branch_node.head if branch_node.respond_to?(:head)
+                         end
+
+        return nil unless condition_node
+
+        extract_expression(condition_node)
+      end
+
+      def extract_expression(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return "" unless node
+
+        # Handle different node types for source reconstruction
+        if node.is_a?(Kanayago::LocalVariableNode)
+          node.vid.to_s
+        elsif node.is_a?(Kanayago::InstanceVariableNode)
+          node.vid.to_s
+        elsif node.is_a?(Kanayago::IntegerNode)
+          node.val.to_s
+        elsif node.is_a?(Kanayago::StringNode)
+          "\"#{node.val}\""
+        elsif node.is_a?(Kanayago::SymbolNode)
+          ":#{node.ptr}"
+        elsif node.is_a?(Kanayago::OperatorCallNode)
+          # Handle comparison operators like age >= 18
+          left = extract_expression(node.recv)
+          operator = node.mid.to_s
+          right = extract_expression(node.args&.val&.first)
+          "#{left} #{operator} #{right}"
+        elsif node.is_a?(Kanayago::CallNode)
+          # Handle method calls like user.valid?
+          if node.respond_to?(:recv) && node.recv
+            receiver = extract_expression(node.recv)
+            method_name = node.mid.to_s
+            "#{receiver}.#{method_name}"
+          elsif node.respond_to?(:mid)
+            node.mid.to_s
+          else
+            "call"
+          end
+        elsif node.respond_to?(:mid)
+          node.mid.to_s
+        elsif node.is_a?(Integer) || node.is_a?(String)
+          node.to_s
+        else
+          node.class.name.split("::").last.gsub("Node", "").downcase
+        end
+      end
+    end
+  end
+end

data/lib/igata/extractors/comparison_analyzer.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+class Igata
+  module Extractors
+    class ComparisonAnalyzer
+      COMPARISON_OPERATORS = %i[>= <= > < == !=].freeze
+
+      def self.extract(method_node)
+        new(method_node).extract
+      end
+
+      def initialize(method_node)
+        @method_node = method_node
+      end
+
+      def extract
+        return [] unless @method_node
+        return [] unless @method_node.respond_to?(:defn)
+
+        comparisons = []
+        # DefinitionNode has a defn field that contains ScopeNode
+        defn_node = @method_node.defn
+        traverse_node(defn_node, comparisons) if defn_node
+        comparisons
+      end
+
+      private
+
+      def traverse_node(node, comparisons) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return unless node
+
+        # Handle OperatorCallNode (comparison operators are OperatorCallNode in Kanayago)
+        if node.is_a?(Kanayago::OperatorCallNode) && COMPARISON_OPERATORS.include?(node.mid)
+          comparisons << Values::ComparisonInfo.new(
+            operator: node.mid,
+            left: extract_expression(node.recv),
+            right: extract_expression(node.args&.val&.first),
+            context: build_context(node)
+          )
+        # Handle AndNode and OrNode (traverse both sides)
+        elsif node.is_a?(Kanayago::AndNode) || node.is_a?(Kanayago::OrNode)
+          traverse_node(node.first, comparisons) if node.respond_to?(:first)
+          traverse_node(node.second, comparisons) if node.respond_to?(:second)
+        # Handle IfStatementNode (traverse condition and body)
+        elsif node.is_a?(Kanayago::IfStatementNode)
+          traverse_node(node.cond, comparisons) if node.respond_to?(:cond)
+          traverse_node(node.body, comparisons) if node.respond_to?(:body)
+          traverse_node(node.else, comparisons) if node.respond_to?(:else)
+        # Handle UnlessStatementNode
+        elsif node.is_a?(Kanayago::UnlessStatementNode)
+          traverse_node(node.cond, comparisons) if node.respond_to?(:cond)
+          traverse_node(node.body, comparisons) if node.respond_to?(:body)
+          traverse_node(node.else, comparisons) if node.respond_to?(:else)
+        # Handle CaseNode
+        elsif node.is_a?(Kanayago::CaseNode)
+          traverse_node(node.body, comparisons) if node.respond_to?(:body)
+          traverse_node(node.else, comparisons) if node.respond_to?(:else)
+        # Handle ScopeNode (container node)
+        elsif node.is_a?(Kanayago::ScopeNode)
+          traverse_node(node.body, comparisons) if node.respond_to?(:body)
+        # Handle BlockNode (container for multiple statements)
+        elsif node.is_a?(Kanayago::BlockNode)
+          node.each { |child| traverse_node(child, comparisons) } if node.respond_to?(:each)
+        # Handle other container nodes
+        elsif node.respond_to?(:body) && node.body.respond_to?(:each)
+          node.body.each { |child| traverse_node(child, comparisons) }
+        end
+      end
+
+      def extract_expression(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return "" unless node
+
+        # Handle different node types for source reconstruction
+        if node.is_a?(Kanayago::LocalVariableNode)
+          node.vid.to_s
+        elsif node.is_a?(Kanayago::InstanceVariableNode)
+          node.vid.to_s
+        elsif node.is_a?(Kanayago::IntegerNode)
+          node.val.to_s
+        elsif node.is_a?(Kanayago::StringNode)
+          "\"#{node.val}\""
+        elsif node.is_a?(Kanayago::SymbolNode)
+          ":#{node.ptr}"
+        elsif node.respond_to?(:mid)
+          node.mid.to_s
+        elsif node.is_a?(Integer) || node.is_a?(String)
+          node.to_s
+        else
+          node.class.name.split("::").last.gsub("Node", "").downcase
+        end
+      end
+
+      def build_context(call_node)
+        left = extract_expression(call_node.recv)
+        operator = call_node.mid.to_s
+        right = extract_expression(call_node.args&.val&.first)
+        "#{left} #{operator} #{right}"
+      end
+    end
+  end
+end

data/lib/igata/extractors/constant_path.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+class Igata
+  module Extractors
+    class ConstantPath
+      def self.extract(ast)
+        new(ast).extract
+      end
+
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def extract # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        if compact_nested? && nested?
+          # Mixed pattern: class App::User; class Profile; end; end
+          # Inner class may also be compact nested: class App::Model; class User::Profile; end
+          # May be deeply nested: class App::Model; class Admin::User; class Profile; end; end; end
+          compact_path = extract_compact_nested_path
+          nested_path = build_nested_path(@ast.body)
+          path = "#{compact_path}::#{nested_path}"
+
+          Values::ConstantPath.new(
+            path: path,
+            nested: true,  # Has nested class inside
+            compact: true  # Outer is compact nested
+          )
+        elsif compact_nested?
+          # Compact nested pattern (no inner nesting): class User::Profile
+          path = extract_compact_nested_path
+          Values::ConstantPath.new(
+            path: path,
+            nested: false, # No nested class inside
+            compact: true
+          )
+        elsif nested?
+          # Regular nested pattern: class User; class Profile; end; end
+          # Inner class may also be compact nested: class User; class App::Profile; end
+          # May be deeply nested: class User; class Admin::User; class Profile; end; end; end
+          namespace = @ast.body.cpath.mid.to_s
+          nested_path = build_nested_path(@ast.body)
+          path = "#{namespace}::#{nested_path}"
+
+          Values::ConstantPath.new(
+            path: path,
+            nested: true, # Has nested class inside
+            compact: false
+          )
+        else
+          # Simple pattern: class User
+          Values::ConstantPath.new(
+            path: @ast.body.cpath.mid.to_s,
+            nested: false,
+            compact: false
+          )
+        end
+      end
+
+      private
+
+      def compact_nested?
+        # For compact nested pattern (class User::Profile), cpath is Colon2Node with non-nil head
+        @ast.body.cpath.is_a?(Kanayago::Colon2Node) && !@ast.body.cpath.head.nil?
+      end
+
+      def extract_compact_nested_path
+        # Recursively traverse cpath to build complete path
+        build_constant_path(@ast.body.cpath)
+      end
+
+      def build_constant_path(node) # rubocop:disable Metrics/MethodLength
+        case node
+        when Kanayago::Colon2Node
+          if node.head.nil?
+            # For "class User", head is nil so return only mid
+            node.mid.to_s
+          else
+            # For "User::Profile", combine head(User) + mid(Profile)
+            "#{build_constant_path(node.head)}::#{node.mid}"
+          end
+        when Kanayago::ConstantNode
+          # Top-level constant name
+          node.vid.to_s
+        else
+          node.to_s
+        end
+      end
+
+      def nested?
+        class_body = @ast.body.body.body
+        # For empty classes, class_body is BeginNode which doesn't have any?
+        return false unless class_body.respond_to?(:any?)
+
+        class_body.any? { |node| constant_definition_node?(node) }
+      end
+
+      def constant_definition_node?(node)
+        node.is_a?(Kanayago::ClassNode) || node.is_a?(Kanayago::ModuleNode)
+      end
+
+      def build_nested_path(parent_node) # rubocop:disable Metrics/MethodLength
+        # Find direct child class/module under the parent node
+        class_body = parent_node.body.body
+        # For empty classes, class_body is BeginNode which doesn't have find
+        return nil unless class_body.respond_to?(:find)
+
+        child_node = class_body.find { |node| constant_definition_node?(node) }
+        return nil unless child_node
+
+        # Get child class name (considering compact nesting)
+        child_class_path = build_constant_path(child_node.cpath)
+
+        # Check if there's deeper nesting
+        deeper_path = build_nested_path(child_node)
+
+        # Concatenate if deeper nesting exists, otherwise return current path
+        if deeper_path
+          "#{child_class_path}::#{deeper_path}"
+        else
+          child_class_path
+        end
+      end
+
+      def find_nested_constant_node
+        # Recursively find the deepest (innermost) class/module definition
+        find_deepest_nested_constant_node(@ast.body)
+      end
+
+      def find_deepest_nested_constant_node(parent_node)
+        # Find direct child class/module under the current node
+        direct_child = parent_node.body.body.find { |node| constant_definition_node?(node) }
+        return nil unless direct_child
+
+        # Check if there's deeper nesting in the child node
+        deeper_child = find_deepest_nested_constant_node(direct_child)
+
+        # Return deeper nesting if exists, otherwise return current child
+        deeper_child || direct_child
+      end
+    end
+  end
+end

data/lib/igata/extractors/method_names.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Igata
+  module Extractors
+    class MethodNames
+      def self.extract(class_node)
+        new(class_node).extract
+      end
+
+      def initialize(class_node)
+        @class_node = class_node
+      end
+
+      def extract
+        class_body = @class_node.body.body
+        # For empty classes, class_body is BeginNode which doesn't have filter_map
+        return [] unless class_body.respond_to?(:filter_map)
+
+        class_body.filter_map do |node|
+          next unless node.is_a?(Kanayago::DefinitionNode)
+
+          # Extract branch information for each method
+          branches = BranchAnalyzer.extract(node)
+
+          # Extract comparison information for each method
+          comparisons = ComparisonAnalyzer.extract(node)
+
+          Values::MethodInfo.new(name: node.mid.to_s, branches: branches, comparisons: comparisons)
+        end
+      end
+    end
+  end
+end

data/lib/igata/formatters/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../error"
+
+class Igata
+  module Formatters
+    class MethodNotOverriddenError < Igata::Error; end
+
+    class Base
+      def initialize(constant_info, method_infos)
+        @constant_info = constant_info
+        @method_infos = method_infos
+      end
+
+      def generate
+        raise MethodNotOverriddenError, "#{self.class}#generate must be implemented"
+      end
+
+      private
+
+      def template_path(name)
+        File.join(templates_dir, "#{name}.erb")
+      end
+
+      def templates_dir
+        raise MethodNotOverriddenError, "#{self.class}#templates_dir must be implemented"
+      end
+
+      def render_template(template_file, binding_context)
+        template_content = File.read(template_file)
+        ERB.new(template_content, trim_mode: "<>").result(binding_context)
+      end
+    end
+  end
+end

data/lib/igata/formatters/minitest.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Igata
+  module Formatters
+    class Minitest < Base
+      def generate
+        class_name = @constant_info.path
+        methods = generate_methods
+
+        template = ERB.new(File.read(template_path("class")), trim_mode: "<>")
+        template.result(binding)
+      end
+
+      private
+
+      def templates_dir
+        File.join(__dir__, "templates", "minitest")
+      end
+
+      def generate_methods
+        @method_infos.map do |method_info|
+          method_name = method_info.name
+          branches = method_info.branches
+          comparisons = method_info.comparisons
+          ERB.new(File.read(template_path("method")), trim_mode: "<>").result(binding)
+        end
+      end
+    end
+  end
+end

data/lib/igata/formatters/rspec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Igata
+  module Formatters
+    class RSpec < Base
+      def generate
+        class_name = @constant_info.path
+        methods = generate_methods
+
+        template = ERB.new(File.read(template_path("class")), trim_mode: "<>")
+        template.result(binding)
+      end
+
+      private
+
+      def templates_dir
+        File.join(__dir__, "templates", "rspec")
+      end
+
+      def generate_methods
+        @method_infos.map do |method_info|
+          method_name = method_info.name
+          branches = method_info.branches
+          comparisons = method_info.comparisons
+          ERB.new(File.read(template_path("method")), trim_mode: "<>").result(binding)
+        end
+      end
+    end
+  end
+end

data/lib/igata/formatters/templates/minitest/class.erb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class <%= class_name %>Test < Minitest::Test
+<% methods.each_with_index do |method, index| %>
+<%= method %>
+<% if index < methods.length - 1 %>
+
+<% end %>
+<% end %>
+end

data/lib/igata/formatters/templates/minitest/method.erb

@@ -0,0 +1,9 @@
+  def test_<%= method_name %>
+<% if branches && !branches.empty? %>
+    # Branches: <%= branches.map { |b| b.condition ? "#{b.type} (#{b.condition})" : b.type.to_s }.join(", ") %>
+<% end %>
+<% if comparisons && !comparisons.empty? %>
+    # Comparisons: <%= comparisons.map { |c| "#{c.operator} (#{c.context})" }.join(", ") %>
+<% end %>
+    skip "Not implemented yet"
+  end

data/lib/igata/formatters/templates/rspec/class.erb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe <%= class_name %> do
+<% methods.each_with_index do |method, index| %>
+<%= method %>
+<% if index < methods.length - 1 %>
+
+<% end %>
+<% end %>
+end

data/lib/igata/formatters/templates/rspec/method.erb

@@ -0,0 +1,11 @@
+  describe "#<%= method_name %>" do
+<% if branches && !branches.empty? %>
+    # Branches: <%= branches.map { |b| b.condition ? "#{b.type} (#{b.condition})" : b.type.to_s }.join(", ") %>
+<% end %>
+<% if comparisons && !comparisons.empty? %>
+    # Comparisons: <%= comparisons.map { |c| "#{c.operator} (#{c.context})" }.join(", ") %>
+<% end %>
+    it "works correctly" do
+      pending "Not implemented yet"
+    end
+  end

data/lib/igata/values.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Igata
+  module Values
+    ConstantPath = Data.define(
+      :path,          # "User::Profile"
+      :nested,        # true/false
+      :compact        # true/false (compact nested like "class User::Profile")
+    )
+
+    MethodInfo = Data.define(
+      :name,          # "initialize"
+      :branches,      # Array of BranchInfo (default: [])
+      :comparisons    # Array of ComparisonInfo (default: [])
+    ) do
+      def initialize(name:, branches: [], comparisons: [])
+        super(name: name, branches: branches, comparisons: comparisons)
+      end
+    end
+
+    BranchInfo = Data.define(
+      :type,          # :if, :unless, :case, :ternary
+      :condition      # condition expression as string
+    )
+
+    ComparisonInfo = Data.define(
+      :operator,      # :>=, :<=, :>, :<, :==, :!=
+      :left,          # left side expression
+      :right,         # right side expression
+      :context        # full expression as string (e.g., "age >= 18")
+    )
+  end
+end

data/lib/igata/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Igata
-  VERSION = "0.1.0"
+class Igata
+  VERSION = "0.2.0"
 end

data/lib/igata.rb

@@ -1,8 +1,73 @@
 # frozen_string_literal: true
 
+require "kanayago"
+require "erb"
+
 require_relative "igata/version"
+require_relative "igata/error"
+require_relative "igata/values"
+require_relative "igata/extractors/constant_path"
+require_relative "igata/extractors/method_names"
+require_relative "igata/extractors/branch_analyzer"
+require_relative "igata/extractors/comparison_analyzer"
+require_relative "igata/formatters/minitest"
+require_relative "igata/formatters/rspec"
+
+class Igata
+  def initialize(source, formatter: :minitest)
+    @source = source
+    @ast = Kanayago.parse(source)
+    @formatter = formatter
+  end
+
+  def generate
+    constant_info = Extractors::ConstantPath.extract(@ast)
+    target_node = find_target_class_node(constant_info)
+    method_infos = Extractors::MethodNames.extract(target_node)
+
+    formatter_class = resolve_formatter(@formatter)
+    formatter_class.new(constant_info, method_infos).generate
+  end
+
+  private
+
+  def resolve_formatter(formatter)
+    case formatter
+    when :minitest
+      Formatters::Minitest
+    when :rspec
+      Formatters::RSpec
+    when Class
+      formatter
+    else
+      raise Error, "Unknown formatter: #{formatter}"
+    end
+  end
+
+  def find_target_class_node(constant_info)
+    if constant_info.nested
+      # When nested is true, recursively find the deepest (innermost) class
+      # - class User; class Profile; end; end
+      # - class App::User; class Profile; end; end (mixed pattern)
+      # - class App::Model; class Admin::User; class Profile; end; end; end (3+ levels)
+      find_deepest_class_node(@ast.body)
+    else
+      # When nested is false, @ast.body itself is the target
+      # - class User
+      # - class User::Profile
+      @ast.body
+    end
+  end
+
+  def find_deepest_class_node(parent_node)
+    # Find direct child class/module under the current node
+    direct_child = parent_node.body.body.find { |node| node.is_a?(Kanayago::ClassNode) || node.is_a?(Kanayago::ModuleNode) }
+    return nil unless direct_child
+
+    # Check if there's deeper nesting in the child node
+    deeper_child = find_deepest_class_node(direct_child)
 
-module Igata
-  class Error < StandardError; end
-  # Your code goes here...
+    # Return deeper nesting if exists, otherwise return current child
+    deeper_child || direct_child
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: igata
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - S-H-GAMELINKS
@@ -17,12 +17,27 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".ruby-version"
 - CHANGELOG.md
 - LICENSE.txt
+- QUICKSTART.md
 - README.md
 - Rakefile
 - exe/igata
 - lib/igata.rb
+- lib/igata/error.rb
+- lib/igata/extractors/branch_analyzer.rb
+- lib/igata/extractors/comparison_analyzer.rb
+- lib/igata/extractors/constant_path.rb
+- lib/igata/extractors/method_names.rb
+- lib/igata/formatters/base.rb
+- lib/igata/formatters/minitest.rb
+- lib/igata/formatters/rspec.rb
+- lib/igata/formatters/templates/minitest/class.erb
+- lib/igata/formatters/templates/minitest/method.erb
+- lib/igata/formatters/templates/rspec/class.erb
+- lib/igata/formatters/templates/rspec/method.erb
+- lib/igata/values.rb
 - lib/igata/version.rb
 - sig/igata.rbs
 homepage: https://github.com/S-H-GAMELINKS/igata
@@ -32,6 +47,7 @@ metadata:
   homepage_uri: https://github.com/S-H-GAMELINKS/igata
   source_code_uri: https://github.com/S-H-GAMELINKS/igata
   changelog_uri: https://github.com/S-H-GAMELINKS/igata/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -46,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.8.0.dev
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Generate test code from AST node produces by Ruby's Parser
 test_files: []