ruby2html 1.6.6 → 2.0.0

data/lib/gem/ruby2html/render/pure_ruby.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+begin
+  # Only ERB's C escaper (erb >= 4), not the template engine. Absent on
+  # JRuby/TruffleRuby: PureRuby.escape then uses its regex fallback.
+  require 'erb/escape'
+rescue LoadError
+  nil
+end
+
+module Ruby2html
+  # Pure-Ruby twin of the C extension's Ruby2html::Native (ext/ruby2html),
+  # used on JRuby, when the extension isn't built, or with
+  # RUBY2HTML_DISABLE_EXT=1. The specs render everything with both and
+  # compare. The rules are documented once, in the C sources.
+  #
+  # Written for JITs (YJIT, the JVM): generated tag methods without splats,
+  # everything appended with String#<< to one buffer, and escaping that
+  # returns the string itself when there is nothing to escape.
+  module PureRuby
+    INVALID_ATTRIBUTE_NAME = %r{[\x00-\x20\x7f"'<>/=]}
+    STRING_BOOLEAN = /\A(?:data-|aria-|(?:draggable|spellcheck|contenteditable)\z)/
+    MAX_NESTING = 32 # see R2H_MAX_NESTING in attributes.c
+    ESCAPABLE = /[&<>"']/
+    ESCAPABLE_BYTES = /[&<>"']/n
+    ESCAPES = { '&' => '&amp;', '<' => '&lt;', '>' => '&gt;', '"' => '&quot;', "'" => '&#39;' }.freeze
+
+    class << self
+      # CRuby's ERB::Escape (erb >= 4, in C) is the fastest option and also
+      # returns its argument untouched when it is clean.
+      if RUBY_ENGINE == 'ruby' && defined?(ERB::Escape)
+        # May return str itself: only for appending to the buffer.
+        def escape(str)
+          ERB::Escape.html_escape(utf8_compatible(str))
+        end
+      else
+        def escape(str)
+          str = utf8_compatible(str)
+          # A UTF-8 regex raises on invalid bytes; Native passes them through.
+          return str.b.gsub(ESCAPABLE_BYTES, ESCAPES).force_encoding(Encoding::UTF_8) unless str.valid_encoding?
+
+          str.match?(ESCAPABLE) ? str.gsub(ESCAPABLE, ESCAPES) : str
+        end
+      end
+
+      # Like Native.escape_html: never hands back the caller's mutable string.
+      def escape_html(obj)
+        str = obj.to_s
+        escaped = escape(str)
+        escaped.equal?(str) && !str.frozen? ? str.dup : escaped
+      end
+
+      # See r2h_utf8_compatible in html_escape.c.
+      def utf8_compatible(str)
+        case str.encoding
+        when Encoding::UTF_8, Encoding::US_ASCII then str
+        when Encoding::BINARY then str.dup.force_encoding(Encoding::UTF_8)
+        else str.ascii_only? ? str : str.encode(Encoding::UTF_8)
+        end
+      end
+
+      def define_tag(method_name, tag, void)
+        source = void ? void_tag_source(method_name, tag) : tag_source(method_name, tag)
+        # The magic comment is per eval: without it every tag literal allocates.
+        module_eval("# frozen_string_literal: true\n#{source}", __FILE__, __LINE__)
+      end
+
+      private
+        def tag_source(method_name, tag)
+          <<~RUBY
+            def #{method_name}(content = nil, **attributes)
+              buffer = @current_output
+              if attributes.empty?
+                buffer << '<#{tag}>'
+              else
+                __r2h_open_tag(buffer, '<#{tag}', attributes)
+                buffer << '>'
+              end
+              if block_given?
+                size = buffer.bytesize
+                result = yield
+                __r2h_block_result(buffer, result) if buffer.bytesize == size
+              elsif content.instance_of?(String)
+                buffer << PureRuby.escape(content)
+              else
+                __r2h_text(buffer, content)
+              end
+              buffer << '</#{tag}>'
+              nil
+            end
+          RUBY
+        end
+
+        def void_tag_source(method_name, tag)
+          <<~RUBY
+            def #{method_name}(_content = nil, **attributes)
+              if attributes.empty?
+                @current_output << '<#{tag} />'
+              else
+                buffer = @current_output
+                __r2h_open_tag(buffer, '<#{tag}', attributes)
+                buffer << ' />'
+              end
+              nil
+            end
+          RUBY
+        end
+    end
+
+    def plain(text)
+      __r2h_text(@current_output, text)
+      nil
+    end
+
+    def component(html)
+      @current_output << PureRuby.utf8_compatible(html.to_s) unless html.nil?
+      nil
+    end
+
+    private
+      def __r2h_text(buffer, obj)
+        case obj
+        when nil then nil
+        when String
+          safe = !obj.instance_of?(String) && __r2h_html_safe?(obj)
+          buffer << (safe ? PureRuby.utf8_compatible(obj) : PureRuby.escape(obj))
+        when Symbol, Integer then buffer << PureRuby.escape(obj.to_s)
+        else
+          buffer << (__r2h_html_safe?(obj) ? PureRuby.utf8_compatible(obj.to_s) : PureRuby.escape(obj.to_s))
+        end
+      end
+
+      def __r2h_block_result(buffer, result)
+        __r2h_text(buffer, result) if result.is_a?(String) || result.is_a?(Symbol) || result.is_a?(Numeric)
+      end
+
+      def __r2h_html_safe?(obj)
+        obj.respond_to?(:html_safe?) && obj.html_safe?
+      end
+
+      # Writes `<tag attr="..."`. If an attribute raises and the caller rescues,
+      # a half-written start tag would turn whatever is appended next into
+      # markup, so the buffer is rolled back to before the tag.
+      def __r2h_open_tag(buffer, open, attributes)
+        mark = buffer.bytesize
+        buffer << open
+        __r2h_attributes(buffer, attributes, nil)
+      rescue Exception # rubocop:disable Lint/RescueException -- re-raised; any exception leaves the tag open
+        buffer.replace(buffer.byteslice(0, mark)) if !buffer.frozen? && buffer.bytesize >= mark
+        raise
+      end
+
+      def __r2h_attributes(buffer, attributes, prefix, depth = 0)
+        raise ArgumentError, "attributes nested more than #{MAX_NESTING} levels deep" if depth > MAX_NESTING
+
+        attributes.each do |key, value|
+          next if value.nil?
+
+          name = key.is_a?(Symbol) ? key.name : key.to_s
+          raise ArgumentError, "attribute name can't be empty" if name.empty?
+
+          name = PureRuby.utf8_compatible(name)
+          name = "#{prefix}-#{__r2h_dasherize(name)}" if prefix
+          # Match bytes when the name isn't valid UTF-8 (a UTF-8 regex would raise).
+          checked = name.valid_encoding? ? name : name.b
+          raise ArgumentError, "invalid attribute name: #{name.inspect}" if INVALID_ATTRIBUTE_NAME.match?(checked)
+
+          case value
+          when String then buffer << ' ' << name << '="' << PureRuby.escape(value) << '"'
+          when true then buffer << ' ' << name << (STRING_BOOLEAN.match?(name) ? '="true"' : '')
+          when false then buffer << ' ' << name << '="false"' if STRING_BOOLEAN.match?(name)
+          when Hash then __r2h_attributes(buffer, value, name, depth + 1)
+          when Array then buffer << ' ' << name << '="' << __r2h_tokens(value) << '"'
+          else buffer << ' ' << name << '="' << PureRuby.escape(value.to_s) << '"'
+          end
+        end
+      end
+
+      def __r2h_dasherize(name)
+        return name.tr('_', '-') if name.valid_encoding?
+
+        name.b.tr('_', '-').force_encoding(Encoding::UTF_8)
+      end
+
+      def __r2h_tokens(tokens)
+        __r2h_collect_tokens(tokens, [], 1).join(' ')
+      end
+
+      def __r2h_collect_tokens(tokens, collected, depth)
+        raise ArgumentError, "attributes nested more than #{MAX_NESTING} levels deep" if depth > MAX_NESTING
+
+        tokens.each do |token|
+          if token.is_a?(Array)
+            __r2h_collect_tokens(token, collected, depth + 1)
+          elsif token
+            collected << PureRuby.escape(token.to_s)
+          end
+        end
+        collected
+      end
+  end
+end

data/lib/gem/ruby2html/render.rb

@@ -1,12 +1,37 @@
 # frozen_string_literal: true
 
-begin
-  require 'ruby2html/ruby2html'
-rescue LoadError
-  puts 'ruby2html not installed'
-end
+require_relative 'render/pure_ruby'
 
 module Ruby2html
+  # Loads the C extension (Ruby2html::Native). Without it (JRuby, a failed
+  # build, or RUBY2HTML_DISABLE_EXT=1) the pure-Ruby twin is used instead.
+  # Installed gems find the extension on the load path; this repo builds it
+  # into lib/ruby2html.
+  def self.load_native_extension
+    return false if ENV['RUBY2HTML_DISABLE_EXT'] == '1'
+
+    begin
+      require 'ruby2html/ruby2html'
+    rescue LoadError
+      require_relative '../../ruby2html/ruby2html'
+    end
+    defined?(Native) ? true : false
+  rescue LoadError
+    false
+  end
+  private_class_method :load_native_extension
+
+  # The module providing tag methods, #plain and #component: Native or PureRuby.
+  IMPLEMENTATION = load_native_extension ? Native : PureRuby
+
+  def self.native?
+    IMPLEMENTATION != PureRuby
+  end
+
+  def self.escape_html(obj)
+    IMPLEMENTATION.escape_html(obj)
+  end
+
   class Render
     HTML5_TAGS = %w[
       a abbr address area article aside audio b base bdi bdo blockquote body br button canvas caption
@@ -19,107 +44,45 @@ module Ruby2html
     ].freeze
 
     VOID_ELEMENTS = %w[area base br col embed hr img input link meta param source track wbr].freeze
-    COMMON_RAILS_METHOD_HELPERS = %w[link_to image_tag form_with button_to].freeze
-
-    # Pre-generate all HTML tag methods as a single string
-    METHOD_DEFINITIONS = HTML5_TAGS.map do |tag|
-      method_name = tag.tr('-', '_')
-      is_void = VOID_ELEMENTS.include?(tag)
-      <<-RUBY
-        def #{method_name}(*args, **options, &block)
-          content = args.first.is_a?(String) ? args.shift : nil
-          estimated_size = #{tag.length * 2 + 5}
-          estimated_size += 32 if options.any?
-          estimated_size += content.length if content
-          tag_content = String.new(capacity: estimated_size)
-          tag_content << '<#{tag}'
-          fast_buffer_append(tag_content, fast_attributes_to_s(options))
-          #{if is_void
-              'tag_content << \' />\''
-            else
-              <<-TAG_LOGIC
-                tag_content << '>'
-                if block
-                  prev_output = @current_output
-                  nested_content = String.new(capacity: 1024)
-                  @current_output = nested_content
-                  block_result = block.call
-                  @current_output = prev_output
-                  if block_result.is_a?(String)
-                    fast_buffer_append(tag_content, fast_escape_html(block_result))
-                  else
-                    fast_buffer_append(tag_content, nested_content)
-                  end
-                elsif content
-                  fast_buffer_append(tag_content, fast_escape_html(content))
-                end
-                tag_content << '</#{tag}>'
-              TAG_LOGIC
-            end}
-          fast_buffer_append(@current_output, tag_content)
-        end
-      RUBY
-    end.join("\n")
+    # Rails helpers that write their markup into the ruby2html buffer, mapped
+    # to their RailsComponents wrapper (shared by Render and Component).
+    RAILS_HELPER_COMPONENTS = { link_to: :LinkTo, button_to: :ButtonTo, image_tag: :ImageTag, form_with: :FormWith }.freeze
+    # Context ivars that would clobber the renderer's own state if copied.
+    SKIPPED_IVAR_PREFIXES = %w[@_ @output @current_output @context @root].freeze
+
+    # Both implementations get the tags so specs can compare them in one process.
+    [PureRuby, IMPLEMENTATION].uniq.each do |implementation|
+      HTML5_TAGS.each { |tag| implementation.define_tag(tag.tr('-', '_'), tag, VOID_ELEMENTS.include?(tag)) }
+    end
 
-    # Evaluate all method definitions at once
-    class_eval(METHOD_DEFINITIONS, __FILE__, __LINE__ + 1)
+    include IMPLEMENTATION
 
-    attr_reader :output
+    # No `output` reader: it would shadow the <output> tag method.
     attr_accessor :current_output
 
     def initialize(context = nil, &root)
       @context = context
       @root = root
-      @output = String.new(capacity: 4096)
+      @output = String.new(capacity: 4096, encoding: Encoding::UTF_8)
       @current_output = @output
     end
 
-    def __render_from_rails(template_path)
-      result = render
-      return result unless annotate_rendered_view_with_filenames?
-
-      template_path = template_path.sub("#{Rails.root}/", '')
-      comment_start = "<!-- BEGIN #{template_path} -->"
-      comment_end = "<!-- END #{template_path} -->"
-
-      final_result = String.new(capacity: result.length + comment_start.length + comment_end.length)
-      final_result << comment_start
-      final_result << result
-      final_result << comment_end
-      final_result.html_safe
-    end if defined?(ActionView)
-
+    # Without arguments renders the root block and returns the HTML (a
+    # SafeBuffer under ActiveSupport). With arguments it is the context's
+    # render (partials, components), appended to the output.
     def render(*args, **options, &block)
-      set_instance_variables
+      copy_instance_variables if @context && !@__vars_copied
 
-      return plain @context.render(*args, **options, &block) if !args.empty? || !options.empty? || block_given?
+      return plain @context.render(*args, **options, &block) if !args.empty? || !options.empty? || block
 
       instance_exec(&@root)
-      result = @output
-      result = ActiveSupport::SafeBuffer.new(result) if defined?(ActiveSupport)
-      result
-    end
-
-    def respond_to?(method_name, include_private = false)
-      HTML5_TAGS.include?(method_name.to_s.tr('_', '-')) || super
-    end
-
-    def plain(text)
-      if defined?(ActiveSupport) && (text.is_a?(ActiveSupport::SafeBuffer) || text.html_safe?)
-        fast_buffer_append(@current_output, text)
-      else
-        fast_buffer_append(@current_output, fast_escape_html(text.to_s))
-      end
-    end
-
-    def component(component_output)
-      fast_buffer_append(@current_output, component_output)
+      defined?(ActiveSupport::SafeBuffer) ? ActiveSupport::SafeBuffer.new(@output) : @output
     end
 
     private
-      def method_missing(method_name, *args, **options, &block)
+      def method_missing(method_name, ...)
         if @context.respond_to?(method_name)
-          @context.send(method_name, *args, **options, &block)
+          @context.send(method_name, ...)
         else
           super
         end
@@ -129,26 +92,25 @@ module Ruby2html
         @context.respond_to?(method_name) || super
       end
 
-      COMMON_RAILS_METHOD_HELPERS.each do |method|
+      # Resolved per call (const_get with a Symbol; autoloaded on first use).
+      RAILS_HELPER_COMPONENTS.each do |method, component_name|
         define_method(method) do |*args, **options, &block|
-          constant = "Ruby2html::RailsComponents::#{method.to_s.camelize}".constantize
-          constant.new(self, @context, method, *args, **options).render(&block)
+          RailsComponents.const_get(component_name).new(self, @context, method, *args, **options).render(&block)
         end
       end if defined?(ActionView)
 
       def escape_html(text)
-        fast_escape_html(text.to_s)
+        IMPLEMENTATION.escape_html(text)
       end
 
-      def annotate_rendered_view_with_filenames?
-        return @annotate_rendered_view_with_filenames if defined?(@annotate_rendered_view_with_filenames)
-        @annotate_rendered_view_with_filenames = Rails.application.config.action_view.annotate_rendered_view_with_filenames
-      end
-
-      def set_instance_variables
+      # Templates read the view's assigns (@users, ...) as their own ivars.
+      def copy_instance_variables
         @context.instance_variables.each do |name|
+          next if name.start_with?(*SKIPPED_IVAR_PREFIXES)
+
           instance_variable_set(name, @context.instance_variable_get(name))
         end
+        @__vars_copied = true
       end
   end
 end

data/lib/gem/ruby2html/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruby2html
-  VERSION = '1.6.6'
+  VERSION = '2.0.0'
 end

data/lib/gem/ruby2html.rb

@@ -1,13 +1,34 @@
 # frozen_string_literal: true
 
-require 'cgi'
-require 'stringio'
-require 'htmlbeautifier'
-
-Dir.glob(File.join(File.dirname(__FILE__), 'ruby2html', '**', '*.rb')).each do |file|
-  require file
-end
+# Entry point. Loads only the renderer eagerly; everything else is autoloaded
+# on first use, so `require 'ruby2html'` outside Rails stays small and fast
+# (no Prism, no ActionView glue, no htmlbeautifier).
+require_relative 'ruby2html/version'
+require_relative 'ruby2html/render'
 
 module Ruby2html
   class Error < StandardError; end
+
+  autoload :Component, File.expand_path('ruby2html/component', __dir__)
+  autoload :ComponentHelper, File.expand_path('ruby2html/component_helper', __dir__)
+  autoload :RailsHelper, File.expand_path('ruby2html/rails_helper', __dir__)
+  autoload :HtmlBeautifierMiddleware, File.expand_path('ruby2html/html_beautifier_middleware', __dir__)
+
+  # Rails helper wrappers and the .html.rb template compiler (needs Prism).
+  module RailsComponents
+    {
+      OutputCapture: 'output_capture',
+      BaseComponent: 'base_component',
+      LinkTo: 'link_to',
+      ButtonTo: 'button_to',
+      ImageTag: 'image_tag',
+      FormWith: 'form_with',
+      TemplateHelpers: 'template_helpers',
+      TemplateCompiler: 'template_compiler'
+    }.each { |name, file| autoload name, File.expand_path("ruby2html/rails_components/#{file}", __dir__) }
+  end
 end
+
+# Template handler + Railtie. Registers lazily via ActiveSupport.on_load, so
+# it costs nothing until ActionView loads; a no-op without ActiveSupport.
+require_relative 'ruby2html/railtie' if defined?(ActiveSupport)

metadata

@@ -1,84 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby2html
 version: !ruby/object:Gem::Version
-  version: 1.6.6
+  version: 2.0.0
 platform: ruby
 authors:
 - sebi
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: htmlbeautifier
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.14'
-- !ruby/object:Gem::Dependency
-  name: benchmark-ips
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.10'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: Ruby2HTML empowers developers to write view logic in pure Ruby, seamlessly
   converting it into clean, well-formatted HTML. Enhance your templating workflow,
   improve readability, and leverage the full power of Ruby in your views. Features
@@ -91,10 +21,19 @@ extensions:
 - ext/ruby2html/extconf.rb
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
 - README.md
+- ext/ruby2html/attributes.c
+- ext/ruby2html/buffer.h
+- ext/ruby2html/content.c
 - ext/ruby2html/extconf.rb
+- ext/ruby2html/html_escape.c
 - ext/ruby2html/ruby2html.c
+- ext/ruby2html/ruby2html.h
+- ext/ruby2html/tag_render.c
 - lib/gem/ruby2html.rb
+- lib/gem/ruby2html/component.rb
 - lib/gem/ruby2html/component_helper.rb
 - lib/gem/ruby2html/html_beautifier_middleware.rb
 - lib/gem/ruby2html/rails_components/base_component.rb
@@ -102,34 +41,39 @@ files:
 - lib/gem/ruby2html/rails_components/form_with.rb
 - lib/gem/ruby2html/rails_components/image_tag.rb
 - lib/gem/ruby2html/rails_components/link_to.rb
+- lib/gem/ruby2html/rails_components/output_capture.rb
+- lib/gem/ruby2html/rails_components/template_collector.rb
+- lib/gem/ruby2html/rails_components/template_compiler.rb
+- lib/gem/ruby2html/rails_components/template_helpers.rb
 - lib/gem/ruby2html/rails_helper.rb
 - lib/gem/ruby2html/railtie.rb
 - lib/gem/ruby2html/render.rb
+- lib/gem/ruby2html/render/pure_ruby.rb
 - lib/gem/ruby2html/version.rb
-- lib/ruby2html/ruby2html.so
-- ruby2html.gemspec
 homepage: https://github.com/sebyx07/ruby2html
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/sebyx07/ruby2html
   source_code_uri: https://github.com/sebyx07/ruby2html
+  changelog_uri: https://github.com/sebyx07/ruby2html/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sebyx07/ruby2html/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib/gem
-- lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Transform Ruby code into beautiful, structured HTML with C-optimized performance
 test_files: []

data/ruby2html.gemspec

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/gem/ruby2html/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'ruby2html'
-  spec.version = Ruby2html::VERSION
-  spec.authors = ['sebi']
-  spec.email = ['gore.sebyx@yahoo.com']
-
-  spec.summary = 'Transform Ruby code into beautiful, structured HTML with C-optimized performance'
-  spec.description = 'Ruby2HTML empowers developers to write view logic in pure Ruby, ' \
-    'seamlessly converting it into clean, well-formatted HTML. ' \
-    'Enhance your templating workflow, improve readability, and ' \
-    'leverage the full power of Ruby in your views. ' \
-    'Features include Rails integration, custom component support, ' \
-    'automatic HTML beautification, and C-optimized rendering performance.'
-  spec.homepage = 'https://github.com/sebyx07/ruby2html'
-  spec.license = 'MIT'
-  spec.required_ruby_version = '>= 3.0.0'
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = spec.homepage
-
-  # Include C extension
-  spec.extensions = ['ext/ruby2html/extconf.rb']
-
-  # Include both lib and ext directories
-  spec.files = Dir.glob('{lib,ext}/{**/*,*}') +
-    ['README.md', File.basename(__FILE__)]
-
-  # Set require paths for both the gem and extension
-  spec.require_paths = %w[lib/gem lib]
-
-  # Runtime dependencies
-  spec.add_dependency 'htmlbeautifier', '>= 1.4'
-
-  # Development dependencies
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rake-compiler', '~> 1.2'
-  spec.add_development_dependency 'minitest', '~> 5.14'
-  spec.add_development_dependency 'benchmark-ips', '~> 2.10'
-end