ruby-bbcode 2.0.3 → 2.1.0

data/lib/ruby-bbcode/tag_sifter.rb

@@ -8,10 +8,10 @@ module RubyBBCode
     attr_reader :bbtree, :errors
 
     def initialize(text_to_parse, dictionary, escape_html = true)
-      @text = escape_html ? text_to_parse.gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', "&quot;") : text_to_parse
+      @text = escape_html ? text_to_parse.gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;') : text_to_parse
 
       @dictionary = dictionary # dictionary containing all allowed/defined tags
-      @bbtree = BBTree.new({:nodes => TagCollection.new})
+      @bbtree = BBTree.new(nodes: TagCollection.new)
       @ti = nil
       @errors = []
     end
@@ -25,34 +25,33 @@ module RubyBBCode
     # once this tree is built, the to_html method can be invoked where the tree is finally
     # converted into HTML syntax.
     def process_text
-      regex_string = '((\[ (\/)? ( \* | (\w+)) ((=[^\[\]]+) | (\s\w+=\w+)* | ([^\]]*))? \]) | ([^\[]+))'
-      @text.scan(/#{regex_string}/ix) do |tag_info|
+      @text.scan(TagInfo::REGEX) do |tag_info|
         @ti = TagInfo.new(tag_info, @dictionary)
 
-        # if the tag isn't in the @dictionary list, then treat it as text
-        @ti.handle_tag_as_text if @ti.element_is_tag? and !@ti.tag_in_dictionary?
-
         validate_element
 
         case @ti.type
         when :opening_tag
-          element = {:is_tag => true, :tag => @ti[:tag], :definition => @ti.definition, :errors => @ti[:errors], :nodes => TagCollection.new }
+          element = { is_tag: true, tag: @ti[:tag], definition: @ti.definition, opening_whitespace: @ti.whitespace, errors: @ti[:errors], nodes: TagCollection.new }
           element[:invalid_quick_param] = true if @ti.invalid_quick_param?
           element[:params] = get_formatted_element_params
 
-          @bbtree.retrogress_bbtree if self_closing_tag_reached_a_closer?
+          if self_closing_tag_reached_a_closer?
+            transfer_whitespace_to_closing_tag
+            @bbtree.retrogress_bbtree
+          end
 
           @bbtree.build_up_new_tag(element)
 
           @bbtree.escalate_bbtree(element)
         when :text
           tag_def = @bbtree.current_node.definition
-          if tag_def and tag_def[:multi_tag] == true
+          if tag_def && (tag_def[:multi_tag] == true)
             set_multi_tag_to_actual_tag
             tag_def = @bbtree.current_node.definition
           end
 
-          if within_open_tag? and tag_def[:require_between]
+          if within_open_tag? && tag_def[:require_between]
             between = get_formatted_between
             @bbtree.current_node[:between] = between
             if use_text_as_parameter?
@@ -63,7 +62,7 @@ module RubyBBCode
                   add_element = true
 
                   # ...and clear between, as this would result in two 'between' texts
-                  @bbtree.current_node[:between] = ""
+                  @bbtree.current_node[:between] = ''
                 end
               else
                 # Between text can be used as (first) parameter
@@ -76,16 +75,20 @@ module RubyBBCode
 
           create_text_element
         when :closing_tag
+          @bbtree.current_node[:closing_whitespace] = @ti.whitespace
           if @ti[:wrong_closing]
             # Convert into text, so it
             @ti.handle_tag_as_text
             create_text_element
           else
-            @bbtree.retrogress_bbtree if parent_of_self_closing_tag? and within_open_tag?
+            if parent_of_self_closing_tag? && within_open_tag?
+              transfer_whitespace_to_closing_tag
+              @bbtree.retrogress_bbtree
+            end
             @bbtree.retrogress_bbtree
           end
         end
-      end # end of scan loop
+      end
 
       validate_all_tags_closed_off
       validate_stack_level_too_deep_potential
@@ -93,6 +96,25 @@ module RubyBBCode
 
     private
 
+    def transfer_whitespace_to_closing_tag
+      last_text_node = node_last_text(parent_tag)
+      unless last_text_node.nil?
+        last_text_node[:text].scan(/(\s+)$/) do |result|
+          parent_tag[:closing_whitespace] = result[0]
+          last_text_node[:text] = last_text_node[:text][0..-result[0].length - 1]
+        end
+      end
+    end
+
+    # Return the node that holds the last piece of text for the given node (self or child)
+    def node_last_text(node)
+      return node if node.type == :text
+      return node_last_text(node.children[-1]) unless node.children.empty?
+
+      # node does not hold text
+      nil
+    end
+
     def set_multi_tag_to_actual_tag
       # Try to find the actual tag
       tag = get_actual_tag
@@ -121,7 +143,7 @@ module RubyBBCode
     end
 
     def create_text_element
-      element = {:is_tag => false, :text => @ti.text, :errors => @ti[:errors] }
+      element = { is_tag: false, text: @ti.text, errors: @ti[:errors] }
       @bbtree.build_up_new_tag(element)
     end
 
@@ -132,26 +154,26 @@ module RubyBBCode
         # perform special formatting for certain tags
         params[:url] = match_url_id(params[:url], @ti.definition[:url_matches])
       end
-      return params
+      params
     end
 
     # Get 'between tag' for tag
     def get_formatted_between
       between = @ti[:text]
-      # perform special formatting for cenrtain tags
+      # perform special formatting for certain tags
       between = match_url_id(between, @bbtree.current_node.definition[:url_matches]) if @bbtree.current_node.definition[:url_matches]
-      return between
+      between
     end
 
     def match_url_id(url, regex_matches)
       regex_matches.each do |regex|
         if url =~ regex
-          id = $1
+          id = Regexp.last_match(1)
           return id
         end
       end
 
-      return url # if we couldn't find a match, then just return the url, hopefully it's a valid ID...
+      url # if we couldn't find a match, then just return the url, hopefully it's a valid ID...
     end
 
     # Validates the element
@@ -162,7 +184,7 @@ module RubyBBCode
     end
 
     def valid_text_or_opening_element?
-      if @ti.element_is_text? or @ti.element_is_opening_tag?
+      if @ti.element_is_text? || @ti.element_is_opening_tag?
         return false unless valid_opening_tag?
         return false unless valid_constraints_on_child?
       end
@@ -171,7 +193,7 @@ module RubyBBCode
 
     def valid_opening_tag?
       if @ti.element_is_opening_tag?
-        if @ti.only_allowed_in_parent_tags? and (!within_open_tag? or !@ti.allowed_in? parent_tag[:tag]) and !self_closing_tag_reached_a_closer?
+        if @ti.only_allowed_in_parent_tags? && (!within_open_tag? || !@ti.allowed_in?(parent_tag[:tag])) && !self_closing_tag_reached_a_closer?
           # Tag doesn't belong in the last opened tag
           throw_child_requires_specific_parent_error
           return false
@@ -183,19 +205,15 @@ module RubyBBCode
         end
 
         # Note that if allow_between_as_param is true, other checks already test the (correctness of the) 'between parameter'
-        unless @ti.definition[:param_tokens].nil? or @ti.definition[:allow_between_as_param] == true
+        unless @ti.definition[:param_tokens].nil? || (@ti.definition[:allow_between_as_param] == true)
           # Check if all required parameters are added
           @ti.definition[:param_tokens].each do |token|
-            if @ti[:params][token[:token]].nil? and token[:optional].nil?
-              add_tag_error "Tag [#{@ti[:tag]}] must have '#{token[:token]}' parameter"
-            end
+            add_tag_error "Tag [#{@ti[:tag]}] must have '#{token[:token]}' parameter" if @ti[:params][token[:token]].nil? && token[:optional].nil?
           end
 
           # Check if no 'custom parameters' are added
           @ti[:params].keys.each do |token|
-            if @ti.definition[:param_tokens].find {|param_token| param_token[:token]==token}.nil?
-              add_tag_error "Tag [#{@ti[:tag]}] doesn't have a '#{token}' parameter"
-            end
+            add_tag_error "Tag [#{@ti[:tag]}] doesn't have a '#{token}' parameter" if @ti.definition[:param_tokens].find { |param_token| param_token[:token] == token }.nil?
           end
         end
       end
@@ -203,15 +221,15 @@ module RubyBBCode
     end
 
     def self_closing_tag_reached_a_closer?
-      @ti.definition[:self_closable] and @bbtree.current_node[:tag] == @ti[:tag]
+      @ti.definition[:self_closable] && (@bbtree.current_node[:tag] == @ti[:tag])
     end
 
     def valid_constraints_on_child?
-      if within_open_tag? and parent_has_constraints_on_children?
+      if within_open_tag? && parent_has_constraints_on_children?
         # Check if the found tag is allowed
         last_tag_def = parent_tag[:definition]
         allowed_tags = last_tag_def[:only_allow]
-        if (!@ti[:is_tag] and last_tag_def[:require_between] != true and @ti[:text].lstrip != "") or (@ti[:is_tag] and (allowed_tags.include?(@ti[:tag]) == false))  # TODO: refactor this, it's just too long
+        if (!@ti.element_is_tag? && (last_tag_def[:require_between] != true) && (@ti[:text].lstrip != '')) || (@ti.element_is_tag? && (allowed_tags.include?(@ti[:tag]) == false)) # TODO: refactor this, it's just too long
           # Last opened tag does not allow tag
           throw_parent_prohibits_this_child_error
           return false
@@ -221,7 +239,6 @@ module RubyBBCode
     end
 
     def valid_closing_element?
-
       if @ti.element_is_closing_tag?
 
         if parent_tag.nil?
@@ -230,9 +247,9 @@ module RubyBBCode
           return false
         end
 
-        if parent_tag[:tag] != @ti[:tag] and !parent_of_self_closing_tag?
+        if (parent_tag[:tag] != @ti[:tag]) && !parent_of_self_closing_tag?
           # Make an exception for 'supported tags'
-          if @ti.definition[:supported_tags].nil? or ! @ti.definition[:supported_tags].include? parent_tag[:tag]
+          if @ti.definition[:supported_tags].nil? || !@ti.definition[:supported_tags].include?(parent_tag[:tag])
             add_tag_error "Closing tag [/#{@ti[:tag]}] doesn't match [#{parent_tag[:tag]}]"
             @ti[:wrong_closing] = true
             return false
@@ -240,7 +257,7 @@ module RubyBBCode
         end
 
         tag_def = @bbtree.current_node.definition
-        if tag_def[:require_between] and @bbtree.current_node[:between].nil?
+        if tag_def[:require_between] && @bbtree.current_node[:between].nil? && @bbtree.current_node[:nodes].empty?
           err = "No text between [#{@ti[:tag]}] and [/#{@ti[:tag]}] tags."
           err = "Cannot determine multi-tag type: #{err}" if tag_def[:multi_tag]
           add_tag_error err, @bbtree.current_node
@@ -253,14 +270,14 @@ module RubyBBCode
     def parent_of_self_closing_tag?
       was_last_tag_self_closable = @bbtree.current_node[:definition][:self_closable] unless @bbtree.current_node[:definition].nil?
 
-      was_last_tag_self_closable and last_tag_fit_in_this_tag?
+      was_last_tag_self_closable && last_tag_fit_in_this_tag?
     end
 
     def last_tag_fit_in_this_tag?
-      @ti.definition[:only_allow].each do |tag|
+      @ti.definition[:only_allow]&.each do |tag|
         return true if tag == @bbtree.current_node[:tag]
-      end unless @ti.definition[:only_allow].nil?
-      return false
+      end
+      false
     end
 
     # This validation is for text elements with between text
@@ -270,8 +287,13 @@ module RubyBBCode
     def valid_param_supplied_as_text?
       tag_def = @bbtree.current_node.definition
 
+      if within_open_tag? && use_text_as_parameter? && @ti.element_is_tag? && has_no_text_node?
+        add_tag_error 'between parameter must be plain text'
+        return false
+      end
+
       # this conditional ensures whether the validation is apropriate to this tag type
-      if @ti.element_is_text? and within_open_tag? and tag_def[:require_between] and use_text_as_parameter? and not tag_def[:quick_param_format].nil?
+      if @ti.element_is_text? && within_open_tag? && tag_def[:require_between] && use_text_as_parameter? && !tag_def[:quick_param_format].nil?
 
         # check if valid
         if @ti[:text].match(tag_def[:quick_param_format]).nil?
@@ -283,19 +305,17 @@ module RubyBBCode
     end
 
     def validate_all_tags_closed_off
+      return unless expecting_a_closing_tag?
+
       # if we're still expecting a closing tag and we've come to the end of the string... throw error(s)
-      if expecting_a_closing_tag?
-        @bbtree.tags_list.each do |tag|
-          add_tag_error "[#{tag[:tag]}] not closed", tag
-          tag[:closed] = false
-        end
+      @bbtree.tags_list.each do |tag|
+        add_tag_error "[#{tag[:tag]}] not closed", tag
+        tag[:closed] = false
       end
     end
 
     def validate_stack_level_too_deep_potential
-      if @bbtree.nodes.count > 2200
-        throw_stack_level_will_be_too_deep_error
-      end
+      throw_stack_level_will_be_too_deep_error if @bbtree.nodes.count > 2200
     end
 
     def throw_child_requires_specific_parent_error
@@ -311,20 +331,24 @@ module RubyBBCode
     def throw_parent_prohibits_this_child_error
       allowed_tags = parent_tag[:definition][:only_allow]
       err = "[#{parent_tag[:tag]}] can only contain [#{allowed_tags.to_sentence(to_sentence_bbcode_tags)}] tags, so "
-      err += "[#{@ti[:tag]}]" if @ti[:is_tag]
-      err += "\"#{@ti[:text]}\"" unless @ti[:is_tag]
+      err += "[#{@ti[:tag]}]" if @ti.element_is_tag?
+      err += "\"#{@ti[:text]}\"" unless @ti.element_is_tag?
       err += ' is not allowed'
       add_tag_error err
     end
 
     def throw_stack_level_will_be_too_deep_error
-      @errors << "Stack level would go too deep.  You must be trying to process a text containing thousands of BBTree nodes at once.  (limit around 2300 tags containing 2,300 strings).  Check RubyBBCode::TagCollection#to_html to see why this validation is needed."
+      @errors << 'Stack level would go too deep.  You must be trying to process a text containing thousands of BBTree nodes at once.  (limit around 2300 tags containing 2,300 strings).  Check RubyBBCode::TagCollection#to_html to see why this validation is needed.'
     end
 
     def to_sentence_bbcode_tags
-      {:words_connector => "], [",
-        :two_words_connector => "] and [",
-        :last_word_connector => "] and ["}
+      { words_connector: '], [',
+        two_words_connector: '] and [',
+        last_word_connector: '] and [' }
+    end
+
+    def has_no_text_node?
+      @bbtree.current_node[:nodes].blank? || @bbtree.current_node[:nodes][0][:text].nil?
     end
 
     def expecting_a_closing_tag?
@@ -337,7 +361,7 @@ module RubyBBCode
 
     def use_text_as_parameter?
       tag = @bbtree.current_node
-      tag.definition[:allow_between_as_param] and tag.params_not_set? and !tag.invalid_quick_param?
+      tag.definition[:allow_between_as_param] && tag.params_not_set? && !tag.invalid_quick_param?
     end
 
     def parent_tag

data/lib/ruby-bbcode/templates/bbcode_errors_template.rb

@@ -14,16 +14,15 @@ module RubyBBCode::Templates
     def initialize(node)
       @node = node
       @tag_definition = node.definition # tag_definition
-      @opening_part = "[#{node[:tag]}#{node.allow_params? ? '%param%' : ''}]"
-      unless @node[:errors].empty?
-        @opening_part = "<span class='bbcode_error' #{BBCodeErrorsTemplate.error_attribute(@node[:errors])}>#{@opening_part}</span>"
-      end
-      @closing_part = "[/#{node[:tag]}]"
+      @opening_part = "[#{node[:tag]}#{node.allow_params? ? '%param%' : ''}]" + add_whitespace(node[:opening_whitespace])
+      @opening_part = "<span class='bbcode_error' #{BBCodeErrorsTemplate.error_attribute(@node[:errors])}>#{@opening_part}</span>" unless @node[:errors].empty?
+      @closing_part = "[/#{node[:tag]}]" + add_whitespace(node[:closing_whitespace])
     end
 
-    def self.convert_text(node)
+    def self.convert_text(node, _parent_node)
       # Keep the text as it was
       return "<span class='bbcode_error' #{error_attribute(node[:errors])}>#{node[:text]}</span>" unless node[:errors].empty?
+
       node[:text]
     end
 
@@ -41,8 +40,7 @@ module RubyBBCode::Templates
       end
     end
 
-    def inlay_closing_part!
-    end
+    def inlay_closing_part!; end
 
     def remove_unused_tokens!
       @opening_part.gsub!('%param%', '')
@@ -54,15 +52,20 @@ module RubyBBCode::Templates
 
     private
 
-      def get_between
-        return @node[:between] if @tag_definition[:require_between] and @node[:between]
-        ''
-      end
+    def add_whitespace(whitespace)
+      whitespace || ''
+    end
 
-      def self.error_attribute(errors)
-        # Escape (double) quotes so the JSON can be generated properly (and parsed properly by JavaScript)
-        escapedErrors = errors.map { |error| error.gsub("\"","&quot;").gsub("'", "&#39;")}
-        "data-bbcode-errors='#{JSON.fast_generate(escapedErrors)}'"
-      end
+    def get_between
+      return @node[:between] if @tag_definition[:require_between] && @node[:between]
+
+      ''
+    end
+
+    def self.error_attribute(errors)
+      # Escape (double) quotes so the JSON can be generated properly (and parsed properly by JavaScript)
+      escapedErrors = errors.map { |error| error.gsub('"', '&quot;').gsub("'", '&#39;') }
+      "data-bbcode-errors='#{JSON.fast_generate(escapedErrors)}'"
+    end
   end
 end

data/lib/ruby-bbcode/templates/html_template.rb

@@ -10,20 +10,30 @@ module RubyBBCode::Templates
 
     def initialize(node)
       @node = node
-      @tag_definition = node.definition # tag_definition
-      @opening_part = node.definition[:html_open].dup
-      @closing_part = node.definition[:html_close].dup
+      @tag_definition = node.definition
+      @opening_part = node.definition[:html_open] + add_whitespace(:opening_whitespace)
+      @closing_part = node.definition[:html_close] + add_whitespace(:closing_whitespace)
     end
 
     # Newlines are converted to html <br /> syntax before being returned.
-    def self.convert_text(node)
+    def self.convert_text(node, parent_node)
       return '' if node[:text].nil?
-      # convert_newlines_to_br
-      node[:text].gsub("\r\n", "\n").gsub("\n", "<br />\n")
+
+      text = node[:text]
+      whitespace = ''
+
+      if !parent_node.nil? && parent_node.definition[:block_tag]
+        # Strip EOL whitespace, so it does not get converted
+        text.scan(/(\s+)$/) do |result|
+          whitespace = result[0]
+          text = text[0..-result[0].length - 1]
+        end
+      end
+      convert_newlines(text) + whitespace
     end
 
     def inlay_between_text!
-      @opening_part.gsub!('%between%', @node[:between]) if between_text_as_param?
+      @opening_part.gsub!('%between%', format_between) if between_text_as_param?
     end
 
     def inlay_params!
@@ -31,12 +41,12 @@ module RubyBBCode::Templates
       @tag_definition[:param_tokens].each do |token|
         param_value = @node[:params][token[:token]] || token[:default]
         param_value = CGI.escape(param_value) if token[:uri_escape]
-        @opening_part.gsub!("%#{token[:token].to_s}%", "#{token[:prefix]}#{param_value}#{token[:postfix]}") unless param_value.nil?
+        @opening_part.gsub!("%#{token[:token]}%", "#{token[:prefix]}#{param_value}#{token[:postfix]}") unless param_value.nil?
       end
     end
 
     def inlay_closing_part!
-      @closing_part.gsub!('%between%', @node[:between]) if between_text_as_param?
+      @closing_part.gsub!('%between%', format_between) if between_text_as_param?
     end
 
     def remove_unused_tokens!
@@ -45,11 +55,27 @@ module RubyBBCode::Templates
       end
     end
 
+    def self.convert_newlines(text)
+      text.gsub("\r\n", "\n").gsub("\n", "<br />\n")
+    end
+
     private
 
+    def add_whitespace(key)
+      whitespace = @node[key]
+      return '' if whitespace.nil?
+
+      whitespace = HtmlTemplate.convert_newlines(whitespace) unless @tag_definition[:block_tag]
+      whitespace
+    end
+
     # Return true if the between text is needed as param
     def between_text_as_param?
       @tag_definition[:require_between]
     end
+
+    def format_between
+      @node[:between] || ''
+    end
   end
-end
+end