rbbcode 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05a9ae1e74abb5b265316ce91cefd13b76e6f484040e37b10c7f39a86e44695f
-  data.tar.gz: 40a4650b699a0bd33dd35d285eb5f9ef2f3962b0628601be3702362495217bb7
+  metadata.gz: 3894f3d4d56f04b0c0d7ad5fa194eef37e9933f49993dc9ddeb243b4bdf1bda9
+  data.tar.gz: f0167cb15f14b2c37dbbd55205e4e3b08275f26b8d8c9d9e9a95c684741c451f
 SHA512:
-  metadata.gz: defb74848c8d0632853ea9e3437188a1411978e523079778f29cd73826b3544937e14a36dde7144329d96d2886ca7275afd214af3bf5c8ba9c34da246a628743
-  data.tar.gz: a67405feba360b5c719bb1b0f958d2187efe8b217eb52e2635b8b41f3fbc66cd47b3c83c48ea53cae18d63298260bb2e4cd1691e0026b9c0a70e1d631d433ced
+  metadata.gz: 1a40401398844f12b7b874cedfc173bb98a887bc4dad718d2d30ece44b338060c84441e87265b12b91e777608a94b29f7eb9f074f49f810acb1f2dc1de9e01be
+  data.tar.gz: f0712fb419b27353fd569ce150adf74c47ef2d45cc6ed16dc80bcb6bd759354e4b3233596dfa942cda9845cb288d6a720b7a73dc2dff78b16538c17a8736b315

data/lib/rbbcode/node_extensions.rb

@@ -7,7 +7,7 @@ class RbbCode
   end
   
   module RecursiveConversion
-    def recursively_convert(node, output_method, depth = 0)
+    def recursively_convert(node, output_method, options, depth = 0)
       if node.terminal?
         if node.respond_to?(output_method)
           # This is a terminal node with a custom implementation of the output
@@ -23,12 +23,12 @@ class RbbCode
         if node.respond_to?(output_method)
           # This is a non-terminal node with a custom implementation of the
           # output method.
-          node.send(output_method)
+          node.send(output_method, options)
         else
           # This is a non-terminal node without a custom implementation of the
           # output method. Convert all its child nodes and concatenate the results.
           node.elements.collect do |sub_node|
-            recursively_convert(sub_node, output_method, depth + 1)
+            recursively_convert(sub_node, output_method, options, depth + 1)
           end.join
         end
       end
@@ -36,32 +36,32 @@ class RbbCode
   end
   
   module DocumentNode
-    def to_html
-      contents.elements.collect { |p| p.to_html }.join
+    def to_html(options)
+      contents.elements.collect { |p| p.to_html(options) }.join
     end
 
-    def to_markdown
-      contents.elements.collect { |p| p.to_markdown }.join
+    def to_markdown(options)
+      contents.elements.collect { |p| p.to_markdown(options) }.join
     end
   end
   
   module ParagraphNode
     include RecursiveConversion
     
-    def to_html
+    def to_html(options)
       # Convert all child nodes, concatenate the results,
       # and wrap the concatenated HTML in <p> tags.
       html = elements.collect do |node|
-        recursively_convert(node, :to_html)
+        recursively_convert(node, :to_html, options)
       end.join
       "\n<p>" + html + "</p>\n"
     end
 
-    def to_markdown
+    def to_markdown(options)
       # Convert all child nodes, concatenate the results,
       # and append newline characters.
       markdown = elements.collect do |node|
-        recursively_convert(node, :to_markdown)
+        recursively_convert(node, :to_markdown, options)
       end.join
       markdown + "\n\n"
     end
@@ -70,12 +70,12 @@ class RbbCode
   module BlockquoteNode
     include RecursiveConversion
 
-    def to_html
+    def to_html(options)
       # Detect paragraph breaks and wrap the result in <blockquote> tags.
       paragraphs = []
       cur_para = ''
       lines.elements.each do |line|
-        inner = recursively_convert(line, :to_html)
+        inner = recursively_convert(line, :to_html, options)
         unless inner.blank?
           cur_para << inner
           if line.post_breaks == 1
@@ -93,11 +93,11 @@ class RbbCode
       "\n<blockquote>" + inner + "</blockquote>\n"
     end
 
-    def to_markdown
+    def to_markdown(options)
       # Add a > character per line, preserving linebreaks as they are in the source.
       # Then append two newlines.
       '> ' + lines.elements.inject('') do |output, line|
-        inner_markdown = recursively_convert(line.contents, :to_markdown)
+        inner_markdown = recursively_convert(line.contents, :to_markdown, options)
         output + inner_markdown + ("\n> " * line.post_breaks)
       end + "\n\n"
     end
@@ -114,33 +114,33 @@ class RbbCode
   module ListNode
     include RecursiveConversion
     
-    def to_html
+    def to_html(options)
       # Convert the :contents child node (defined in the .treetop file)
       # and wrap the result in <ul> tags.
-      "\n<ul>" + recursively_convert(items, :to_html) + "</ul>\n"
+      "\n<ul>" + recursively_convert(items, :to_html, options) + "</ul>\n"
     end
 
-    def to_markdown
+    def to_markdown(options)
       # Convert the :contents child node (defined in the .treetop file).
       # (Unlike with HTML, no outer markup needed.) Then append an extra
       # newline, for a total of two at the end.
-      recursively_convert(items, :to_markdown) + "\n"
+      recursively_convert(items, :to_markdown, options) + "\n"
     end
   end
   
   module ListItemNode
     include RecursiveConversion
     
-    def to_html
+    def to_html(options)
       # Convert the :contents child node (defined in the .treetop file)
       # and wrap the result in <li> tags.
-      "\n<li>" + recursively_convert(contents, :to_html) + "</li>\n"
+      "\n<li>" + recursively_convert(contents, :to_html, options) + "</li>\n"
     end
 
-    def to_markdown
+    def to_markdown(options)
       # Convert the :contents child node (defined in the .treetop file)
       # and add * characters.
-      "* " + recursively_convert(contents, :to_html) + "\n"
+      "* " + recursively_convert(contents, :to_html, options) + "\n"
     end
   end
   
@@ -150,7 +150,7 @@ class RbbCode
   module URLTagNode
     include Attributes
     
-    def url_to_html
+    def url_to_html(options)
       # The :url child node (defined in the .treetop file) may or may not exist,
       # depending on how the link is formatted in the BBCode source.
       if respond_to?(:url) and respond_to?(:text)
@@ -162,7 +162,7 @@ class RbbCode
       end
     end
 
-    def url_to_markdown
+    def url_to_markdown(options)
       if respond_to?(:url) and respond_to?(:text)
         # This is a URL tag formatted like [url=http://example.com]Example[/url].
         '[' + text.text_value + '](' + strip_quotes(url.text_value) + ')'
@@ -176,17 +176,17 @@ class RbbCode
   # You won't find this module in the .treetop file. Instead, it's effectively a specialization
   # of TagNode, which calls to ImgTagNode when processing an img tag.
   module ImgTagNode
-    def img_to_html
+    def img_to_html(options)
       '<img src="' + inner_bbcode + '" alt="Image"/>'
     end
 
-    def img_to_markdown
+    def img_to_markdown(options)
       "![Image](#{inner_bbcode})"
     end
   end
 
   module UTagNode
-    def u_to_markdown
+    def u_to_markdown(options)
       # Underlining is unsupported in Markdown. So we just ignore [u] tags.
       inner_bbcode
     end
@@ -216,27 +216,27 @@ class RbbCode
       contents.elements.collect { |e| e.text_value }.join
     end
     
-    def inner_html
+    def inner_html(options)
       contents.elements.collect do |node|
-        recursively_convert(node, :to_html)
+        recursively_convert(node, :to_html, options)
       end.join
     end
 
-    def inner_markdown
+    def inner_markdown(options)
       contents.elements.collect do |node|
-        recursively_convert(node, :to_markdown)
+        recursively_convert(node, :to_markdown, options)
       end.join
     end
 
-    def wrap_html(t)
-      "<#{t}>" + inner_html + "</#{t}>"
+    def wrap_html(t, options)
+      "<#{t}>" + inner_html(options) + "</#{t}>"
     end
 
-    def wrap_markdown(t)
-      t + inner_markdown + t
+    def wrap_markdown(t, options)
+      t + inner_markdown(options) + t
     end
 
-    def convert(output_format)
+    def convert(output_format, options)
       # Consult TAG_MAPPINGS to decide how to process this type of tag.
       t = TAG_MAPPINGS[output_format][tag_name]
       if t.nil?
@@ -245,41 +245,41 @@ class RbbCode
         # This type of tag requires more than just a simple mapping from one tag name
         # to another. So we invoke a separate Ruby module.
         extend(t)
-        send("#{tag_name}_to_#{output_format}")
+        send("#{tag_name}_to_#{output_format}", options)
         # Thus, if our tag_name is"url, and TAG_MAPPINGS points us to URLTagNode,
         # that module must define url_to_html.
       else
         # For this type of tag, a simple mapping from the tag name to a string (such as
         # <i>) suffices.
-        send("wrap_#{output_format}", t)
+        send("wrap_#{output_format}", t, options)
       end
     end
     
-    def to_html
-      convert :html
+    def to_html(options)
+      convert :html, options
     end
 
-    def to_markdown
-      convert :markdown
+    def to_markdown(options)
+      convert :markdown, options
     end
   end
   
   module SingleBreakNode
-    def to_html
+    def to_html(options)
       '<br/>'
     end
 
-    def to_markdown
+    def to_markdown(options)
       "\n"
     end
   end
   
   module LiteralTextNode
-    def to_html
+    def to_html(options)
       text_value
     end
 
-    def to_markdown
+    def to_markdown(options)
       text_value
     end
   end

data/lib/rbbcode.rb

@@ -29,23 +29,31 @@ class RbbCode
   def initialize(options = {})
     @options = {
       :output_format => :html,
+      :emoticons => false,
       :sanitize => true,
       :sanitize_config => RbbCode::DEFAULT_SANITIZE_CONFIG
     }.merge(options)
   end
   
-  def convert(bb_code)
+  def convert(bb_code, options = {})
+    # Options passed to #convert will override any options passed to .new.
+    options = @options.merge(options)
+    output_format = options.delete(:output_format)
+    emoticons = options.delete(:emoticons)
+    sanitize = options.delete(:sanitize)
+    sanitize_config = options.delete(:sanitize_config)
+
     # Collapse CRLFs to LFs. Then replace any solitary CRs with LFs.
     bb_code = bb_code.gsub("\r\n", "\n").gsub("\r", "\n")
     # Add linebreaks before and after so that paragraphs etc. can be recognized.
     bb_code = "\n\n" + bb_code + "\n\n"
-    output = self.class.parser_class.new.parse(bb_code).send("to_#{@options[:output_format]}")
-    if @options[:emoticons]
+    output = self.class.parser_class.new.parse(bb_code).send("to_#{output_format}", options)
+    if emoticons
       output = convert_emoticons(output)
     end
     # Sanitization works for HTML only.
-    if @options[:output_format] == :html and @options[:sanitize]
-      Sanitize.clean(output, @options[:sanitize_config])
+    if output_format == :html and sanitize
+      Sanitize.clean(output, sanitize_config)
     else
       output
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbbcode
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Jarrett Colby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-20 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -28,72 +28,78 @@ dependencies:
   name: sanitize
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.0.2
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: lorax
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.3.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.3.0.rc2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
 description: Converts BBCode to HTML. Gracefully handles invalid input.
 email: jarrett@madebyhq.com
 executables: []