kanayago 0.1.1 → 0.3.0

data/sample/minitest_generator.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require_relative '../lib/kanayago'
+
+class MinitestGenerator
+  def initialize(code)
+    @code = code
+    @ast = Kanayago.parse(code)
+    @current_visibility = :public
+  end
+
+  def generate
+    class_infos = extract_classes(@ast)
+
+    return '# No classes found in the code' if class_infos.empty?
+
+    # Generate tests for all classes
+    class_infos.map { |class_info| generate_minitest(class_info) }.join("\n\n")
+  end
+
+  private
+
+  # rubocop:disable Metrics/CyclomaticComplexity
+  def extract_classes(node, namespace = [])
+    classes = []
+
+    case node
+    when Kanayago::ModuleNode
+      # Process module and its contents
+      module_name = extract_constant_name(node.cpath)
+      new_namespace = namespace + [module_name]
+      classes.concat(extract_classes(node.body, new_namespace)) if node.respond_to?(:body)
+
+    when Kanayago::ClassNode
+      # Process class and collect its methods
+      class_name = extract_constant_name(node.cpath)
+      full_name = (namespace + [class_name]).join('::')
+      methods = extract_methods(node.body)
+
+      classes << {
+        name: full_name,
+        simple_name: class_name,
+        methods: methods
+      }
+
+      # Also look for nested classes within this class
+      new_namespace = namespace + [class_name]
+      classes.concat(extract_classes(node.body, new_namespace)) if node.respond_to?(:body)
+
+    when Kanayago::ScopeNode
+      classes.concat(extract_classes(node.body, namespace)) if node.respond_to?(:body)
+
+    when Kanayago::BlockNode
+      # BlockNode is an Array, iterate through its elements
+      node.each do |child|
+        classes.concat(extract_classes(child, namespace))
+      end
+    end
+
+    classes
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+
+  def extract_constant_name(node)
+    case node
+    when Kanayago::Colon2Node
+      # Extract the class name from mid (Symbol)
+      node.mid.to_s
+    else
+      'UnknownClass'
+    end
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def extract_methods(node, visibility = :public)
+    methods = []
+    current_visibility = visibility
+
+    return methods unless node
+
+    case node
+    when Kanayago::DefinitionNode
+      method_info = {
+        name: node.mid.to_s,
+        visibility: current_visibility,
+        parameters: extract_parameters(node)
+      }
+      methods << method_info if current_visibility == :public
+
+    when Kanayago::ScopeNode
+      # ScopeNode contains body, process it recursively
+      methods.concat(extract_methods(node.body, current_visibility)) if node.respond_to?(:body)
+
+    when Kanayago::BlockNode
+      # BlockNode is an Array, iterate through its elements
+      node.each do |child|
+        # Check if this is a visibility modifier
+        if child.is_a?(Kanayago::VariableCallNode) && child.respond_to?(:mid)
+          case child.mid.to_s
+          when 'private'
+            current_visibility = :private
+          when 'protected'
+            current_visibility = :protected
+          when 'public'
+            current_visibility = :public
+          end
+        else
+          # Process other nodes (including DefinitionNodes)
+          methods.concat(extract_methods(child, current_visibility))
+        end
+      end
+    end
+
+    methods
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def extract_parameters(def_node)
+    params = []
+    return params unless def_node.respond_to?(:defn)
+
+    defn = def_node.defn
+    return params unless defn.respond_to?(:args)
+
+    args = defn.args
+    return params unless args.respond_to?(:ainfo)
+
+    ainfo = args.ainfo
+    return params unless ainfo.is_a?(Hash)
+
+    # Handle required positional parameters (pre_args)
+    pre_count = ainfo[:pre_args_num] || 0
+    pre_count.times do |i|
+      params << {
+        name: "arg#{i + 1}",
+        type: :required
+      }
+    end
+
+    # Handle optional parameters
+    if ainfo[:opt_args]
+      current_opt = ainfo[:opt_args]
+      while current_opt
+        if current_opt.respond_to?(:body) && current_opt.body.respond_to?(:id)
+          params << {
+            name: current_opt.body.id.to_s,
+            type: :optional
+          }
+        end
+        current_opt = current_opt.respond_to?(:next) ? current_opt.next : nil
+      end
+    end
+
+    # Handle keyword parameters
+    if ainfo[:kw_args]
+      current_kw = ainfo[:kw_args]
+      while current_kw
+        if current_kw.respond_to?(:body) && current_kw.body.respond_to?(:id)
+          params << {
+            name: current_kw.body.id.to_s,
+            type: :keyword
+          }
+        end
+        current_kw = current_kw.respond_to?(:next) ? current_kw.next : nil
+      end
+    end
+
+    params
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+  def generate_minitest(class_info)
+    output = []
+    output << "require 'test_helper'"
+    output << ''
+    output << "class #{class_info[:name]}Test < Minitest::Test"
+
+    if class_info[:methods].empty?
+      output << '  # No public methods found'
+    else
+      class_info[:methods].each do |method|
+        output << generate_method_test(method)
+      end
+    end
+
+    output << 'end'
+    output.join("\n")
+  end
+
+  def generate_method_test(method)
+    lines = []
+    method_name = method[:name]
+    params = method[:parameters]
+
+    # Convert method name to test method name
+    test_base = method_name.gsub('?', '').gsub('!', '')
+
+    if method_name.end_with?('?')
+      # Boolean methods - generate true/false cases
+      lines << "  def test_#{test_base}_returns_true_when_condition_is_met"
+      lines << '    # TODO: implement'
+      lines << '  end'
+      lines << ''
+      lines << "  def test_#{test_base}_returns_false_when_condition_is_not_met"
+      lines << '    # TODO: implement'
+      lines << '  end'
+    elsif method_name == 'initialize'
+      # Constructor - check for optional parameters
+      lines << '  def test_initialize_creates_new_instance'
+      lines << '    # TODO: implement'
+      lines << '  end'
+
+      if params.any? { |p| %i[optional keyword].include?(p[:type]) }
+        lines << ''
+        lines << '  def test_initialize_uses_default_values_when_optional_parameters_are_not_provided'
+        lines << '    # TODO: implement'
+        lines << '  end'
+      end
+    else
+      # Regular methods
+      lines << "  def test_#{test_base}_works_correctly"
+      lines << '    # TODO: implement'
+      lines << '  end'
+
+      if params.any? { |p| %i[optional keyword].include?(p[:type]) }
+        lines << ''
+        lines << "  def test_#{test_base}_handles_optional_parameters"
+        lines << '    # TODO: implement'
+        lines << '  end'
+      end
+    end
+
+    lines << ''
+    lines.join("\n")
+  end
+end
+
+# Usage example
+sample_code = <<~RUBY
+  class User
+    class Profile
+      def initialize(name, age = 20)
+        @name = name
+        @age = age
+      end
+
+      def adult?
+        @age >= 18
+      end
+
+      def greet(message = "Hello")
+        "\#{message}, \#{@name}!"
+      end
+
+      private
+
+      def internal_method
+        # This should not appear in tests
+      end
+    end
+  end
+RUBY
+
+generator = MinitestGenerator.new(sample_code)
+puts generator.generate

data/sample/test_generator.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require_relative '../lib/kanayago'
+
+class TestGenerator
+  def initialize(code)
+    @code = code
+    @ast = Kanayago.parse(code)
+    @current_visibility = :public
+  end
+
+  def generate
+    class_infos = extract_classes(@ast)
+
+    return '# No classes found in the code' if class_infos.empty?
+
+    # Generate tests for all classes
+    class_infos.map { |class_info| generate_rspec(class_info) }.join("\n\n")
+  end
+
+  private
+
+  # rubocop:disable Metrics/CyclomaticComplexity
+  def extract_classes(node, namespace = [])
+    classes = []
+
+    case node
+    when Kanayago::ModuleNode
+      # Process module and its contents
+      module_name = extract_constant_name(node.cpath)
+      new_namespace = namespace + [module_name]
+      classes.concat(extract_classes(node.body, new_namespace)) if node.respond_to?(:body)
+
+    when Kanayago::ClassNode
+      # Process class and collect its methods
+      class_name = extract_constant_name(node.cpath)
+      full_name = (namespace + [class_name]).join('::')
+      methods = extract_methods(node.body)
+
+      classes << {
+        name: full_name,
+        simple_name: class_name,
+        methods: methods
+      }
+
+      # Also look for nested classes within this class
+      new_namespace = namespace + [class_name]
+      classes.concat(extract_classes(node.body, new_namespace)) if node.respond_to?(:body)
+
+    when Kanayago::ScopeNode
+      classes.concat(extract_classes(node.body, namespace)) if node.respond_to?(:body)
+
+    when Kanayago::BlockNode
+      # BlockNode is an Array, iterate through its elements
+      node.each do |child|
+        classes.concat(extract_classes(child, namespace))
+      end
+    end
+
+    classes
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+
+  def extract_constant_name(node)
+    case node
+    when Kanayago::Colon2Node
+      # Extract the class name from mid (Symbol)
+      node.mid.to_s
+    else
+      'UnknownClass'
+    end
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def extract_methods(node, visibility = :public)
+    methods = []
+    current_visibility = visibility
+
+    return methods unless node
+
+    case node
+    when Kanayago::DefinitionNode
+      method_info = {
+        name: node.mid.to_s,
+        visibility: current_visibility,
+        parameters: extract_parameters(node)
+      }
+      methods << method_info if current_visibility == :public
+
+    when Kanayago::ScopeNode
+      # ScopeNode contains body, process it recursively
+      methods.concat(extract_methods(node.body, current_visibility)) if node.respond_to?(:body)
+
+    when Kanayago::BlockNode
+      # BlockNode is an Array, iterate through its elements
+      node.each do |child|
+        # Check if this is a visibility modifier
+        if child.is_a?(Kanayago::VariableCallNode) && child.respond_to?(:mid)
+          case child.mid.to_s
+          when 'private'
+            current_visibility = :private
+          when 'protected'
+            current_visibility = :protected
+          when 'public'
+            current_visibility = :public
+          end
+        else
+          # Process other nodes (including DefinitionNodes)
+          methods.concat(extract_methods(child, current_visibility))
+        end
+      end
+    end
+
+    methods
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def extract_parameters(def_node)
+    params = []
+    return params unless def_node.respond_to?(:defn)
+
+    defn = def_node.defn
+    return params unless defn.respond_to?(:args)
+
+    args = defn.args
+    return params unless args.respond_to?(:ainfo)
+
+    ainfo = args.ainfo
+    return params unless ainfo.is_a?(Hash)
+
+    # Handle required positional parameters (pre_args)
+    pre_count = ainfo[:pre_args_num] || 0
+    pre_count.times do |i|
+      params << {
+        name: "arg#{i + 1}",
+        type: :required
+      }
+    end
+
+    # Handle optional parameters
+    if ainfo[:opt_args]
+      current_opt = ainfo[:opt_args]
+      while current_opt
+        if current_opt.respond_to?(:body) && current_opt.body.respond_to?(:id)
+          params << {
+            name: current_opt.body.id.to_s,
+            type: :optional
+          }
+        end
+        current_opt = current_opt.respond_to?(:next) ? current_opt.next : nil
+      end
+    end
+
+    # Handle keyword parameters
+    if ainfo[:kw_args]
+      current_kw = ainfo[:kw_args]
+      while current_kw
+        if current_kw.respond_to?(:body) && current_kw.body.respond_to?(:id)
+          params << {
+            name: current_kw.body.id.to_s,
+            type: :keyword
+          }
+        end
+        current_kw = current_kw.respond_to?(:next) ? current_kw.next : nil
+      end
+    end
+
+    params
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+  def generate_rspec(class_info)
+    output = []
+    output << "require 'spec_helper'"
+    output << ''
+    output << "RSpec.describe #{class_info[:name]} do"
+
+    if class_info[:methods].empty?
+      output << '  # No public methods found'
+    else
+      class_info[:methods].each do |method|
+        output << generate_method_spec(method)
+      end
+    end
+
+    output << 'end'
+    output.join("\n")
+  end
+
+  def generate_method_spec(method)
+    lines = []
+    method_name = method[:name]
+    params = method[:parameters]
+
+    lines << "  describe '##{method_name}' do"
+
+    if method_name.end_with?('?')
+      # Boolean methods - generate true/false cases
+      lines << "    context 'when condition is met' do"
+      lines << "      it 'returns true' do"
+      lines << '        # TODO: implement'
+      lines << '      end'
+      lines << '    end'
+      lines << ''
+      lines << "    context 'when condition is not met' do"
+      lines << "      it 'returns false' do"
+      lines << '        # TODO: implement'
+      lines << '      end'
+      lines << '    end'
+    elsif method_name == 'initialize'
+      # Constructor - check for optional parameters
+      lines << "    it 'creates a new instance' do"
+      lines << '      # TODO: implement'
+      lines << '    end'
+
+      if params.any? { |p| %i[optional keyword].include?(p[:type]) }
+        lines << ''
+        lines << "    it 'uses default values when optional parameters are not provided' do"
+        lines << '      # TODO: implement'
+        lines << '    end'
+      end
+    else
+      # Regular methods
+      lines << "    it 'works correctly' do"
+      lines << '      # TODO: implement'
+      lines << '    end'
+
+      if params.any? { |p| %i[optional keyword].include?(p[:type]) }
+        lines << ''
+        lines << "    context 'with optional parameters' do"
+        lines << "      it 'handles optional parameters' do"
+        lines << '        # TODO: implement'
+        lines << '      end'
+        lines << '    end'
+      end
+    end
+
+    lines << '  end'
+    lines << ''
+    lines.join("\n")
+  end
+end
+
+# Usage example
+sample_code = <<~RUBY
+  class User
+    class Profile
+      def initialize(name, age = 20)
+        @name = name
+        @age = age
+      end
+
+      def adult?
+        @age >= 18
+      end
+
+      def greet(message = "Hello")
+        "\#{message}, \#{@name}!"
+      end
+
+      private
+
+      def internal_method
+        # This should not appear in tests
+      end
+    end
+  end
+RUBY
+
+generator = TestGenerator.new(sample_code)
+puts generator.generate

data/script/setup_parser.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+
+# Ruby parser setup script for Kanayago
+# This script downloads Ruby source code and prepares parser files for building
+module KanayagoSetup
+  class << self
+    def run
+      puts 'Setting up Ruby parser files for Kanayago...'
+
+      # Determine Ruby version
+      ruby_version = detect_ruby_version
+      puts "Detected Ruby version: #{ruby_version}"
+
+      # Load copy targets for this Ruby version
+      load_copy_targets(ruby_version)
+
+      # Import parser files
+      import_parser_files(ruby_version)
+
+      # Apply patch
+      apply_patch(ruby_version)
+
+      puts 'Setup completed successfully!'
+    rescue StandardError => e
+      warn "Error during setup: #{e.message}"
+      warn e.backtrace.join("\n")
+      exit 1
+    end
+
+    private
+
+    def detect_ruby_version
+      if RUBY_DESCRIPTION.include?('dev')
+        'head'
+      else
+        RUBY_VERSION[0..2]
+      end
+    end
+
+    def load_copy_targets(version)
+      copy_target_path = File.expand_path("../patch/#{version}/copy_target.rb", __dir__)
+
+      raise "Copy target file not found: #{copy_target_path}" unless File.exist?(copy_target_path)
+
+      require copy_target_path
+    end
+
+    def import_parser_files(version) # rubocop:disable Metrics/PerceivedComplexity
+      puts 'Importing Ruby parser files...'
+
+      tar_name = if version == 'head'
+                   'snapshot/snapshot-master.tar.gz'
+                 else
+                   "#{version}/ruby-#{RUBY_VERSION}.tar.gz"
+                 end
+
+      # Get project root directory
+      project_root = File.expand_path('..', __dir__)
+      tmp_dir = File.join(project_root, 'tmp')
+      tmp_ruby_dir = File.join(tmp_dir, 'ruby')
+      tmp_tar_file = File.join(tmp_dir, 'ruby.tar.gz')
+
+      # Create temporary directory
+      FileUtils.mkdir_p(tmp_ruby_dir)
+
+      # Download Ruby source
+      puts 'Downloading Ruby source from cache.ruby-lang.org...'
+      system("curl -L https://cache.ruby-lang.org/pub/ruby/#{tar_name} -o #{tmp_tar_file}") ||
+        raise('Failed to download Ruby source')
+
+      # Extract
+      puts 'Extracting Ruby source...'
+      system("tar -zxf #{tmp_tar_file} -C #{tmp_ruby_dir} --strip-components 1") ||
+        raise('Failed to extract Ruby source')
+
+      dist = File.join(project_root, 'ext', 'kanayago')
+
+      # Create necessary directories
+      MAKE_DIRECTORIES.each do |dir|
+        dir_path = File.join(dist, dir)
+        FileUtils.mkdir_p(dir_path)
+      end
+
+      # Copy files
+      puts 'Copying parser files...'
+      RUBY_PARSER_COPY_TARGETS.each do |target|
+        src = File.join(tmp_ruby_dir, target)
+        dst = File.join(dist, target)
+
+        if File.exist?(src)
+          FileUtils.cp(src, dst)
+        else
+          warn "Warning: Source file not found: #{src}"
+        end
+      end
+
+      # Generate probes.h
+      puts 'Generating probes.h...'
+      probes_h_path = File.join(dist, 'probes.h')
+      File.open(probes_h_path, 'w+') do |f|
+        f << <<~SRC
+          #define RUBY_DTRACE_PARSE_BEGIN_ENABLED() (0)
+          #define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1) (void)(arg0), (void)(arg1);
+          #define RUBY_DTRACE_PARSE_END_ENABLED() (0)
+          #define RUBY_DTRACE_PARSE_END(arg0, arg1) (void)(arg0), (void)(arg1);
+        SRC
+      end
+
+      # Cleanup
+      puts 'Cleaning up temporary files...'
+      FileUtils.rm_rf(tmp_ruby_dir)
+      FileUtils.rm_f(tmp_tar_file)
+    end
+
+    def apply_patch(version)
+      puts "Applying patch for Ruby #{version}..."
+
+      patch_file = File.expand_path("../patch/#{version}/kanayago.patch", __dir__)
+
+      raise "Patch file not found: #{patch_file}" unless File.exist?(patch_file)
+
+      # Change to project root directory before applying patch
+      project_root = File.expand_path('..', __dir__)
+      Dir.chdir(project_root) do
+        system("patch -p1 < #{patch_file}") ||
+          raise('Failed to apply patch')
+      end
+    end
+  end
+end
+
+# Run setup if this script is executed directly
+KanayagoSetup.run if __FILE__ == $PROGRAM_NAME

data/typeprof.conf.json

@@ -0,0 +1,9 @@
+{
+    "typeprof_version": "experimental",
+    "rbs_dir": "sig/",
+    "analysis_unit_dirs": [
+        "lib/",
+        "lib/kanayago/"
+    ],
+    "diagnostic_severity": "error"
+}