kanayago 0.1.1 → 0.2.0

data/patch/head/copy_target.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RUBY_PARSER_COPY_TARGETS = %w[
+  ccan/check_type/check_type.h
+  ccan/container_of/container_of.h
+  ccan/list/list.h
+  ccan/str/str.h
+  constant.h
+  id.h
+  id_table.h
+  include/ruby/st.h
+  internal/array.h
+  internal/basic_operators.h
+  internal/bignum.h
+  internal/bits.h
+  internal/compile.h
+  internal/compilers.h
+  internal/complex.h
+  internal/encoding.h
+  internal/error.h
+  internal/fixnum.h
+  internal/gc.h
+  internal/hash.h
+  internal/imemo.h
+  internal/io.h
+  internal/namespace.h
+  internal/numeric.h
+  internal/parse.h
+  internal/rational.h
+  internal/re.h
+  internal/ruby_parser.h
+  internal/sanitizers.h
+  internal/serial.h
+  internal/set_table.h
+  internal/static_assert.h
+  internal/string.h
+  internal/symbol.h
+  internal/thread.h
+  internal/variable.h
+  internal/warnings.h
+  internal/vm.h
+  internal.h
+  lex.c
+  method.h
+  node.c
+  node.h
+  node_name.inc
+  parse.c
+  parse.h
+  parser_bits.h
+  parser_node.h
+  parser_st.c
+  parser_st.h
+  parser_value.h
+  ruby_assert.h
+  ruby_atomic.h
+  ruby_parser.c
+  rubyparser.h
+  shape.h
+  st.c
+  symbol.h
+  thread_pthread.h
+  universal_parser.c
+  vm_core.h
+  vm_opts.h
+].freeze
+
+MAKE_DIRECTORIES = [
+  'ccan',
+  'ccan/check_type',
+  'ccan/container',
+  'ccan/container_of',
+  'ccan/list',
+  'ccan/str',
+  'internal',
+  'include',
+  'include/ruby'
+].freeze
+
+DELETE_DIRECTORIES = %w[
+  ccan
+  internal
+  include
+].freeze

data/patch/head/kanayago.patch

@@ -0,0 +1,162 @@
+diff --git a/ext/kanayago/internal/ruby_parser.h b/ext/kanayago/internal/ruby_parser.h
+index 8e306d1..d420a02 100644
+--- a/ext/kanayago/internal/ruby_parser.h
++++ b/ext/kanayago/internal/ruby_parser.h
+@@ -15,6 +15,29 @@ struct lex_pointer_string {
+     long ptr;
+ };
+ 
++// Add Ruby's Parser struct and enum for Kanayago
++enum lex_type {
++    lex_type_str,
++    lex_type_io,
++    lex_type_array,
++    lex_type_generic,
++};
++
++struct ruby_parser {
++    rb_parser_t *parser_params;
++    enum lex_type type;
++    union {
++        struct lex_pointer_string lex_str;
++        struct {
++            VALUE file;
++        } lex_io;
++        struct {
++            VALUE ary;
++        } lex_array;
++    } data;
++};
++// End for Kanayago
++
+ RUBY_SYMBOL_EXPORT_BEGIN
+ #ifdef UNIVERSAL_PARSER
+ const rb_parser_config_t *rb_ruby_parser_config(void);
+diff --git a/ext/kanayago/ruby_parser.c b/ext/kanayago/ruby_parser.c
+index 267f619..841db65 100644
+--- a/ext/kanayago/ruby_parser.c
++++ b/ext/kanayago/ruby_parser.c
+@@ -314,6 +314,44 @@ enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
+ 
+ extern VALUE rb_eArgError;
+ 
++//　Add for Kanayago
++static void *
++xmalloc_mul_add(size_t x, size_t y, size_t z)
++{
++    return rb_xmalloc_mul_add(x, y, z);
++}
++
++static VALUE
++suppress_tracing(VALUE (*func)(VALUE), VALUE arg)
++{
++    return func(arg);
++}
++
++static ID
++make_temporary_id(size_t n)
++{
++    return rb_make_temporary_id(n);
++}
++
++static int
++stderr_tty_p(void)
++{
++    return rb_stderr_tty_p();
++}
++
++static VALUE
++reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
++{
++     return rb_reg_compile(str, options, sourcefile, sourceline);
++}
++
++static VALUE
++reg_check_preprocess(VALUE val)
++{
++    return rb_reg_check_preprocess(val);
++}
++// End of Add for Kanayago
++
+ static const rb_parser_config_t rb_global_parser_config = {
+     .malloc = ruby_xmalloc,
+     .calloc = ruby_xcalloc,
+@@ -325,9 +363,9 @@ static const rb_parser_config_t rb_global_parser_config = {
+     .zalloc = zalloc,
+     .rb_memmove = memmove2,
+     .nonempty_memcpy = nonempty_memcpy,
+-    .xmalloc_mul_add = rb_xmalloc_mul_add,
++    .xmalloc_mul_add = xmalloc_mul_add, // use xmalloc_mul_add for Kanayago
+ 
+-    .compile_callback = rb_suppress_tracing,
++    .compile_callback = suppress_tracing, // use suppress_tracing for Kanayago
+     .reg_named_capture_assign = reg_named_capture_assign,
+ 
+     .attr_get = rb_attr_get,
+@@ -335,7 +373,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+     .ary_new_from_args = rb_ary_new_from_args,
+     .ary_unshift = rb_ary_unshift,
+ 
+-    .make_temporary_id = rb_make_temporary_id,
++    .make_temporary_id = make_temporary_id, // use make_temporary_id for Kanayago
+     .is_local_id = is_local_id2,
+     .is_attrset_id = is_attrset_id2,
+     .is_global_name_punct = is_global_name_punct,
+@@ -365,7 +403,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+ 
+     .int2num = rb_int2num_inline,
+ 
+-    .stderr_tty_p = rb_stderr_tty_p,
++    .stderr_tty_p = stderr_tty_p, //use stderr_tty_p for Kanayago
+     .write_error_str = rb_write_error_str,
+     .io_write = rb_io_write,
+     .io_flush = rb_io_flush,
+@@ -412,8 +450,8 @@ static const rb_parser_config_t rb_global_parser_config = {
+     .gc_guard = gc_guard,
+     .gc_mark = rb_gc_mark,
+ 
+-    .reg_compile = rb_reg_compile,
+-    .reg_check_preprocess = rb_reg_check_preprocess,
++    .reg_compile = reg_compile, // use reg_compile for Kanayago
++    .reg_check_preprocess = reg_check_preprocess, // use reg_check_preprocess for Kanayago
+     .memcicmp = rb_memcicmp,
+ 
+     .compile_warn = rb_compile_warn,
+@@ -443,27 +481,6 @@ static const rb_parser_config_t rb_global_parser_config = {
+ };
+ #endif
+ 
+-enum lex_type {
+-    lex_type_str,
+-    lex_type_io,
+-    lex_type_array,
+-    lex_type_generic,
+-};
+-
+-struct ruby_parser {
+-    rb_parser_t *parser_params;
+-    enum lex_type type;
+-    union {
+-        struct lex_pointer_string lex_str;
+-        struct {
+-            VALUE file;
+-        } lex_io;
+-        struct {
+-            VALUE ary;
+-        } lex_array;
+-    } data;
+-};
+-
+ static void
+ parser_mark(void *ptr)
+ {
+@@ -501,7 +518,8 @@ parser_memsize(const void *ptr)
+     return rb_ruby_parser_memsize(parser->parser_params);
+ }
+ 
+-static const rb_data_type_t ruby_parser_data_type = {
++// Not static const for Kanayago
++const rb_data_type_t ruby_parser_data_type = {
+     "parser",
+     {
+         parser_mark,

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