ruby-bindgen 1.0.0

data/lib/ruby-bindgen/name_mapper.rb

@@ -0,0 +1,65 @@
+module RubyBindgen
+  class NameMapper
+    attr_reader :exact, :regex
+    protected :exact, :regex
+
+    def initialize(mappings = [])
+      @exact = {}
+      @regex = []
+      mappings.each do |pattern, replacement|
+        if pattern.is_a?(Regexp)
+          @regex << [pattern, replacement]
+        else
+          @exact[pattern] = replacement
+        end
+      end
+    end
+
+    # Factory: parses YAML config array of {from:, to:} entries
+    def self.from_config(mappings)
+      parsed = mappings.filter_map do |entry|
+        key = entry[:from] || entry["from"]
+        replacement = entry[:to] || entry["to"]
+        next if key.nil?
+        if key.start_with?('/') && key.end_with?('/') && key.length > 2
+          [Regexp.new(key[1..-2]), replacement]
+        else
+          [key, replacement]
+        end
+      end
+      new(parsed)
+    end
+
+    # Look up a name, trying each candidate in order.
+    # Returns the replacement value or nil.
+    def lookup(*candidates)
+      # O(1) exact match
+      candidates.each do |name|
+        result = @exact[name]
+        return result if result
+      end
+
+      # Regex fallback
+      @regex.each do |pattern, replacement|
+        candidates.each do |name|
+          if (m = pattern.match(name))
+            if replacement.is_a?(String)
+              return replacement.gsub(/\\(\d+)/) { m[$1.to_i] }
+            else
+              return replacement
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    # Merge two tables. Other's entries override self's.
+    def merge(other)
+      exact_mappings = @exact.merge(other.exact).map { |k, v| [k, v] }
+      regex_mappings = other.regex + @regex
+      self.class.new(exact_mappings + regex_mappings)
+    end
+
+  end
+end

data/lib/ruby-bindgen/namer.rb

@@ -0,0 +1,138 @@
+module RubyBindgen
+  class Namer
+    def initialize(rename_types = NameMapper.new, rename_methods = NameMapper.new,
+                   conversion_mappings = NameMapper.new)
+      @rename_types = rename_types
+      @rename_methods = rename_methods
+      @conversion_mappings = conversion_mappings
+    end
+
+    def ruby(cursor)
+      if cursor.anonymous? && cursor.kind == :cursor_namespace
+        "Anonymous"
+      elsif cursor.anonymous?
+        definer = cursor.anonymous_definer
+        definer ? definer.spelling.camelize : nil
+      else
+        case cursor.kind
+          when :cursor_translation_unit
+            basename = File.basename(cursor.spelling, File.extname(cursor.spelling))
+            basename.camelize
+          when :cursor_conversion_function
+            ruby_conversion_function(cursor)
+          when :cursor_function, :cursor_cxx_method
+            ruby_operator_or_method(cursor)
+          when :cursor_struct, :cursor_union, :cursor_enum_decl, :cursor_class_decl, :cursor_namespace
+            @rename_types.lookup(cursor.spelling) || cursor.spelling.camelize
+          when :cursor_field_decl
+            cursor.spelling.underscore
+          when :cursor_typedef_decl
+            cursor.underlying_type.declaration.invalid? ?
+              cursor.spelling.underscore :
+              ruby(cursor.underlying_type.declaration)
+          when :cursor_variable
+            cursor.spelling.camelize
+          else
+            cursor.spelling.underscore
+        end
+      end
+    end
+
+    def cruby(cursor)
+      case cursor.kind
+        when :cursor_class_decl
+          "rb_c#{cursor.type.spelling.sub("(anonymous namespace)", "Anonymous").camelize}"
+        when :cursor_struct
+          "rb_c#{cursor.type.spelling.camelize}"
+        when :cursor_enum_decl
+          "rb_c#{cursor.type.spelling.sub("(anonymous namespace)", "Anonymous").camelize}"
+        when :cursor_namespace
+          if cursor.anonymous?
+            # qualified_name is nil for translation units
+            "rb_m#{cursor.semantic_parent.qualified_name&.camelize}Anonymous"
+          else
+            "rb_m#{cursor.qualified_name.camelize}"
+          end
+        when :cursor_typedef_decl
+          "rb_c#{cursor.spelling.sub("(anonymous namespace)", "Anonymous").camelize}"
+        when :cursor_translation_unit
+          "Class(rb_cObject)"
+        else
+          cursor.spelling.underscore
+      end
+    end
+
+    # Apply rename_types to a generated Ruby class name.
+    # Accepts one or more candidate names to try (e.g., raw C++ name, camelized name).
+    # Returns the first match, or the last candidate as fallback.
+    def apply_rename_types(*names)
+      @rename_types.lookup(*names) || names.last
+    end
+
+    private
+
+    # Handle conversion functions like operator int(), operator float()
+    def ruby_conversion_function(cursor)
+      # Use result_type.spelling to get the original typedef name (e.g., "size_t")
+      # rather than the resolved type from cursor.spelling (e.g., "unsigned long")
+      type_name = cursor.type.result_type.spelling
+
+      # Look up Ruby convention for this type
+      suffix = @conversion_mappings.lookup(type_name)
+      if suffix
+        "to_#{suffix}"
+      else
+        # Handle std::basic_string variants (std::string is a typedef)
+        if type_name.include?('basic_string')
+          return "to_s"
+        end
+
+        # Clean up the type name for Ruby method naming:
+        # - Remove reference/pointer markers
+        # - Use only the final type name (after last ::)
+        # - Convert to underscore style
+        clean_name = type_name.gsub(/[&*]/, '').strip
+        clean_name = clean_name.split('::').last || clean_name
+        # Remove template parameters for cleaner method names
+        clean_name = clean_name.sub(/<.*>$/, '')
+        "to_#{clean_name.underscore}"
+      end
+    end
+
+    # Handle operators and regular methods
+    def ruby_operator_or_method(cursor)
+      # Check rename_methods first (includes operator mappings merged by generator).
+      # SymbolCandidates yields the cursor spelling, qualified-name forms (with
+      # the inline-namespace-collapsed parent fallback), template display
+      # variants, and parameter-list forms — the same set Symbols uses, so a
+      # rename rule expressed in any form Symbols would accept also matches here.
+      symbol_candidates = SymbolCandidates.new(cursor)
+      result = @rename_methods.lookup(*symbol_candidates)
+
+      case result
+      when String then return result
+      when Proc then return result.call(cursor)
+      end
+
+      # No mapping — apply heuristics for non-operators only
+      spelling = cursor.spelling
+      unless spelling.start_with?('operator')
+        is_bool = cursor.type.result_type.spelling == "bool"
+        # Methods starting with "is" prefix (isFoo or is_foo) are predicates
+        is_prefixed = spelling.match?(/^is[A-Z_]/)
+
+        # Add ? suffix for predicate methods:
+        # 1. bool return with no parameters, OR
+        # 2. bool return with "is" prefix (regardless of parameters)
+        if is_bool && (cursor.type.args_size == 0 || is_prefixed)
+          return "#{spelling.underscore.sub(/^is_/, "")}?"
+        else
+          return spelling.underscore
+        end
+      end
+
+      # Unknown operator with no mapping
+      raise "Unknown operator: #{spelling}"
+    end
+  end
+end

data/lib/ruby-bindgen/outputter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+module RubyBindgen
+  class Outputter
+    attr_reader :base_path, :output_paths
+
+    def initialize(base_path)
+      @base_path = base_path
+      @output_paths = {}
+    end
+
+    def output_path(relative_path)
+      File.expand_path(File.join(self.base_path, relative_path))
+    end
+
+    def write(relative_path, content)
+      path = self.output_path(relative_path)
+      cleaned = cleanup_whitespace(content)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, "wb") do |file|
+        file << cleaned
+      end
+      @output_paths[path] = cleaned
+    end
+
+    private
+
+    # Clean up whitespace issues in generated content:
+    # - Collapse multiple consecutive blank lines to single blank line
+    # - Remove blank lines before closing braces
+    def cleanup_whitespace(content)
+      content = content.gsub(/\n{3,}/, "\n\n")
+      content = content.gsub(/\n\n(\s*\})/, "\n\\1")
+      content
+    end
+  end
+end

data/lib/ruby-bindgen/parser.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RubyBindgen
+  class Parser
+    class ParseError < RuntimeError
+      attr_reader :path, :details
+
+      def initialize(path, details: [])
+        @path = path
+        @details = details
+        super(build_message(path, details))
+      end
+
+      private
+
+      def build_message(path, details)
+        return "Failed to parse: #{path}" if details.empty?
+
+        formatted_details = details.map { |detail| "  #{detail}" }.join("\n")
+        "Parse errors in #{path}:\n#{formatted_details}"
+      end
+    end
+
+    attr_reader :inputter, :clang_args
+
+    def initialize(inputter, clang_args, libclang: nil)
+      @inputter = inputter
+      @clang_args = clang_args
+
+      # Set libclang path before loading ffi-clang (it reads ENV on load)
+      ENV['LIBCLANG'] = libclang if libclang
+
+      # Lazy-load ffi-clang and its refinements so CMake format doesn't need libclang
+      require 'ffi/clang'
+      require 'ruby-bindgen/refinements/cursor'
+
+      @index = FFI::Clang::Index.new(exclude_declarations_from_pch: false, display_diagnostics: true)
+    end
+
+    def generate(visitor)
+      visitor.visit_start
+
+      STDOUT << "\n" << "Processing:" << "\n"
+      self.inputter.each do |path, relative_path|
+        STDOUT << "  " << path << "\n"
+        begin
+          translation_unit = parse_translation_unit(path)
+        rescue ParseError => error
+          raise unless visitor.respond_to?(:visit_parse_error)
+
+          visitor.visit_parse_error(path, relative_path, error)
+          next
+        end
+        visitor.visit_translation_unit(translation_unit, path, relative_path)
+      end
+
+      visitor.visit_end
+    end
+
+    private
+
+    def parse_translation_unit(path)
+      translation_unit = @index.parse_translation_unit(path, self.clang_args, [],
+                                                       [:detailed_preprocessing_record, :skip_function_bodies])
+
+      raise ParseError.new(path) if translation_unit.nil?
+
+      check_diagnostics(translation_unit, path)
+      translation_unit
+    end
+
+    def check_diagnostics(translation_unit, path)
+      errors = translation_unit.diagnostics.select { |d| d.severity == :fatal || d.severity == :error }
+      return if errors.empty?
+
+      details = errors.map { |d| "#{d.severity}: #{d.spelling}" }
+      raise ParseError.new(path, details: details)
+    end
+  end
+end

data/lib/ruby-bindgen/refinements/cursor.rb

@@ -0,0 +1,57 @@
+module FFI
+  module Clang
+    class Cursor
+      def self.namer
+        @namer || raise("Namer not set — generator must call Cursor.namer= before processing")
+      end
+
+      def self.namer=(value)
+        @namer = value
+      end
+
+      def ruby_name
+        self.class.namer.ruby(self)
+      end
+
+      def cruby_name
+        self.class.namer.cruby(self)
+      end
+
+      def anonymous_definer
+        return nil unless self.anonymous?
+
+        if self.kind == :cursor_namespace
+          return self
+        end
+
+        # This could be a typedef of a field declaration in union or struct
+        #
+        # typedef struct {
+        #   union {
+        #     char *sdata;
+        #     int idata;
+        #   } u;
+        # } F_TextItemT;
+        _, result = self.translation_unit.cursor.find do |child, parent|
+          self.eql?(child) && (parent.kind == :cursor_field_decl ||
+                               parent.kind == :cursor_typedef_decl)
+        end
+
+        # Or this could be a variable declaration
+        #
+        # struct {
+        #   int Value;
+        #   uint8_t String[4];
+        # } MyArray_t;
+        unless result
+          variables = self.translation_unit.cursor.find_by_kind(true, :cursor_variable)
+          result = variables.find do |variable|
+            self.eql?(variable.type.declaration)
+          end
+        end
+        result
+      end
+
+    end
+  end
+end

data/lib/ruby-bindgen/refinements/string.rb

@@ -0,0 +1,41 @@
+class String
+  # Taken from ActiveSupport with modifications
+  def upcase_first
+    if self.length > 0
+      self[0].upcase.concat(self[1..-1])
+    else
+      self
+    end
+  end
+
+  # Taken from ActiveSupport with modifications
+  def camelize()
+    if self.match?(/\A[a-z\d]*\z/)
+      return self.capitalize
+    end
+
+    return self if self.match?(/\A[A-Z]+\z/)
+
+    input = self.match?(/\A[A-Z_0-9]*\z/) ? self.downcase : self
+    string = input.sub(/^[a-z\d]*/) { |match| match.capitalize! || match }
+    string.gsub!(/\/, ::/)
+    string.gsub!(/(?:_|-|\.|::|,| |\<|\>|(\/))([a-z\d]*)/i) do
+      word = $2
+      word[0] = word[0].capitalize || word[0] unless word.empty?
+      $1 ? "::#{word}" : word
+    end
+    string
+  end
+
+  # Taken from ActiveSupport with modifications
+  def underscore
+    return self unless /[A-Z-]|::/.match?(self)
+    word = self.gsub("::".freeze, "/".freeze)
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+    word.gsub!(/([a-z])([A-Z])/, '\1_\2'.freeze)
+    word.gsub!(/([a-z])(\d+[A-Z])/, '\1_\2'.freeze)
+    word.tr!("-".freeze, "_".freeze)
+    word.downcase!
+    word
+  end
+end