igata 0.2.1 → 0.3.0

data/lib/igata/formatters/base.rb

@@ -13,7 +13,11 @@ class Igata
       end
 
       def generate
-        raise MethodNotOverriddenError, "#{self.class}#generate must be implemented"
+        class_name = @constant_info.path
+        methods = generate_methods
+
+        template = ERB.new(File.read(template_path("class")), trim_mode: "<>")
+        template.result(binding)
       end
 
       private
@@ -30,6 +34,18 @@ class Igata
         template_content = File.read(template_file)
         ERB.new(template_content, trim_mode: "<>").result(binding_context)
       end
+
+      def generate_methods
+        @method_infos.map do |method_info|
+          method_name = method_info.name
+          branches = method_info.branches
+          comparisons = method_info.comparisons
+          exceptions = method_info.exceptions
+          boundary_values = method_info.boundary_values
+          arguments = method_info.arguments
+          ERB.new(File.read(template_path("method")), trim_mode: "<>").result(binding)
+        end
+      end
     end
   end
 end

data/lib/igata/formatters/minitest.rb

@@ -5,28 +5,11 @@ 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/minitest_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Igata
+  module Formatters
+    class MinitestSpec < Base
+      private
+
+      def templates_dir
+        File.join(__dir__, "templates", "minitest_spec")
+      end
+    end
+  end
+end

data/lib/igata/formatters/rspec.rb

@@ -5,28 +5,11 @@ 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/method.erb

@@ -1,9 +1,45 @@
   def test_<%= method_name %>
+<% if arguments && !arguments.args.empty? %>
+    # Arguments:
+<%   arguments.args.each do |arg| %>
+<%     if arg.type == :required %>
+    #   - <%= arg.name %> (required)
+<%     elsif arg.type == :optional %>
+    #   - <%= arg.name %> (optional, default: <%= arg.default %>)
+<%     elsif arg.type == :keyword %>
+    #   - <%= arg.name %>: (keyword, default: <%= arg.default %>)
+<%     elsif arg.type == :required_keyword %>
+    #   - <%= arg.name %>: (required keyword)
+<%     elsif arg.type == :rest %>
+    #   - *<%= arg.name %> (variable length)
+<%     elsif arg.type == :keyrest %>
+    #   - **<%= arg.name %> (keyword variable length)
+<%     elsif arg.type == :block %>
+    #   - &<%= arg.name %> (block)
+<%     end %>
+<%   end %>
+<% end %>
 <% 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 %>
+<% if boundary_values && !boundary_values.empty? %>
+    # Boundary value suggestions:
+<%   boundary_values.each do |bv| %>
+    #   <%= bv.comparison.context %>: [<%= bv.description %>]
+<%   end %>
+<% end %>
+<% if exceptions && !exceptions.empty? %>
+<%   raised = exceptions.select { |e| e.type == :raise } %>
+<%   rescued = exceptions.select { |e| e.type == :rescue } %>
+<%   if !raised.empty? %>
+    # Exceptions raised: <%= raised.map { |e| e.message ? "#{e.exception_class} (\"#{e.message}\")" : e.exception_class }.join(", ") %>
+<%   end %>
+<%   if !rescued.empty? %>
+    # Exceptions rescued: <%= rescued.map { |e| e.exception_class }.uniq.join(", ") %>
+<%   end %>
 <% end %>
     skip "Not implemented yet"
   end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "minitest/spec"
+
+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/minitest_spec/method.erb

@@ -0,0 +1,47 @@
+  describe "#<%= method_name %>" do
+<% if arguments && !arguments.args.empty? %>
+    # Arguments:
+<%   arguments.args.each do |arg| %>
+<%     if arg.type == :required %>
+    #   - <%= arg.name %> (required)
+<%     elsif arg.type == :optional %>
+    #   - <%= arg.name %> (optional, default: <%= arg.default %>)
+<%     elsif arg.type == :keyword %>
+    #   - <%= arg.name %>: (keyword, default: <%= arg.default %>)
+<%     elsif arg.type == :required_keyword %>
+    #   - <%= arg.name %>: (required keyword)
+<%     elsif arg.type == :rest %>
+    #   - *<%= arg.name %> (variable length)
+<%     elsif arg.type == :keyrest %>
+    #   - **<%= arg.name %> (keyword variable length)
+<%     elsif arg.type == :block %>
+    #   - &<%= arg.name %> (block)
+<%     end %>
+<%   end %>
+<% end %>
+<% 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 %>
+<% if boundary_values && !boundary_values.empty? %>
+    # Boundary value suggestions:
+<%   boundary_values.each do |bv| %>
+    #   <%= bv.comparison.context %>: [<%= bv.description %>]
+<%   end %>
+<% end %>
+<% if exceptions && !exceptions.empty? %>
+<%   raised = exceptions.select { |e| e.type == :raise } %>
+<%   rescued = exceptions.select { |e| e.type == :rescue } %>
+<%   if !raised.empty? %>
+    # Exceptions raised: <%= raised.map { |e| e.message ? "#{e.exception_class} (\"#{e.message}\")" : e.exception_class }.join(", ") %>
+<%   end %>
+<%   if !rescued.empty? %>
+    # Exceptions rescued: <%= rescued.map { |e| e.exception_class }.uniq.join(", ") %>
+<%   end %>
+<% end %>
+    it "works correctly" do
+      skip "Not implemented yet"
+    end
+  end

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

@@ -1,9 +1,45 @@
   describe "#<%= method_name %>" do
+<% if arguments && !arguments.args.empty? %>
+    # Arguments:
+<%   arguments.args.each do |arg| %>
+<%     if arg.type == :required %>
+    #   - <%= arg.name %> (required)
+<%     elsif arg.type == :optional %>
+    #   - <%= arg.name %> (optional, default: <%= arg.default %>)
+<%     elsif arg.type == :keyword %>
+    #   - <%= arg.name %>: (keyword, default: <%= arg.default %>)
+<%     elsif arg.type == :required_keyword %>
+    #   - <%= arg.name %>: (required keyword)
+<%     elsif arg.type == :rest %>
+    #   - *<%= arg.name %> (variable length)
+<%     elsif arg.type == :keyrest %>
+    #   - **<%= arg.name %> (keyword variable length)
+<%     elsif arg.type == :block %>
+    #   - &<%= arg.name %> (block)
+<%     end %>
+<%   end %>
+<% end %>
 <% 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 %>
+<% if boundary_values && !boundary_values.empty? %>
+    # Boundary value suggestions:
+<%   boundary_values.each do |bv| %>
+    #   <%= bv.comparison.context %>: [<%= bv.description %>]
+<%   end %>
+<% end %>
+<% if exceptions && !exceptions.empty? %>
+<%   raised = exceptions.select { |e| e.type == :raise } %>
+<%   rescued = exceptions.select { |e| e.type == :rescue } %>
+<%   if !raised.empty? %>
+    # Exceptions raised: <%= raised.map { |e| e.message ? "#{e.exception_class} (\"#{e.message}\")" : e.exception_class }.join(", ") %>
+<%   end %>
+<%   if !rescued.empty? %>
+    # Exceptions rescued: <%= rescued.map { |e| e.exception_class }.uniq.join(", ") %>
+<%   end %>
 <% end %>
     it "works correctly" do
       pending "Not implemented yet"

data/lib/igata/values.rb

@@ -9,12 +9,15 @@ class Igata
     )
 
     MethodInfo = Data.define(
-      :name,          # "initialize"
-      :branches,      # Array of BranchInfo (default: [])
-      :comparisons    # Array of ComparisonInfo (default: [])
+      :name,            # "initialize"
+      :branches,        # Array of BranchInfo (default: [])
+      :comparisons,     # Array of ComparisonInfo (default: [])
+      :exceptions,      # Array of ExceptionInfo (default: [])
+      :boundary_values, # Array of BoundaryValueInfo (default: [])
+      :arguments        # ArgumentInfo (default: nil)
     ) do
-      def initialize(name:, branches: [], comparisons: [])
-        super(name: name, branches: branches, comparisons: comparisons)
+      def initialize(name:, branches: [], comparisons: [], exceptions: [], boundary_values: [], arguments: nil)
+        super
       end
     end
 
@@ -29,5 +32,32 @@ class Igata
       :right,         # right side expression
       :context        # full expression as string (e.g., "age >= 18")
     )
+
+    ExceptionInfo = Data.define(
+      :type,            # :raise or :rescue
+      :exception_class, # exception class name (e.g., "ArgumentError", "StandardError")
+      :message,         # message for raise (e.g., "Invalid amount")
+      :context          # full expression as string
+    )
+
+    BoundaryValueInfo = Data.define(
+      :comparison,      # ComparisonInfo object
+      :test_values,     # Array of test values (e.g., [17, 18, 19])
+      :description      # description string (e.g., "Boundary: 17 (below), 18 (boundary), 19 (above)")
+    )
+
+    ArgumentInfo = Data.define(
+      :args # Array of ArgDetail
+    )
+
+    ArgDetail = Data.define(
+      :name,     # "name", "age", "verified", "args", etc.
+      :type,     # :required, :optional, :keyword, :rest, :keyrest, :block
+      :default   # default value (for optional/keyword arguments)
+    ) do
+      def initialize(name:, type:, default: nil)
+        super
+      end
+    end
   end
 end

data/lib/igata/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Igata
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/igata.rb

@@ -10,58 +10,98 @@ 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/extractors/exception_analyzer"
+require_relative "igata/extractors/boundary_value_generator"
+require_relative "igata/extractors/argument_extractor"
 require_relative "igata/formatters/minitest"
 require_relative "igata/formatters/rspec"
+require_relative "igata/formatters/minitest_spec"
 
 class Igata
   def initialize(source, formatter: :minitest)
     @source = source
-    @ast = Kanayago.parse(source)
+    parse_result = Kanayago.parse(source)
+    @ast = parse_result.ast
+    @script_lines = parse_result.script_lines
     @formatter = formatter
   end
 
   def generate
     constant_info = Extractors::ConstantPath.extract(@ast)
+    return "" unless constant_info
+
     target_node = find_target_class_node(constant_info)
     method_infos = Extractors::MethodNames.extract(target_node)
 
+    # Add argument information to method_infos
+    method_infos = method_infos.map do |method_info|
+      arg_info = Extractors::ArgumentExtractor.extract(method_info, @script_lines)
+      method_info.with(arguments: arg_info)
+    end
+
     formatter_class = resolve_formatter(@formatter)
     formatter_class.new(constant_info, method_infos).generate
   end
 
   private
 
+  # rubocop:disable Metrics/MethodLength
   def resolve_formatter(formatter)
     case formatter
     when :minitest
       Formatters::Minitest
     when :rspec
       Formatters::RSpec
+    when :minitest_spec
+      Formatters::MinitestSpec
     when Class
       formatter
     else
       raise Error, "Unknown formatter: #{formatter}"
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
   def find_target_class_node(constant_info)
+    # First, find the actual ClassNode if @ast.body is a BlockNode
+    root_class_node = find_root_class_node(@ast.body)
+
     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)
+      find_deepest_class_node(root_class_node)
     else
-      # When nested is false, @ast.body itself is the target
+      # When nested is false, root_class_node itself is the target
       # - class User
       # - class User::Profile
-      @ast.body
+      root_class_node
+    end
+  end
+
+  # rubocop:disable Lint/DuplicateBranch
+  def find_root_class_node(node)
+    if node.is_a?(Kanayago::ClassNode) || node.is_a?(Kanayago::ModuleNode)
+      node
+    elsif node.is_a?(Kanayago::BlockNode) && node.respond_to?(:find)
+      node.find { |n| n.is_a?(Kanayago::ClassNode) || n.is_a?(Kanayago::ModuleNode) }
+    else
+      node
     end
   end
+  # rubocop:enable Lint/DuplicateBranch
 
-  def find_deepest_class_node(parent_node)
+  def find_deepest_class_node(parent_node) # rubocop:disable Metrics/CyclomaticComplexity
     # 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 parent_node.respond_to?(:body)
+    return nil unless parent_node.body.respond_to?(:body)
+
+    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)
+
+    direct_child = class_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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: igata
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - S-H-GAMELINKS
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.6.1
 description: Generate test code from AST node produces by Ruby's Parser
 email:
 - gamelinks007@gmail.com
@@ -37,18 +37,25 @@ files:
 - QUICKSTART.md
 - README.md
 - Rakefile
+- USAGE.md
 - exe/igata
 - lib/igata.rb
 - lib/igata/error.rb
+- lib/igata/extractors/argument_extractor.rb
+- lib/igata/extractors/boundary_value_generator.rb
 - lib/igata/extractors/branch_analyzer.rb
 - lib/igata/extractors/comparison_analyzer.rb
 - lib/igata/extractors/constant_path.rb
+- lib/igata/extractors/exception_analyzer.rb
 - lib/igata/extractors/method_names.rb
 - lib/igata/formatters/base.rb
 - lib/igata/formatters/minitest.rb
+- lib/igata/formatters/minitest_spec.rb
 - lib/igata/formatters/rspec.rb
 - lib/igata/formatters/templates/minitest/class.erb
 - lib/igata/formatters/templates/minitest/method.erb
+- lib/igata/formatters/templates/minitest_spec/class.erb
+- lib/igata/formatters/templates/minitest_spec/method.erb
 - lib/igata/formatters/templates/rspec/class.erb
 - lib/igata/formatters/templates/rspec/method.erb
 - lib/igata/values.rb