igata 0.2.1 → 0.3.0

data/lib/igata/extractors/boundary_value_generator.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+class Igata
+  module Extractors
+    # rubocop:disable Metrics/ClassLength, Lint/DuplicateBranch, Naming/PredicateMethod
+    class BoundaryValueGenerator
+      def self.extract(comparisons)
+        new(comparisons).extract
+      end
+
+      def initialize(comparisons)
+        @comparisons = comparisons
+      end
+
+      def extract
+        @comparisons.map do |comparison|
+          generate_boundary_values(comparison)
+        end.compact
+      end
+
+      private
+
+      def generate_boundary_values(comparison) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        right_value = comparison.right
+
+        # Determine value type and generate appropriate boundary values
+        test_values, description = if numeric?(right_value)
+                                     generate_numeric_boundaries(comparison)
+                                   elsif string_literal?(right_value)
+                                     generate_string_boundaries(comparison)
+                                   elsif nil_value?(right_value)
+                                     generate_nil_boundaries(comparison)
+                                   elsif boolean_value?(right_value)
+                                     generate_boolean_boundaries(comparison)
+                                   elsif symbol_value?(right_value)
+                                     generate_symbol_boundaries(comparison)
+                                   else
+                                     # Variable or method call - skip boundary value generation
+                                     return nil
+                                   end
+
+        return nil if test_values.nil? || test_values.empty?
+
+        Values::BoundaryValueInfo.new(
+          comparison: comparison,
+          test_values: test_values,
+          description: description
+        )
+      end
+
+      # Numeric boundary values
+      # rubocop:disable Metrics/MethodLength
+      def generate_numeric_boundaries(comparison)
+        value = parse_numeric(comparison.right)
+        operator = comparison.operator
+
+        test_values = case operator
+                      when :>=
+                        [value - 1, value, value + 1]
+                      when :>
+                        [value, value + 1]
+                      when :<=
+                        [value - 1, value, value + 1]
+                      when :<
+                        [value - 1, value]
+                      when :==
+                        [value - 1, value, value + 1]
+                      when :!=
+                        [value]
+                      else
+                        []
+                      end
+
+        description = build_numeric_description(operator, value, test_values)
+        [test_values, description]
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # String literal boundary values
+      # rubocop:disable Metrics/MethodLength
+      def generate_string_boundaries(comparison)
+        str_value = parse_string(comparison.right)
+        operator = comparison.operator
+
+        test_values = case operator
+                      when :>=, :>
+                        # For string comparison: previous, same, next
+                        [decrement_string(str_value), str_value, increment_string(str_value)]
+                      when :<=, :<
+                        [decrement_string(str_value), str_value, increment_string(str_value)]
+                      when :==
+                        [str_value, "different_string"]
+                      when :!=
+                        [str_value, "different_string"]
+                      else
+                        []
+                      end
+
+        description = build_string_description(operator, str_value, test_values)
+        [test_values, description]
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Nil boundary values
+      # rubocop:disable Metrics/MethodLength
+      def generate_nil_boundaries(comparison)
+        operator = comparison.operator
+
+        test_values = case operator
+                      when :==
+                        [nil, "some_value"]
+                      when :!=
+                        [nil, "some_value"]
+                      else
+                        []
+                      end
+
+        description = "nil check: test with #{test_values.inspect}"
+        [test_values, description]
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Boolean boundary values
+      def generate_boolean_boundaries(comparison)
+        operator = comparison.operator
+
+        test_values = case operator
+                      when :==, :!=
+                        [true, false]
+                      else
+                        []
+                      end
+
+        description = "boolean check: test with #{test_values.inspect}"
+        [test_values, description]
+      end
+
+      # Symbol boundary values
+      # rubocop:disable Metrics/MethodLength
+      def generate_symbol_boundaries(comparison)
+        sym_value = parse_symbol(comparison.right)
+        operator = comparison.operator
+
+        test_values = case operator
+                      when :==
+                        [sym_value, ":other_symbol"]
+                      when :!=
+                        [sym_value, ":other_symbol"]
+                      else
+                        []
+                      end
+
+        description = "symbol check: test with #{test_values.inspect}"
+        [test_values, description]
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Type detection methods
+      def numeric?(str)
+        # Check if string is a numeric literal (integer or float)
+        return false if str.nil? || str.empty?
+
+        # Remove quotes if present (shouldn't be for numbers but just in case)
+        clean_str = str.gsub(/["']/, "")
+        # Match integer or float
+        clean_str.match?(/\A-?\d+(\.\d+)?\z/)
+      end
+
+      def string_literal?(str)
+        # Check if string is a string literal (starts and ends with quotes)
+        return false if str.nil? || str.empty?
+
+        str.match?(/\A["'].*["']\z/)
+      end
+
+      def nil_value?(str)
+        str == "nil"
+      end
+
+      def boolean_value?(str)
+        %w[true false].include?(str)
+      end
+
+      def symbol_value?(str)
+        return false if str.nil? || str.empty?
+
+        str.start_with?(":")
+      end
+
+      # Parsing methods
+      def parse_numeric(str)
+        clean_str = str.gsub(/["']/, "")
+        clean_str.include?(".") ? clean_str.to_f : clean_str.to_i
+      end
+
+      def parse_string(str)
+        # Remove surrounding quotes
+        str.gsub(/\A["']|["']\z/, "")
+      end
+
+      def parse_boolean(str)
+        str == "true"
+      end
+
+      def parse_symbol(str)
+        str # Keep as is with colon
+      end
+
+      # String manipulation for boundary values
+      # rubocop:disable Metrics/MethodLength
+      def increment_string(str)
+        # Simple increment: "A" -> "B", "Z" -> "AA"
+        if str.empty?
+          "A"
+        elsif str == "Z"
+          "AA"
+        else
+          last_char = str[-1]
+          if last_char == "z"
+            "#{str[0..-2]}aa"
+          else
+            str[0..-2] + last_char.next
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def decrement_string(str)
+        # Simple decrement: "B" -> "A", "A" -> ""
+        return "" if str.empty?
+        return "" if str == "A"
+
+        last_char = str[-1]
+        if last_char == "a"
+          str[0..-2]
+        else
+          str[0..-2] + (last_char.ord - 1).chr
+        end
+      end
+
+      # Description builders
+      def build_numeric_description(operator, value, test_values) # rubocop:disable Metrics/MethodLength
+        case operator
+        when :>=
+          "#{value - 1} (below), #{value} (boundary), #{value + 1} (above)"
+        when :>
+          "#{value} (boundary), #{value + 1} (above)"
+        when :<=
+          "#{value - 1} (below), #{value} (boundary), #{value + 1} (above)"
+        when :<
+          "#{value - 1} (below), #{value} (boundary)"
+        when :==
+          "#{value - 1} (not equal), #{value} (equal), #{value + 1} (not equal)"
+        when :!=
+          "#{value} (equal)"
+        else
+          test_values.inspect
+        end
+      end
+
+      def build_string_description(operator, str_value, test_values)
+        case operator
+        when :>=, :>, :<=, :<
+          "string comparison: #{test_values.inspect}"
+        when :==
+          "equal: #{str_value.inspect}, not equal: different string"
+        when :!=
+          "equal: #{str_value.inspect}, not equal: different string"
+        else
+          test_values.inspect
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength, Lint/DuplicateBranch, Naming/PredicateMethod
+  end
+end

data/lib/igata/extractors/branch_analyzer.rb

@@ -2,6 +2,7 @@
 
 class Igata
   module Extractors
+    # rubocop:disable Metrics/ClassLength, Lint/DuplicateBranch
     class BranchAnalyzer
       def self.extract(method_node)
         new(method_node).extract
@@ -54,6 +55,22 @@ class Igata
           # Traverse when branches
           traverse_node(node.body, branches) if node.respond_to?(:body)
           traverse_node(node.else, branches) if node.respond_to?(:else)
+        # Handle RescueNode (container node for rescue clauses)
+        elsif node.is_a?(Kanayago::RescueNode)
+          # Traverse head (main body before rescue)
+          if node.respond_to?(:head) && node.head
+            if node.head.is_a?(Array)
+              node.head.each { |child| traverse_node(child, branches) }
+            else
+              traverse_node(node.head, branches)
+            end
+          end
+          traverse_node(node.resq, branches) if node.respond_to?(:resq)
+          traverse_node(node.else, branches) if node.respond_to?(:else)
+        # Handle RescueBodyNode
+        elsif node.is_a?(Kanayago::RescueBodyNode)
+          traverse_node(node.body, branches) if node.respond_to?(:body)
+          traverse_node(node.next, branches) if node.respond_to?(:next)
         # Handle ScopeNode (container node)
         elsif node.is_a?(Kanayago::ScopeNode)
           traverse_node(node.body, branches) if node.respond_to?(:body)
@@ -92,7 +109,7 @@ class Igata
         elsif node.is_a?(Kanayago::IntegerNode)
           node.val.to_s
         elsif node.is_a?(Kanayago::StringNode)
-          "\"#{node.val}\""
+          "\"#{node.ptr}\""
         elsif node.is_a?(Kanayago::SymbolNode)
           ":#{node.ptr}"
         elsif node.is_a?(Kanayago::OperatorCallNode)
@@ -121,5 +138,6 @@ class Igata
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength, Lint/DuplicateBranch
   end
 end

data/lib/igata/extractors/comparison_analyzer.rb

@@ -2,6 +2,7 @@
 
 class Igata
   module Extractors
+    # rubocop:disable Lint/DuplicateBranch
     class ComparisonAnalyzer
       COMPARISON_OPERATORS = %i[>= <= > < == !=].freeze
 
@@ -55,6 +56,22 @@ class Igata
         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 RescueNode (container node for rescue clauses)
+        elsif node.is_a?(Kanayago::RescueNode)
+          # Traverse head (main body before rescue)
+          if node.respond_to?(:head) && node.head
+            if node.head.is_a?(Array)
+              node.head.each { |child| traverse_node(child, comparisons) }
+            else
+              traverse_node(node.head, comparisons)
+            end
+          end
+          traverse_node(node.resq, comparisons) if node.respond_to?(:resq)
+          traverse_node(node.else, comparisons) if node.respond_to?(:else)
+        # Handle RescueBodyNode
+        elsif node.is_a?(Kanayago::RescueBodyNode)
+          traverse_node(node.body, comparisons) if node.respond_to?(:body)
+          traverse_node(node.next, comparisons) if node.respond_to?(:next)
         # Handle ScopeNode (container node)
         elsif node.is_a?(Kanayago::ScopeNode)
           traverse_node(node.body, comparisons) if node.respond_to?(:body)
@@ -78,7 +95,7 @@ class Igata
         elsif node.is_a?(Kanayago::IntegerNode)
           node.val.to_s
         elsif node.is_a?(Kanayago::StringNode)
-          "\"#{node.val}\""
+          "\"#{node.ptr}\""
         elsif node.is_a?(Kanayago::SymbolNode)
           ":#{node.ptr}"
         elsif node.respond_to?(:mid)
@@ -97,5 +114,6 @@ class Igata
         "#{left} #{operator} #{right}"
       end
     end
+    # rubocop:enable Lint/DuplicateBranch
   end
 end

data/lib/igata/extractors/constant_path.rb

@@ -2,6 +2,7 @@
 
 class Igata
   module Extractors
+    # rubocop:disable Metrics/ClassLength
     class ConstantPath
       def self.extract(ast)
         new(ast).extract
@@ -9,15 +10,28 @@ class Igata
 
       def initialize(ast)
         @ast = ast
+        # If ast.body is BlockNode, find the ClassNode inside it
+        @class_node = find_class_node(ast.body)
       end
 
-      def extract # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      def find_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) }
+        end
+      end
+
+      def extract # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        return nil unless @class_node
+        return nil unless @class_node.respond_to?(:cpath) && @class_node.cpath
+
         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)
+          nested_path = build_nested_path(@class_node)
           path = "#{compact_path}::#{nested_path}"
 
           Values::ConstantPath.new(
@@ -37,8 +51,8 @@ class Igata
           # 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)
+          namespace = @class_node.cpath.mid.to_s
+          nested_path = build_nested_path(@class_node)
           path = "#{namespace}::#{nested_path}"
 
           Values::ConstantPath.new(
@@ -49,7 +63,7 @@ class Igata
         else
           # Simple pattern: class User
           Values::ConstantPath.new(
-            path: @ast.body.cpath.mid.to_s,
+            path: @class_node.cpath.mid.to_s,
             nested: false,
             compact: false
           )
@@ -60,12 +74,14 @@ class Igata
 
       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?
+        return false unless @class_node.respond_to?(:cpath)
+
+        @class_node.cpath.is_a?(Kanayago::Colon2Node) && !@class_node.cpath.head.nil?
       end
 
       def extract_compact_nested_path
         # Recursively traverse cpath to build complete path
-        build_constant_path(@ast.body.cpath)
+        build_constant_path(@class_node.cpath)
       end
 
       def build_constant_path(node) # rubocop:disable Metrics/MethodLength
@@ -87,7 +103,10 @@ class Igata
       end
 
       def nested?
-        class_body = @ast.body.body.body
+        return false unless @class_node.respond_to?(:body)
+        return false unless @class_node.body.respond_to?(:body)
+
+        class_body = @class_node.body.body
         # For empty classes, class_body is BeginNode which doesn't have any?
         return false unless class_body.respond_to?(:any?)
 
@@ -123,7 +142,7 @@ class Igata
 
       def find_nested_constant_node
         # Recursively find the deepest (innermost) class/module definition
-        find_deepest_nested_constant_node(@ast.body)
+        find_deepest_nested_constant_node(@class_node)
       end
 
       def find_deepest_nested_constant_node(parent_node)
@@ -138,5 +157,6 @@ class Igata
         deeper_child || direct_child
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/igata/extractors/exception_analyzer.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+class Igata
+  module Extractors
+    # rubocop:disable Metrics/ClassLength, Lint/DuplicateBranch
+    class ExceptionAnalyzer
+      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)
+
+        exceptions = []
+        # DefinitionNode has a defn field that contains ScopeNode
+        defn_node = @method_node.defn
+        traverse_node(defn_node, exceptions) if defn_node
+        exceptions
+      end
+
+      private
+
+      def traverse_node(node, exceptions) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        return unless node
+
+        # Handle raise statement (FunctionCallNode with mid == :raise)
+        if node.is_a?(Kanayago::FunctionCallNode) && node.respond_to?(:mid) && node.mid.to_s == "raise"
+          exceptions << extract_raise_info(node)
+        # Handle rescue clause
+        elsif node.is_a?(Kanayago::RescueNode)
+          extract_rescue_info(node, exceptions)
+          # Continue traversing head (main body before rescue), rescue clause, and else
+          if node.respond_to?(:head) && node.head
+            if node.head.is_a?(Array)
+              node.head.each { |child| traverse_node(child, exceptions) }
+            else
+              traverse_node(node.head, exceptions)
+            end
+          end
+          traverse_node(node.resq, exceptions) if node.respond_to?(:resq)
+          traverse_node(node.else, exceptions) if node.respond_to?(:else)
+        # Handle RescueBody node (contains exception class list)
+        elsif node.is_a?(Kanayago::RescueBodyNode)
+          extract_rescue_body_info(node, exceptions)
+          traverse_node(node.body, exceptions) if node.respond_to?(:body)
+          traverse_node(node.next, exceptions) if node.respond_to?(:next)
+        # Handle IfStatementNode (raise might be inside if)
+        elsif node.is_a?(Kanayago::IfStatementNode)
+          traverse_node(node.body, exceptions) if node.respond_to?(:body)
+          traverse_node(node.elsif, exceptions) if node.respond_to?(:elsif)
+          traverse_node(node.else, exceptions) if node.respond_to?(:else)
+        # Handle UnlessStatementNode
+        elsif node.is_a?(Kanayago::UnlessStatementNode)
+          traverse_node(node.body, exceptions) if node.respond_to?(:body)
+          traverse_node(node.else, exceptions) if node.respond_to?(:else)
+        # Handle CaseNode
+        elsif node.is_a?(Kanayago::CaseNode)
+          traverse_node(node.body, exceptions) if node.respond_to?(:body)
+          traverse_node(node.else, exceptions) if node.respond_to?(:else)
+        # Handle ScopeNode (container node)
+        elsif node.is_a?(Kanayago::ScopeNode)
+          traverse_node(node.body, exceptions) if node.respond_to?(:body)
+        # Handle BlockNode (container for multiple statements)
+        elsif node.is_a?(Kanayago::BlockNode)
+          node.each { |child| traverse_node(child, exceptions) } 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, exceptions) }
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockNesting
+      def extract_raise_info(call_node)
+        # Extract exception class and message from raise statement
+        # raise ArgumentError, "message" => args is ListNode with val array
+        exception_class = "StandardError" # default
+        message = nil
+
+        if call_node.respond_to?(:args) && call_node.args
+          args_node = call_node.args
+
+          # ListNode contains exception class and message in val array
+          if args_node.is_a?(Kanayago::ListNode) && args_node.respond_to?(:val)
+            args_array = args_node.val
+
+            if args_array.is_a?(Array)
+              # First argument is exception class (if constant) or message (if string)
+              first_arg = args_array[0]
+              if first_arg
+                if first_arg.is_a?(Kanayago::ConstantNode)
+                  exception_class = first_arg.vid.to_s
+                elsif first_arg.is_a?(Kanayago::StringNode)
+                  # raise "message" - just a string message (StandardError)
+                  message = first_arg.ptr
+                end
+              end
+
+              # Second argument is message (if exists)
+              second_arg = args_array[1]
+              message = second_arg.ptr if second_arg.is_a?(Kanayago::StringNode)
+            end
+          end
+        end
+
+        context = build_raise_context(exception_class, message)
+        Values::ExceptionInfo.new(
+          type: :raise,
+          exception_class: exception_class,
+          message: message,
+          context: context
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockNesting
+
+      def extract_rescue_info(rescue_node, exceptions)
+        # RescueNode might contain multiple rescue bodies
+        # We'll handle this via RescueBodyNode traversal
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def extract_rescue_body_info(rescue_body_node, exceptions)
+        # Extract exception class from rescue clause
+        # rescue ArgumentError => e
+        # rescue ArgumentError, StandardError => e
+        exception_classes = []
+
+        if rescue_body_node.respond_to?(:args) && rescue_body_node.args
+          args_node = rescue_body_node.args
+
+          # args is ListNode with val array containing exception classes
+          if args_node.is_a?(Kanayago::ListNode) && args_node.respond_to?(:val)
+            args_array = args_node.val
+
+            if args_array.is_a?(Array)
+              args_array.each do |arg|
+                exception_classes << arg.vid.to_s if arg.is_a?(Kanayago::ConstantNode)
+              end
+            end
+          end
+        end
+
+        # If no exceptions specified, it catches StandardError
+        exception_classes = ["StandardError"] if exception_classes.empty?
+
+        exception_classes.each do |exc_class|
+          context = "rescue #{exc_class}"
+          exceptions << Values::ExceptionInfo.new(
+            type: :rescue,
+            exception_class: exc_class,
+            message: nil,
+            context: context
+          )
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      def build_raise_context(exception_class, message)
+        if message
+          "raise #{exception_class}, \"#{message}\""
+        else
+          "raise #{exception_class}"
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength, Lint/DuplicateBranch
+  end
+end

data/lib/igata/extractors/method_names.rb

@@ -11,6 +11,7 @@ class Igata
         @class_node = class_node
       end
 
+      # rubocop:disable Metrics/MethodLength
       def extract
         class_body = @class_node.body.body
         # For empty classes, class_body is BeginNode which doesn't have filter_map
@@ -25,9 +26,22 @@ class Igata
           # Extract comparison information for each method
           comparisons = ComparisonAnalyzer.extract(node)
 
-          Values::MethodInfo.new(name: node.mid.to_s, branches: branches, comparisons: comparisons)
+          # Extract exception information for each method
+          exceptions = ExceptionAnalyzer.extract(node)
+
+          # Extract boundary value suggestions for each method
+          boundary_values = BoundaryValueGenerator.extract(comparisons)
+
+          Values::MethodInfo.new(
+            name: node.mid.to_s,
+            branches: branches,
+            comparisons: comparisons,
+            exceptions: exceptions,
+            boundary_values: boundary_values
+          )
         end
       end
+      # rubocop:enable Metrics/MethodLength
     end
   end
 end