bbortcodes 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84f733c21d25ceaaf619d48918acad7c2b9ce8591d4c377229f96d938dff75b9
-  data.tar.gz: cb0c54df42dc99db3dc621ae75470b1700e91d03193658669f7f50f770f79ef4
+  metadata.gz: 00accc38cffaf4a382f6544309295b9e911676625312aa0ccf2cf42aefab345e
+  data.tar.gz: 832efe6cdda3787a15c7dca1f3e33aa28eafa026f6c9829162dc536947e275e2
 SHA512:
-  metadata.gz: be9a9d74d3cc2962c24d26acf3bb7a0450bfb6cc51f44cd334e5f65b12e47eb8795cf2ab83d2a1414cd2028113a7e8cf735c9bda5e3bd2192848fbe3e2195b9c
-  data.tar.gz: 0641d34d28eb37e3d12b7915d053308fd5e3352d609b1d9b290824a18c5ca2e48257e177735fac9afefe99cb65e8ff50babbf5e63ee6cf60aeca107709039ee4
+  metadata.gz: 267033c66da2ce686488602f537c1a343cff7364d629c26ac89832c4b2d63f9eebba54dfed83b8b418a0073c354b5ab102b6d702c7edc3b99dc1623402fbcc65
+  data.tar.gz: f903ec7d1d617cae3fac14d98fc1e956bf2c3b41b3d4ca6390de24ec5170502e7ce2d8bfea982252914189294a03e38136c37a51f5f8d8275109ead048f3be9a

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0] - 2025-02-06
+
+### Changed
+- **BREAKING**: Grammar now only matches registered shortcode names
+  - Unregistered bracket patterns (e.g., `[unknown]`, markdown links `[text](url)`) pass through as plain text
+  - Previously, unregistered shortcodes would trigger `on_parse_error` handling
+- **BREAKING**: `on_parse_error` configuration now only applies to grammar-level parse failures
+  - Unknown shortcode names no longer trigger this setting since they're treated as plain text
+- Removed `handle_unknown_shortcode` method from Parser (now dead code)
+
+### Fixed
+- Empty attributes (e.g., `caption=""`) now parse correctly instead of returning partial Parslet objects
+
 ## [0.1.0] - 2025-10-15
 
 ### Added

data/README.md

@@ -1,10 +1,12 @@
+[![Gem Version](https://badge.fury.io/rb/bbortcodes.svg)](https://badge.fury.io/rb/bbortcodes)
+
 # BBortcodes
 
 A state-of-the-art Ruby gem for parsing WordPress-like shortcodes with grammar-based parsing, type safety, and support for nested shortcodes.
 
 ## Features
 
-- **Grammar-based parsing** using [Parslet](https://github.com/kschiess/parslet) - no fragile regex matching
+- **Grammar-based parsing** using [Parslet](https://github.com/kschiess/parslet) - only registered shortcodes are parsed, everything else passes through as plain text
 - **Type safety** with [Literal](https://github.com/joeldrapper/literal) for runtime type checking
 - **Nested shortcodes** with configurable child validation
 - **Self-closing and paired shortcodes** support
@@ -432,8 +434,9 @@ BBortcodes.configure do |config|
   # Error handling
   # ---------------
 
-  # How to handle parse errors for unknown shortcodes
-  # Options: :raise, :skip (leave as-is), :strip (remove)
+  # How to handle grammar-level parse failures
+  # Options: :raise, :skip (return original text), :strip (return empty)
+  # Note: Unregistered shortcodes like [unknown] are automatically plain text
   config.on_parse_error = :raise # default
 
   # How to handle disallowed nested shortcodes
@@ -463,20 +466,21 @@ BBortcodes.configure do |config|
 end
 ```
 
-#### Example: Skip Unknown Shortcodes
+#### Unregistered Shortcodes as Plain Text
 
-```ruby
-BBortcodes.configure do |config|
-  config.on_parse_error = :skip
-end
+Bracket patterns that don't match registered shortcode names are automatically treated as plain text:
 
-text = "Text with [unknown]shortcode[/unknown]"
+```ruby
+text = "Text with [unknown]shortcode[/unknown] and [link](url)"
 output, _ = BBortcodes.parse(text)
 
 puts output
-# => "Text with [unknown]shortcode[/unknown]"
+# => "Text with [unknown]shortcode[/unknown] and [link](url)"
+# Both patterns pass through unchanged since they're not registered shortcodes
 ```
 
+This means markdown links, unregistered shortcode names, and other bracket patterns won't cause parse errors—they simply remain as plain text in the output.
+
 #### Example: Strip Disallowed Children
 
 ```ruby
@@ -582,6 +586,7 @@ BBortcodes uses [Parslet](https://github.com/kschiess/parslet), a PEG (Parsing E
 - **Better error messages** when syntax is invalid
 - **Composable grammar rules** for maintainability
 - **Unambiguous parsing** of edge cases
+- **Dynamic tag matching** - the grammar only matches registered shortcode names, treating everything else (markdown links, unregistered patterns) as plain text
 
 ### Type Safety
 

data/lib/bbortcodes/grammar.rb

@@ -4,6 +4,11 @@ require "parslet"
 
 module BBortcodes
   class Grammar < Parslet::Parser
+    def initialize(tag_names = [])
+      super()
+      @tag_names = tag_names.sort_by(&:length).reverse # Match longest first
+    end
+
     # Whitespace
     rule(:space) { match('\s').repeat(1) }
     rule(:space?) { space.maybe }
@@ -28,13 +33,19 @@ module BBortcodes
       (space >> attribute).repeat(1)
     end
 
-    # Shortcode name - alphanumeric and underscore/hyphen
-    rule(:shortcode_name) { match("[a-zA-Z]") >> match("[a-zA-Z0-9_-]").repeat }
+    # Dynamic rule matching only registered tag names
+    rule(:valid_shortcode_name) do
+      if @tag_names.empty?
+        str("").absent? # Never matches when no tags registered
+      else
+        @tag_names.map { |name| str(name) }.reduce(:|)
+      end
+    end
 
     # Self-closing shortcode: [name] or [name attr="value"]
     rule(:self_closing_shortcode) do
       str("[") >>
-        shortcode_name.as(:name) >>
+        valid_shortcode_name.as(:name) >>
         attributes.as(:attributes).maybe >>
         space? >>
         str("]")
@@ -43,7 +54,7 @@ module BBortcodes
     # Opening tag: [name] or [name attr="value"]
     rule(:opening_tag) do
       str("[") >>
-        shortcode_name.as(:tag_name) >>
+        valid_shortcode_name.as(:tag_name) >>
         attributes.as(:attributes).maybe >>
         space? >>
         str("]")
@@ -52,7 +63,7 @@ module BBortcodes
     # Closing tag: [/name]
     rule(:closing_tag) do
       str("[/") >>
-        shortcode_name.as(:tag_name) >>
+        valid_shortcode_name.as(:tag_name) >>
         space? >>
         str("]")
     end
@@ -61,8 +72,14 @@ module BBortcodes
     rule(:content_char) { str("[").absent? >> any }
     rule(:plain_text) { content_char.repeat(1).as(:text) }
 
+    # Fallback: lone bracket that doesn't start a valid shortcode or closing tag
+    rule(:lone_bracket) do
+      str("[") >> (str("/") >> valid_shortcode_name).absent?
+    end
+    rule(:lone_bracket_text) { lone_bracket.as(:text) }
+
     # Forward declaration for recursive content
-    rule(:content_element) { paired_shortcode | self_closing_shortcode | plain_text }
+    rule(:content_element) { paired_shortcode | self_closing_shortcode | lone_bracket_text | plain_text }
     rule(:content) { content_element.repeat.as(:content) }
 
     # Paired shortcode with content: [name]content[/name]
@@ -73,7 +90,7 @@ module BBortcodes
     end
 
     # Document is a sequence of text and shortcodes
-    rule(:document_element) { paired_shortcode | self_closing_shortcode | plain_text }
+    rule(:document_element) { paired_shortcode | self_closing_shortcode | lone_bracket_text | plain_text }
     rule(:document) { document_element.repeat.as(:document) }
 
     root(:document)

data/lib/bbortcodes/parser.rb

@@ -9,7 +9,6 @@ module BBortcodes
     def initialize(registry: nil, config: nil)
       @registry = registry || BBortcodes.registry
       @config = config || BBortcodes.config
-      @grammar = Grammar.new
       @transform = Transform.new
     end
 
@@ -28,9 +27,13 @@ module BBortcodes
       context = prepare_context(context)
 
       # Parse the text into a tree structure with timeout protection
+      # Create grammar with current registered tag names
+      tag_names = @registry.tag_names
+      grammar = Grammar.new(tag_names)
+
       begin
         parsed = Timeout.timeout(config.parse_timeout) do
-          @grammar.parse(text)
+          grammar.parse(text)
         end
       rescue Timeout::Error
         raise ParseError, "Parsing timeout exceeded (#{config.parse_timeout}s) - input may be too complex"
@@ -113,11 +116,9 @@ module BBortcodes
         return reconstruct_shortcode_text(node)
       end
 
-      # Find the shortcode class
+      # Find the shortcode class (should always succeed since grammar only matches registered tags)
       shortcode_class = registry.find(tag_name)
-      unless shortcode_class
-        return handle_unknown_shortcode(node)
-      end
+      raise ParseError, "Unknown shortcode: #{tag_name}" unless shortcode_class
 
       # Validate against parent's allowed children
       if parent_shortcode && !parent_shortcode.class.allows_child?(shortcode_class)
@@ -166,17 +167,6 @@ module BBortcodes
       end
     end
 
-    def handle_unknown_shortcode(node)
-      case config.on_parse_error
-      when :raise
-        raise ParseError, "Unknown shortcode: #{node[:name]}"
-      when :skip
-        reconstruct_shortcode_text(node)
-      when :strip
-        ""
-      end
-    end
-
     def handle_disallowed_child(node, parent)
       case config.on_disallowed_child
       when :raise

data/lib/bbortcodes/transform.rb

@@ -12,6 +12,11 @@ module BBortcodes
       {name.to_s => value.to_s}
     end
 
+    # Transform attribute with empty or multi-char string value
+    rule(name: simple(:name), value: {string: sequence(:chars)}) do
+      {name.to_s => chars.map(&:to_s).join}
+    end
+
     # Transform self-closing shortcode
     rule(name: simple(:name), attributes: subtree(:attrs)) do
       attributes = Array(attrs).reduce({}, :merge)

data/lib/bbortcodes/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BBortcodes
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bbortcodes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Stefan Exner
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-16 00:00:00.000000000 Z
+date: 2026-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anyway_config