ruby-bbcode 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 81fc51b37a07ce293879a04f6c2e94d0888a5069
-  data.tar.gz: 7f35303b08f5a4f37c311b6aa70babe8e6918d04
+SHA256:
+  metadata.gz: 5a747eebc84dd7ba046dde015c5bcd30cc3301d610aa5ab10769f9428728e7bd
+  data.tar.gz: f02dd04c79a57b3f611b414804c5f62bc28c18ff6555c6d3ac3ca115560bdd4c
 SHA512:
-  metadata.gz: dc09a68f466ee66a7a2591bff3fff64e48db3f2ea2e65f6226979ec5620e9bd0e2e084bfe85162d9c0d9beef5fb0781ffcd4b55d4e5bd5caf06dc9a2d4f836fd
-  data.tar.gz: c93e42b5f4b448f9589d105845a116f8d183aa2f66025c09ab07b518de01d85c5c7b0da5c7c92f43fef7233761ccfc5200d8f829331d0415ad9d3415775d4e59
+  metadata.gz: 9d958f90dfb03450bca54fa5e2f41272a14fc11a5186911cf688c93d576582c6f0effd1b42e0d0a228e49a1b5cf4991fb3f39a7307296c1337afb2791688f82f
+  data.tar.gz: 26fd15dfccd85f1d1f74b8dd7d47eab7c0e12950d85863ea39f8cc430d51fb0e1617d0c5defcb7fab076f538db16a3efc5bb0fa98e7329374a540b2411ece93f

data/CHANGELOG.md

@@ -1,6 +1,35 @@
 Upcoming
 --------
 
+Version 2.1.1 - 27-May-2020
+---------------------------
+
+* Bump activesupport to version 5.2.4.3
+
+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-2019
+---------------------------
+
+* Require Ruby version 2.3.0 or higher
+* Require activesupport version 4.2.2 or higher
+
+Version 2.0.2 - 10-Apr-2017
+---------------------------
+
+* 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 ([#29](https://github.com/veger/ruby-bbcode/issues/29))
+
 Version 2.0.0 - 09-Apr-2015
 ---------------------------
 
@@ -10,8 +39,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/README.md

@@ -0,0 +1,66 @@
+# Ruby-BBCode
+
+[![gem version](https://badge.fury.io/rb/ruby-bbcode.svg)](https://badge.fury.io/rb/ruby-bbcode) [![Build Status](https://travis-ci.org/veger/ruby-bbcode.svg?branch=master)](https://travis-ci.org/veger/ruby-bbcode) [![Code Coverage](https://coveralls.io/repos/github/veger/ruby-bbcode/badge.svg?branch=master)](https://coveralls.io/github/veger/ruby-bbcode?branch=master)
+
+This gem adds support for [BBCode](http:/www.bbcode.org/) to Ruby. The BBCode is parsed by a parser before converted to HTML, allowing to convert nested BBCode tags in strings to their correct HTML equivalent. The parser also checks whether the BBCode is valid and gives errors for incorrect BBCode texts.
+Additionally, annotations can be added to the BBCode string the showing errors that are present, assuming there are any errors.
+
+The parser recognizes all [official tags](http://www.bbcode.org/reference.php) and allows to easily extend this set with custom tags.
+
+## Examples
+
+`bbcode_to_html` can be used to convert a BBCode string to HTML:
+
+```ruby
+'This is [b]bold[/b] and this is [i]italic[/i].'.bbcode_to_html
+ => 'This is <strong>bold</strong> and this is <em>italic</em>.'
+ ```
+
+`bbcode_show_errors` can be used to convert a BBCode to BBCode annotated with errors (assuming the original BBCode did contain errors):
+
+```ruby
+'[img=no_dimensions_here]image.png[/img]'.bbcode_show_errors
+ => '<span class=\'bbcode_error\' data-bbcode-errors=\'["The image parameters \'no_dimensions_here\' are incorrect, \'<width>x<height>\' excepted"]\'>[img]</span>image.png[/img]'
+ ```
+
+These HTML attributes containing the JSON representation of the errors can be used to inform the user about the problems.
+The following JavaScript/jQuery example makes use of the [Bootstrap tooltips plugin](http://getbootstrap.com/javascript/#tooltips) to show the errors in tooltip popups:
+```javascript
+$(".bbcode_error").tooltip({
+  title: function() {
+    var errors = JSON.parse($(this).attr('data-bbcode-errors'));
+    return errors.join("\n");
+  }
+});
+```
+
+## Installing
+
+Add the following line to the Gemfile of your application:
+```ruby
+gem 'ruby-bbcode'
+```
+
+Or to use the source code from the repository:
+```ruby
+gem 'ruby-bbcode', :git => 'git://github.com/veger/ruby-bbcode.git'
+```
+
+Run
+```shell
+bundle install
+```
+
+And Ruby-BBCode is available in your application.
+
+_Note_: Do not forget to restart your server!
+
+## Acknowledgements
+
+A big thanks to [@TheNotary](https://github.com/TheNotary) for all contributions he made to this project!
+
+Some of the ideas and the tests came from [bb-ruby](https://github.com/cpjolicoeur/bb-ruby) of Craig P Jolicoeur.
+
+## License
+
+MIT License. See the included [MIT-LICENCE](MIT-LICENSE) file.

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
 
@@ -46,15 +47,22 @@ module RubyBBCode
 
     # Step down the bbtree a notch because we've reached a closing tag
     def retrogress_bbtree
-      @tags_list.pop     # remove latest tag in tags_list since it's closed now...
+      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!
+        @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...
       # The parsed data manifests in @bbtree.current_node.children << TagNode.new(element) which I think is more confusing than needed
 
-      if within_open_tag?
-        # Set the current node to be the node we've just parsed over which is infact within another node??...
-        @current_node = TagNode.new(self.nodes.last)
-      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
@@ -63,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