ruby-bbcode 2.0.3 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0e75772f9527582d10e8c0217244e80c0426c5c861be5ee124e758107349cb2
-  data.tar.gz: 4c7ef1e08b4d77a7111919cfe9e2d5b9b4d476ab092436264709e20fd04ad199
+  metadata.gz: 7b730deba08944b458a3493bbbf22c22332972907a6ee08cdbd6b5fa6ad197f3
+  data.tar.gz: f52a6ac0c514718b073bff2480e731b694d17b34420ab3fc8b0d6c3d73321439
 SHA512:
-  metadata.gz: 35930032e1756cd925369b1c485c09d4bbe016cb31702a2f89b496d94b5d23f960b5b2f0d7ff7f884f3154ec67a2456c0541dd2ab1d2e955e5e058280f26d36c
-  data.tar.gz: 1bef1bdbd00a25f3c735824228eb7961c06885bd47b5487030a23a1050d26c1014b1e29d2f108edbf528f7946986c6ca6d166bf3ca5c1e7db491b500e51164be
+  metadata.gz: 3fb032ad7763f35eb774a1566c03eaf22fe7ba13f1fae26fc82d05da66eb2163e0a0bbcebe15fa78d7c4345dbb574a03c8a22c5b40d2baf22fc74da7e992e0b8
+  data.tar.gz: 6ca73ffcbc1acf6ebd7ba4e3408f9b6448e910193b44e1c3bd29082417089457becd0627c463214aca2bdd14624faa1e3563ffefc3ae8e7cdaebfabd3f38f644

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 Upcoming
 --------
 
+Version 2.1.0 - 30-May-2019
+---------------------------
+
+* Use rubocup and sonargraph and fix minor issues
+* Make behavior of unknown tags configurable ([#33](https://github.com/veger/ruby-bbcode/issues/36))
+* Allow tags inside link tags ([#32](https://github.com/veger/ruby-bbcode/issues/32))
+* Do not convert newlines to HTML br element for 'block tags' ([#31](https://github.com/veger/ruby-bbcode/issues/31))
+
 Version 2.0.3 - 07-Feb-2018
 ---------------------------
 
@@ -10,12 +18,12 @@ Version 2.0.3 - 07-Feb-2018
 Version 2.0.2 - 10-Apr-2017
 ---------------------------
 
-* Fix error when tags are in self-closing tags (issue #30)
+* Fix error when tags are in self-closing tags ([#30](https://github.com/veger/ruby-bbcode/issues/30))
 
 Version 2.0.1 - 15-Jan-2017
 ---------------------------
 
-* Remove EOL newlines before/after self-closing tags (issue #29)
+* Remove EOL newlines before/after self-closing tags ([#29](https://github.com/veger/ruby-bbcode/issues/29))
 
 Version 2.0.0 - 09-Apr-2015
 ---------------------------
@@ -26,8 +34,8 @@ Version 2.0.0 - 09-Apr-2015
 * Changed tag description symbols (to become descriptive), **breaks existing custom tag additions!**
 * Add support to show the BBCode annotated with errors (when there are any)
 * Add support to escape token value using :uri_escape.
-* Recognize uppercase tags (issue #27)
-* Support [iframe-API](https://developers.google.com/youtube/iframe_api_reference) for YouTube videos (#18)
+* Recognize uppercase tags ([#27](https://github.com/veger/ruby-bbcode/issues/27))
+* Support [iframe-API](https://developers.google.com/youtube/iframe_api_reference) for YouTube videos ([#18](https://github.com/veger/ruby-bbcode/issues/18))
 * Support difference between optional and required parameters
 * Add optional parameters to youtube and vimeo tags to specify the dimensions of the video
 

data/Rakefile

@@ -9,7 +9,7 @@ begin
 rescue LoadError
   require 'rdoc/rdoc'
   require 'rake/rdoctask'
-	require 'rdoc/task'
+  require 'rdoc/task'
   RDoc::Task = Rake::RDocTask
 end
 
@@ -22,8 +22,6 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-
-
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
@@ -42,4 +40,4 @@ Rake::TestTask.new(:current) do |t|
   t.verbose = true
 end
 
-task :default => :test
+task default: :test

data/lib/ruby-bbcode.rb

@@ -1,4 +1,5 @@
 require 'tags/tags'
+require 'ruby-bbcode/configuration'
 require 'ruby-bbcode/tag_info'
 require 'ruby-bbcode/tag_sifter'
 require 'ruby-bbcode/tag_node'
@@ -11,6 +12,22 @@ require 'ruby-bbcode/bbtree'
 module RubyBBCode
   include ::RubyBBCode::Tags
 
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
   # This method converts the given text (with BBCode tags) into a HTML representation
   # The escape_html parameter (default: true) escapes HTML tags that were present in the given text and therefore blocking (mallicious) HTML in the original text
   # The additional_tags parameter is used to add additional BBCode tags that should be accepted
@@ -43,38 +60,41 @@ module RubyBBCode
 
     @tag_sifter.process_text
     return @tag_sifter.errors unless @tag_sifter.valid?
+
     true
   end
 
-
-  protected
-
-  # This method provides the final set of bbcode tags, it merges the default tags with the given additional_tags
-  # and blacklists(method = :disable) or whitelists the list of tags with the given tags parameter.
-  def self.determine_applicable_tags(additional_tags, method, *tags)
-    use_tags = @@tags.merge(additional_tags)
-    if method == :disable then               # if method is set to :disable
-      tags.each { |t| use_tags.delete(t) }   # blacklist (remove) the supplied tags
-    else  # method is not :disable, but has any other value
-      # Only use the supplied tags (whitelist)
-      new_use_tags = {}
-      tags.each { |t| new_use_tags[t] = use_tags[t] if use_tags.key?(t) }
-      use_tags = new_use_tags
+  class << self
+    protected
+
+    # This method provides the final set of bbcode tags, it merges the default tags with the given additional_tags
+    # and blacklists(method = :disable) or whitelists the list of tags with the given tags parameter.
+    def determine_applicable_tags(additional_tags, method, *tags)
+      use_tags = @@tags.merge(additional_tags)
+      if method == :disable
+        # if method is set to :disable blacklist (remove) the supplied tags
+        tags.each { |t| use_tags.delete(t) }
+      else
+        # only use the supplied tags (whitelist) if method is not :disable
+        new_use_tags = {}
+        tags.each { |t| new_use_tags[t] = use_tags[t] if use_tags.key?(t) }
+        use_tags = new_use_tags
+      end
+      use_tags
     end
-    use_tags
-  end
-
-  # This method parses the given text (with BBCode tags) into a BBTree representation
-  # The escape_html parameter (default: true) escapes HTML tags that were present in the given text and therefore blocking (mallicious) HTML in the original text
-  # The additional_tags parameter is used to add additional BBCode tags that should be accepted
-  # The method parameter determines whether the tags parameter needs to be used to blacklist (when set to :disable) or whitelist (when not set to :disable) the list of BBCode tags
-  # The method raises an exception when the text could not be parsed due to errors
-  def self.parse(text, escape_html = true, additional_tags = {}, method = :disable, *tags)
-    text = text.clone
-    use_tags = determine_applicable_tags(additional_tags, method, *tags)
 
-    @tag_sifter = TagSifter.new(text, use_tags, escape_html)
-    @tag_sifter.process_text
+    # This method parses the given text (with BBCode tags) into a BBTree representation
+    # The escape_html parameter (default: true) escapes HTML tags that were present in the given text and therefore blocking (mallicious) HTML in the original text
+    # The additional_tags parameter is used to add additional BBCode tags that should be accepted
+    # The method parameter determines whether the tags parameter needs to be used to blacklist (when set to :disable) or whitelist (when not set to :disable) the list of BBCode tags
+    # The method raises an exception when the text could not be parsed due to errors
+    def parse(text, escape_html = true, additional_tags = {}, method = :disable, *tags)
+      text = text.clone
+      use_tags = determine_applicable_tags(additional_tags, method, *tags)
+
+      @tag_sifter = TagSifter.new(text, use_tags, escape_html)
+      @tag_sifter.process_text
+    end
   end
 end
 
@@ -94,7 +114,7 @@ String.class_eval do
   # The method parameter determines whether the tags parameter needs to be used to blacklist (when set to :disable) or whitelist (when not set to :disable) the list of BBCode tags
   # The method raises an exception when the text could not be parsed due to errors
   def bbcode_to_html!(escape_html = true, additional_tags = {}, method = :disable, *tags)
-    self.replace(RubyBBCode.to_html(self, escape_html, additional_tags, method, *tags))
+    replace(RubyBBCode.to_html(self, escape_html, additional_tags, method, *tags))
   end
 
   # Convert a string with BBCode markup into its corresponding HTML markup

data/lib/ruby-bbcode/bbtree.rb

@@ -12,7 +12,7 @@ module RubyBBCode
   class BBTree
     attr_accessor :current_node, :tags_list
 
-    def initialize(hash = { :nodes => TagCollection.new })
+    def initialize(hash = { nodes: TagCollection.new })
       @bbtree = hash
       @current_node = TagNode.new(@bbtree)
       @tags_list = []
@@ -23,13 +23,14 @@ module RubyBBCode
     end
 
     def within_open_tag?
-      @tags_list.length > 0
+      !@tags_list.empty?
     end
-    alias :expecting_a_closing_tag? :within_open_tag?  # just giving this method multiple names for semantical purposes
+    alias expecting_a_closing_tag? within_open_tag? # just giving this method multiple names for semantical purposes
 
     # Returns the parent tag, if suitable/available
     def parent_tag
       return nil unless within_open_tag?
+
       @tags_list.last
     end
 
@@ -49,18 +50,19 @@ module RubyBBCode
       if @tags_list[-1].definition[:self_closable]
         # It is possible that the next (self_closable) tag is on the next line
         # Remove newline of current tag and parent tag as they are (probably) not intented as an actual newline here but as tag separator
-        @tags_list[-1][:nodes][0][:text].chomp! unless @tags_list[-1][:nodes][0][:text].nil?
-        @tags_list[-2][:nodes][0][:text].chomp! unless @tags_list.length < 2 or @tags_list[-2][:nodes][0][:text].nil?
+        @tags_list[-1][:nodes][0][:text]&.chomp!
+        @tags_list[-2][:nodes][0][:text].chomp! unless (@tags_list.length < 2) || @tags_list[-2][:nodes][0][:text].nil?
       end
 
-      @tags_list.pop     # remove latest tag in tags_list since it's closed now...
+      @tags_list.pop # remove latest tag in tags_list since it's closed now...
       # The parsed data manifests in @bbtree.current_node.children << TagNode.new(element) which I think is more confusing than needed
 
-      if within_open_tag?
-        @current_node = @tags_list[-1]
-      else # If we're still at the root of the BBTree or have returned back to the root via encountring closing tags...
-        @current_node = TagNode.new({:nodes => self.nodes})  # Note:  just passing in self works too...
-      end
+      @current_node = if within_open_tag?
+                        @tags_list[-1]
+                      else
+                        # we're still at the root of the BBTree or have returned back to the root via encountering closing tags...
+                        TagNode.new(nodes: nodes)
+                      end
     end
 
     # Create a new node and adds it to the current node as a child node
@@ -69,11 +71,11 @@ module RubyBBCode
     end
 
     def to_html(tags = {})
-      self.nodes.to_html(tags)
+      nodes.to_html(tags)
     end
 
     def to_bbcode(tags = {})
-      self.nodes.to_bbcode(tags)
+      nodes.to_bbcode(tags)
     end
   end
 end

data/lib/ruby-bbcode/configuration.rb

@@ -0,0 +1,18 @@
+# Configuration holds RubyBBCode configuration
+class Configuration
+  # Defines how to treat unknown tags
+  # * :exception throws and exception
+  # * :text converts it into a text
+  # * :ignore removes it from the output
+  attr_reader :ignore_unknown_tags
+
+  def initialize
+    @ignore_unknown_tags = :text
+  end
+
+  def ignore_unknown_tags=(value)
+    raise 'ignore_unknown_tags must be either :exception, :text or :ignore' unless %i[exception text ignore].include? value
+
+    @ignore_unknown_tags = value
+  end
+end

data/lib/ruby-bbcode/tag_collection.rb

@@ -17,9 +17,9 @@ module RubyBBCode
     # This method is vulnerable to stack-level-too-deep scenarios where >=1,200 tags are being parsed.
     # But that scenario can be mitigated by splitting up the tags.  bbtree = { :nodes => [900tags, 1000tags] }, the work
     # for that bbtree can be split up into two passes, do the each node one at a time.  I'm not coding that though, it's pointless, just a thought though
-    def to_code(tags, template)
-      html_string = ""
-      self.each do |node|
+    def to_code(tags, template, parent_node = nil)
+      output_string = ''
+      each do |node|
         if node.type == :tag
           t = template.new node
 
@@ -30,20 +30,20 @@ module RubyBBCode
             t.remove_unused_tokens!
           end
 
-          html_string << t.opening_part
+          output_string << t.opening_part
 
           # invoke "recursive" call if this node contains child nodes
-          html_string << node.children.to_code(tags, template) if node.has_children?      # FIXME:  Don't use recursion, it can lead to stack-level-too-deep errors for large volumes?
+          output_string << node.children.to_code(tags, template, node) if node.has_children? # FIXME:  Don't use recursion, it can lead to stack-level-too-deep errors for large volumes?
 
           t.inlay_closing_part!
 
-          html_string << t.closing_part
+          output_string << t.closing_part
         elsif node.type == :text
-          html_string << template.convert_text(node)
+          output_string << template.convert_text(node, parent_node)
         end
       end
 
-      html_string
+      output_string
     end
   end
-end
+end

data/lib/ruby-bbcode/tag_info.rb

@@ -3,6 +3,16 @@ module RubyBBCode
   # This class was made mostly just to keep track of all of the confusing the logic conditions that are checked.
   #
   class TagInfo
+    REGEX_STRING = '(?:(\[ (\/)? (\* | (?:\w+)) ((?:=[^\[\]]+) | (?:\s\w+=\w+)* | (?:[^\]]*))? \] (\s*)) | ([^\[]+))'.gsub(' ', '').freeze
+    REGEX = /#{REGEX_STRING}/i.freeze
+
+    COMPLETE_MATCH = 0
+    CLOSING_MATCH = 1
+    TAG_MATCH = 2
+    TAG_PARAM_MATCH = 3
+    WHITESPACE_AFTER_TAG = 4
+    TEXT = 5
+
     def initialize(tag_info, dictionary)
       @tag_data = find_tag_info(tag_info, dictionary)
     end
@@ -15,16 +25,19 @@ module RubyBBCode
       @tag_data[key] = value
     end
 
-    # Returns the definition of this instance (when it represents a tag element)
-    def definition
-      @definition
-    end
+    # Definition of this instance (when it represents a tag element)
+    attr_reader :definition
 
     # Returns the text (when this instance represents a text element)
     def text
       @tag_data[:text]
     end
 
+    # Returns the whitespace that was available directly after the tag definition
+    def whitespace
+      @tag_data[:whitespace]
+    end
+
     # Returns the type of the cuvvrent tag/node, which is either :opening_tag, :closing_tag, or :text
     def type
       return :opening_tag if element_is_opening_tag?
@@ -51,12 +64,12 @@ module RubyBBCode
 
     # Returns true if this instance represents an opening tag element
     def element_is_opening_tag?
-      self[:is_tag] and !self[:closing_tag]
+      self[:is_tag] && !self[:closing_tag]
     end
 
     # Returns true if this instance represents a closing tag element
     def element_is_closing_tag?
-      self[:is_tag] and  self[:closing_tag]
+      self[:is_tag] &&  self[:closing_tag]
     end
 
     # Returns true if this tag element is included in the set of available tags
@@ -71,7 +84,7 @@ module RubyBBCode
 
     # Returns true if the tag element is allowed in the provided parent_tag
     def allowed_in?(parent_tag)
-      !only_allowed_in_parent_tags? or @definition[:only_in].include?(parent_tag)
+      !only_allowed_in_parent_tags? || @definition[:only_in].include?(parent_tag)
     end
 
     # Returns true if this tag has quick parameter support
@@ -86,21 +99,39 @@ module RubyBBCode
 
     protected
 
+    # Returns a default info structure used by all tags
+    def default_tag_info(tag_info)
+      {
+        errors: [],
+        complete_match: tag_info[COMPLETE_MATCH],
+        whitespace: tag_info[WHITESPACE_AFTER_TAG]
+      }
+    end
+
     # Convert the result of the TagSifter#process_text regex into a more usable hash, that is used by the rest of the parser.
     # tag_info should a result of the regex of TagSifter#process_text
     # Returns the tag hash
     def find_tag_info(tag_info, dictionary)
-      ti = {}
-      ti[:errors] = []
-      ti[:complete_match] = tag_info[0]
-      ti[:is_tag] = (tag_info[0].start_with? '[')
+      ti = default_tag_info(tag_info)
+      ti[:is_tag] = (tag_info[COMPLETE_MATCH]&.start_with? '[')
       if ti[:is_tag]
-        ti[:closing_tag] = (tag_info[2] == '/')
-        ti[:tag] = tag_info[3].to_sym.downcase
+        ti[:closing_tag] = (tag_info[CLOSING_MATCH] == '/')
+        ti[:tag] = tag_info[TAG_MATCH].to_sym.downcase
         ti[:params] = {}
         @definition = dictionary[ti[:tag]]
-        if tag_info[5][0] == ?= and can_have_quick_param?
-          quick_param = tag_info[5][1..-1]
+        if !tag_in_dictionary?
+          # Tag is not defined in dictionary, so treat as text
+          raise "unknown tag #{ti[:tag]}" if RubyBBCode.configuration.ignore_unknown_tags == :exception
+
+          ti = default_tag_info(tag_info)
+          ti[:is_tag] = false
+          ti[:text] = if RubyBBCode.configuration.ignore_unknown_tags == :text
+                        tag_info[COMPLETE_MATCH]
+                      else
+                        ''
+                      end
+        elsif (tag_info[TAG_PARAM_MATCH][0] == '=') && can_have_quick_param?
+          quick_param = tag_info[TAG_PARAM_MATCH][1..-1]
           # Get list of parameter values and add them as (regular) parameters
           value_array = quick_param.scan(@definition[:quick_param_format])[0]
           if value_array.nil?
@@ -111,9 +142,9 @@ module RubyBBCode
               ti[:params][param_tokens[i][:token]] = value
             end
           end
-        elsif tag_info[5][0] == ?\s
+        elsif tag_info[TAG_PARAM_MATCH][0] == "\s"
           regex_string = '((\w+)=([\w#]+)) | ((\w+)="([^"]+)") | ((\w+)=\'([^\']+)\')'
-          tag_info[5].scan(/#{regex_string}/ix) do |param_info|
+          tag_info[TAG_PARAM_MATCH].scan(/#{regex_string}/ix) do |param_info|
             param = param_info[1] || param_info[4] || param_info[7]
             value = param_info[2] || param_info[5] || param_info[8]
             ti[:params][param.to_sym] = value
@@ -121,7 +152,7 @@ module RubyBBCode
         end
       else
         # Plain text
-        ti[:text] = tag_info[9]
+        ti[:text] = tag_info[TEXT]
       end
       ti
     end

data/lib/ruby-bbcode/tag_node.rb

@@ -15,7 +15,7 @@ module RubyBBCode
     #   and a tag element has the form of
     #       { :is_tag=>true, :tag=>:i, :nodes => [] }
     # * +nodes+
-    def initialize(element, nodes = [])
+    def initialize(element)
       @element = element
     end
 
@@ -39,12 +39,12 @@ module RubyBBCode
 
     # Returns true if the tag does not have any parameters set.
     def params_not_set?
-      @element[:params].length == 0
+      @element[:params].empty?
     end
 
-    # Returns true id the node that child nodes
+    # Returns true if the node that child nodes
     def has_children?
-      type == :tag and children.length > 0
+      (type == :tag) && !children.empty?
     end
 
     # Returns true when the quick parameter was invalid (i.e. it did not match the required format)