markbridge 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43b79ac6557f41fcce9274986295812dd9cbfccf10ce19d0f9b81424ef4f9a83
-  data.tar.gz: 63d7b2494828a885ceea8b333251d23e6400c2d84cb0a50e30c3112bb4c2a517
+  metadata.gz: 395eaa44d32b7fc497e7153b1648250d6abd675ef3fcafa7939c1282725683e2
+  data.tar.gz: bd1c7215feeeb2a6fd6e0ebb213122c3652037eec277eec396191321e3e050e0
 SHA512:
-  metadata.gz: 387f752e9d6ae0eecc1c4e1e48cda6ac9e94390b16b75d8813a29400af10664913ca0dff8d9af2553753ed41ed5a5ed60d366f51246a3c814fb6034dfeb3660c
-  data.tar.gz: ea951ad454a6f6bfa86d902725394bf01605bff6307c1a6a6b10918d1267af12d41fd2bd1989151a90a3eec7d0670fbfb79c69e0ae256077ed5897f64870e036
+  metadata.gz: ee252b9c8fdd75437e99e5cf2aa446c71c58f9091a1c1d33a0724feaa3e8239f1267e31154957b60a7d1b72c951ec0cf11367ecf8b13a15a5147e93f702a1d1f
+  data.tar.gz: da07e85f2ba664a1239578c2fead05e2bbbf43a563f2e2da5c6d2f409192d7777cfe5875148bb2058fd1750838ff9f56556938ee8ca000ac918e1a608276d5df

data/lib/markbridge/ast/table.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module AST
+    # Represents a table element containing rows.
+    #
+    # @example
+    #   table = AST::Table.new
+    #   table << AST::TableRow.new
+    class Table < Element
+      # Add a child node to the table.
+      # Whitespace-only Text nodes are ignored.
+      #
+      # @param child [Node] the node to add
+      # @return [Table] self for chaining
+      def <<(child)
+        return self if child.is_a?(Text) && child.text.strip.empty?
+
+        super
+      end
+    end
+
+    # Represents a table row containing cells.
+    #
+    # @example
+    #   row = AST::TableRow.new
+    #   row << AST::TableCell.new
+    class TableRow < Element
+      # Add a child node to the row.
+      # Whitespace-only Text nodes are ignored.
+      #
+      # @param child [Node] the node to add
+      # @return [TableRow] self for chaining
+      def <<(child)
+        return self if child.is_a?(Text) && child.text.strip.empty?
+
+        super
+      end
+    end
+
+    # Represents a table cell (td or th).
+    #
+    # @example Data cell
+    #   cell = AST::TableCell.new
+    #   cell << AST::Text.new("data")
+    #
+    # @example Header cell
+    #   cell = AST::TableCell.new(header: true)
+    #   cell << AST::Text.new("header")
+    class TableCell < Element
+      # Create a new table cell.
+      #
+      # @param header [Boolean] whether this is a header cell (th)
+      def initialize(header: false)
+        super()
+        @header = header
+      end
+
+      # Check if this is a header cell.
+      #
+      # @return [Boolean] true if this is a header cell
+      def header?
+        @header
+      end
+    end
+  end
+end

data/lib/markbridge/ast.rb

@@ -18,6 +18,7 @@ require_relative "ast/italic"
 require_relative "ast/line_break"
 require_relative "ast/list"
 require_relative "ast/list_item"
+require_relative "ast/table"
 require_relative "ast/paragraph"
 require_relative "ast/quote"
 require_relative "ast/size"

data/lib/markbridge/parsers/bbcode/handler_registry.rb

@@ -132,6 +132,11 @@ module Markbridge
           registry.register(%w[list ul ol ulist olist], Handlers::ListHandler.new)
           registry.register(%w[* li .], Handlers::ListItemHandler.new)
 
+          # Table handlers
+          registry.register("table", Handlers::TableHandler.new)
+          registry.register("tr", Handlers::TableRowHandler.new)
+          registry.register(%w[td th], Handlers::TableCellHandler.new)
+
           # Set the closing strategy
           registry.closing_strategy = closing_strategy || default_closing_strategy(registry)
 

data/lib/markbridge/parsers/bbcode/handlers/image_handler.rb

@@ -18,22 +18,24 @@ module Markbridge
           private
 
           def create_element(token:, content:)
-            # Extract dimensions from attributes or option
+            width, height = extract_dimensions(token)
+            AST::Image.new(src: content, width:, height:)
+          end
+
+          def extract_dimensions(token)
             width = sanitize_dimension(token.attrs[:width])
             height = sanitize_dimension(token.attrs[:height])
 
-            # Parse option for WIDTHxHEIGHT format (e.g., [img=100x200])
-            if token.attrs[:option]&.match?(/^\d+x\d+$/i)
-              dimensions = token.attrs[:option].split("x", 2)
-              width = sanitize_dimension(dimensions[0])
-              height = sanitize_dimension(dimensions[1])
-            elsif token.attrs[:option]&.match?(/^\d+$/)
-              # Just a number means width
-              width = sanitize_dimension(token.attrs[:option])
+            option = token.attrs[:option]
+            if option&.match?(/^\d+x\d+$/i)
+              parts = option.split("x", 2)
+              width = sanitize_dimension(parts[0])
+              height = sanitize_dimension(parts[1])
+            elsif option&.match?(/^\d+$/)
+              width = sanitize_dimension(option)
             end
 
-            # Content is the URL
-            AST::Image.new(src: content, width:, height:)
+            [width, height]
           end
 
           # Convert dimension to positive integer or nil

data/lib/markbridge/parsers/bbcode/handlers/quote_handler.rb

@@ -17,46 +17,53 @@ module Markbridge
           end
 
           def on_open(token:, context:, registry:, tokens: nil)
-            # Extract quote attributes
-            author = nil
+            attrs = extract_quote_attrs(token)
+            element = AST::Quote.new(**attrs)
+            context.push(element, token:)
+          end
+
+          attr_reader :element_class
+
+          private
+
+          def extract_quote_attrs(token)
+            author, post, topic, username = extract_from_option(token)
+            author ||= token.attrs[:author]
+
+            # Explicit attributes override option-parsed values
+            {
+              author:,
+              post: token.attrs[:post] || post,
+              topic: token.attrs[:topic] || topic,
+              username: token.attrs[:username] || username,
+            }
+          end
+
+          def extract_from_option(token)
+            option = token.attrs[:option]
+            return nil, nil, nil, nil unless option
+
+            unless option.match?(/,\s*post:\d+/)
+              # Simple author attribution
+              return option, nil, nil, nil
+            end
+
+            # Discourse format: "username, post:123, topic:456"
+            parts = option.split(",").map(&:strip)
+            username = parts[0]
             post = nil
             topic = nil
-            username = nil
 
-            # Check for author attribute or option
-            if token.attrs[:author]
-              author = token.attrs[:author]
-            elsif token.attrs[:option]
-              # Parse Discourse-style quote: "username, post:123, topic:456"
-              option = token.attrs[:option]
-              if option.match?(/,\s*post:\d+/)
-                # Discourse format with post/topic
-                parts = option.split(",").map(&:strip)
-                username = parts[0]
-                parts[1..].each do |part|
-                  if part =~ /^post:(\d+)$/
-                    post = ::Regexp.last_match(1)
-                  elsif part =~ /^topic:(\d+)$/
-                    topic = ::Regexp.last_match(1)
-                  end
-                end
-                author = username
-              else
-                # Simple author attribution
-                author = option
+            parts[1..].each do |part|
+              if part =~ /^post:(\d+)$/
+                post = ::Regexp.last_match(1)
+              elsif part =~ /^topic:(\d+)$/
+                topic = ::Regexp.last_match(1)
               end
             end
 
-            # Check for explicit username, post, topic attributes (override option if present)
-            username = token.attrs[:username] if token.attrs[:username]
-            post = token.attrs[:post] if token.attrs[:post]
-            topic = token.attrs[:topic] if token.attrs[:topic]
-
-            element = AST::Quote.new(author:, post:, topic:, username:)
-            context.push(element, token:)
+            [username, post, topic, username]
           end
-
-          attr_reader :element_class
         end
       end
     end

data/lib/markbridge/parsers/bbcode/handlers/table_cell_handler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module BBCode
+      module Handlers
+        # Handler for table cell tags (td, th)
+        class TableCellHandler < BaseHandler
+          def initialize
+            @element_class = AST::TableCell
+          end
+
+          def on_open(token:, context:, registry:, tokens: nil)
+            # Auto-close previous cell if still open
+            context.pop if context.current.is_a?(AST::TableCell)
+
+            element = AST::TableCell.new(header: token.tag == "th")
+            context.push(element, token:)
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/bbcode/handlers/table_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module BBCode
+      module Handlers
+        # Handler for table tags
+        class TableHandler < BaseHandler
+          def initialize
+            @element_class = AST::Table
+          end
+
+          def on_open(token:, context:, registry:, tokens: nil)
+            element = AST::Table.new
+            context.push(element, token:)
+          end
+
+          def on_close(token:, context:, registry:, tokens: nil)
+            # Auto-close open cell before closing row
+            context.pop if context.current.is_a?(AST::TableCell)
+            # Auto-close open row before closing table
+            context.pop if context.current.is_a?(AST::TableRow)
+
+            super
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/bbcode/handlers/table_row_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module BBCode
+      module Handlers
+        # Handler for table row tags (tr)
+        class TableRowHandler < BaseHandler
+          def initialize
+            @element_class = AST::TableRow
+          end
+
+          def on_open(token:, context:, registry:, tokens: nil)
+            # Auto-close open cell before starting new row
+            context.pop if context.current.is_a?(AST::TableCell)
+            # Auto-close previous row if still open
+            context.pop if context.current.is_a?(AST::TableRow)
+
+            element = AST::TableRow.new
+            context.push(element, token:)
+          end
+
+          def on_close(token:, context:, registry:, tokens: nil)
+            # Auto-close open cell before closing row
+            context.pop if context.current.is_a?(AST::TableCell)
+
+            super
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/bbcode/parser.rb

@@ -114,7 +114,7 @@ module Markbridge
         # while still processing its children
         # @param token [Token]
         # @param context [ParserState]
-        def handle_unknown_tag(token, context)
+        def handle_unknown_tag(token, _context)
           @unknown_tags[token.tag] += 1
         end
       end

data/lib/markbridge/parsers/bbcode.rb

@@ -35,6 +35,9 @@ require_relative "bbcode/handlers/self_closing_handler"
 require_relative "bbcode/handlers/simple_handler"
 require_relative "bbcode/handlers/size_handler"
 require_relative "bbcode/handlers/spoiler_handler"
+require_relative "bbcode/handlers/table_handler"
+require_relative "bbcode/handlers/table_row_handler"
+require_relative "bbcode/handlers/table_cell_handler"
 require_relative "bbcode/handlers/url_handler"
 
 # Parser components

data/lib/markbridge/parsers/html/handler_registry.rb

@@ -67,6 +67,11 @@ module Markbridge
           registry.register(%w[ul ol], Handlers::ListHandler.new)
           registry.register("li", Handlers::ListItemHandler.new)
 
+          # Table handlers (thead/tbody/tfoot are transparent - unregistered tags pass through)
+          registry.register("table", Handlers::TableHandler.new)
+          registry.register("tr", Handlers::TableRowHandler.new)
+          registry.register(%w[td th], Handlers::TableCellHandler.new)
+
           # Paragraph handler (transparent - doesn't create AST node)
           registry.register("p", Handlers::ParagraphHandler.new)
 

data/lib/markbridge/parsers/html/handlers/base_handler.rb

@@ -11,7 +11,6 @@ module Markbridge
           # @param parent [AST::Element] the parent AST node
           # @return [AST::Element, nil] the created element if children should be processed, nil otherwise
           def process(element:, parent:)
-            node = element # Alias for compatibility
             # Default: do nothing, subclasses override
             nil
           end

data/lib/markbridge/parsers/html/handlers/table_cell_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module HTML
+      module Handlers
+        # Handler for table cell tags (<td>, <th>)
+        class TableCellHandler < BaseHandler
+          def initialize
+            @element_class = AST::TableCell
+          end
+
+          def process(element:, parent:)
+            ast_element = AST::TableCell.new(header: element.name.downcase == "th")
+            parent << ast_element
+            ast_element
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/html/handlers/table_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module HTML
+      module Handlers
+        # Handler for table tags (<table>)
+        class TableHandler < BaseHandler
+          def initialize
+            @element_class = AST::Table
+          end
+
+          def process(element:, parent:)
+            ast_element = AST::Table.new
+            parent << ast_element
+            ast_element
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/html/handlers/table_row_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module HTML
+      module Handlers
+        # Handler for table row tags (<tr>)
+        class TableRowHandler < BaseHandler
+          def initialize
+            @element_class = AST::TableRow
+          end
+
+          def process(element:, parent:)
+            ast_element = AST::TableRow.new
+            parent << ast_element
+            ast_element
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/html/parser.rb

@@ -5,6 +5,11 @@ module Markbridge
     module HTML
       # Parses HTML into an AST using Nokogiri
       class Parser
+        # Tags whose contents should be dropped entirely (not emitted as text).
+        # These are raw-text/metadata elements whose children are either CSS,
+        # JavaScript, or document metadata that shouldn't appear in output.
+        IGNORED_TAGS = %w[style script head title noscript template].freeze
+
         attr_reader :unknown_tags
 
         # Create a new parser with optional custom handlers
@@ -26,8 +31,12 @@ module Markbridge
         def parse(input)
           @unknown_tags.clear
 
-          # Parse HTML with Nokogiri
-          doc = Nokogiri::HTML5.fragment(input)
+          # Parse HTML with Nokogiri. Using the generic HTML (HTML4) parser rather
+          # than HTML5 because Nokogiri::HTML5 is not available on JRuby
+          # (see sparklemotion/nokogiri#2227). Table support treats thead/tbody/tfoot
+          # as transparent, so the parse-tree difference (HTML5 auto-inserts tbody,
+          # HTML4 does not) has no effect on the AST.
+          doc = Nokogiri::HTML.fragment(input)
 
           # Create root AST document
           document = AST::Document.new
@@ -72,6 +81,8 @@ module Markbridge
         # @param parent [AST::Element]
         def process_element_node(node, parent)
           tag_name = node.name.downcase
+          return if IGNORED_TAGS.include?(tag_name)
+
           handler = @handlers[tag_name]
 
           if handler

data/lib/markbridge/parsers/html.rb

@@ -17,6 +17,9 @@ require_relative "html/handlers/list_handler"
 require_relative "html/handlers/list_item_handler"
 require_relative "html/handlers/quote_handler"
 require_relative "html/handlers/paragraph_handler"
+require_relative "html/handlers/table_handler"
+require_relative "html/handlers/table_row_handler"
+require_relative "html/handlers/table_cell_handler"
 
 # Parser components
 require_relative "html/handler_registry"