ruby-bbcode 1.0.1 → 2.0.0

data/lib/ruby-bbcode/tag_info.rb

@@ -1,125 +1,123 @@
 module RubyBBCode
-  # TagInfo is basically what the regex scan get's converted into 
-  # during the tag_sifter#process_text method.
-  # This class was made mostly just to keep track of all of the confusing
-  # the logic conditions that are checked.  
+  # TagInfo is basically what the regex scan get's converted into during the TagSifter#process_text method.
+  # This class was made mostly just to keep track of all of the confusing the logic conditions that are checked.
   #
   class TagInfo
     def initialize(tag_info, dictionary)
-      @tag_data = find_tag_info(tag_info)
-      @dictionary = dictionary
-      @definition = @dictionary[@tag_data[:tag].to_sym] unless @tag_data[:tag].nil?
+      @tag_data = find_tag_info(tag_info, dictionary)
     end
-    
+
     def [](key)
       @tag_data[key]
     end
-    
+
     def []=(key, value)
       @tag_data[key] = value
     end
-    
-    def tag_data
-      @tag_data
-    end
-    
+
+    # Returns the definition of this instance (when it represents a tag element)
     def definition
       @definition
     end
-    
-    def definition=(val)
-      @definition = val
-    end
-    
-    def dictionary   # need this for reasigning multi_tag elements
-      @dictionary
-    end
-    
-    # This represents the text value of the element (if it's not a tag element)
-    # Newlines are converted to html <br /> syntax before being returned.  
+
+    # Returns the text (when this instance represents a text element)
     def text
-      text = @tag_data[:text]
-      # convert_newlines_to_br  
-      text.gsub!("\r\n", "\n")
-      text.gsub!("\n", "<br />\n")
-      text
-    end
-    
-    # allows for a very snazy case/ when conditional
+      @tag_data[:text]
+    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?
       return :text if element_is_text?
       return :closing_tag if element_is_closing_tag?
     end
-    
-    def handle_unregistered_tags_as_text
-      if element_is_tag? and tag_missing_from_tag_dictionary?
-        # Handle as text from now on!
-        self[:is_tag] = false
-        self[:closing_tag] = false
-        self[:text] = self[:complete_match]
-      end
+
+    # Converts this instance (from a tag) into a text element
+    def handle_tag_as_text
+      self[:is_tag] = false
+      self[:closing_tag] = false
+      self[:text] = self[:complete_match]
     end
-    
+
+    # Returns true if this instance represents a tag element
     def element_is_tag?
       self[:is_tag]
     end
-    
+
+    # Returns true if this instance represents a text element
+    def element_is_text?
+      !self[:is_tag]
+    end
+
+    # Returns true if this instance represents an opening tag element
     def element_is_opening_tag?
       self[:is_tag] and !self[:closing_tag]
     end
-    
+
+    # Returns true if this instance represents a closing tag element
     def element_is_closing_tag?
-      self[:closing_tag]
-    end
-    
-    def element_is_text?
-      !self[:text].nil?
-    end
-    
-    def has_params?
-      self[:params][:tag_param] != nil
-    end
-    
-    def tag_missing_from_tag_dictionary?
-      !@dictionary.include?(self[:tag].to_sym)
+      self[:is_tag] and  self[:closing_tag]
     end
-    
-    def allowed_outside_parent_tags?
-      @definition[:only_in].nil?
+
+    # Returns true if this tag element is included in the set of available tags
+    def tag_in_dictionary?
+      !@definition.nil?
     end
-    
-    def constrained_to_within_parent_tags?
+
+    # Returns true if the tag that is represented by this instance is restricted on where it is allowed, i.e. if it is restricted by certain parent tags.
+    def only_allowed_in_parent_tags?
       !@definition[:only_in].nil?
     end
-    
-    def allowed_in(tag_symbol)
-      @definition[:only_in].include?(tag_symbol)
+
+    # 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)
     end
-    
-    def can_have_params?
-      @definition[:allow_tag_param]
+
+    # Returns true if this tag has quick parameter support
+    def can_have_quick_param?
+      @definition[:allow_quick_param]
     end
 
-    # Checks if the tag param matches the regex pattern defined in tags.rb
-    def invalid_param?
-      self[:params][:tag_param].match(@definition[:tag_param]).nil?
+    # Returns true if the tag param matches the regex pattern defined in tags.rb
+    def invalid_quick_param?
+      @tag_data.key? :invalid_quick_param
     end
-    
+
     protected
-    
-    def find_tag_info(tag_info)
+
+    # 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? '[')
       if ti[:is_tag]
         ti[:closing_tag] = (tag_info[2] == '/')
-        ti[:tag] = tag_info[3]
+        ti[:tag] = tag_info[3].to_sym.downcase
         ti[:params] = {}
-        if tag_info[5][0] == ?=
-          ti[:params][:tag_param] = tag_info[5][1..-1]
+        @definition = dictionary[ti[:tag]]
+        if tag_info[5][0] == ?= and can_have_quick_param?
+          quick_param = tag_info[5][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?
+            ti[:invalid_quick_param] = quick_param
+          else
+            param_tokens = @definition[:param_tokens]
+            value_array[0..param_tokens.length - 1].each.with_index do |value, i|
+              ti[:params][param_tokens[i][:token]] = value
+            end
+          end
         elsif tag_info[5][0] == ?\s
-          #FIXME: Find params... Delete this or write a test to cover this and implement it
+          regex_string = '((\w+)=([\w#]+)) | ((\w+)="([^"]+)") | ((\w+)=\'([^\']+)\')'
+          tag_info[5].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
+          end
         end
       else
         # Plain text
@@ -127,6 +125,5 @@ module RubyBBCode
       end
       ti
     end
-    
   end
 end

data/lib/ruby-bbcode/tag_node.rb

@@ -6,7 +6,7 @@ module RubyBBCode
   class TagNode
     # Tag or text element that is stored in this node
     attr_accessor :element
-    
+
     # ==== Attributes
     #
     # * +element+ - contains the information of TagInfo#tag_data.
@@ -18,54 +18,48 @@ module RubyBBCode
     def initialize(element, nodes = [])
       @element = element
     end
-    
+
     def [](key)
       @element[key]
     end
-    
+
     def []=(key, value)
       @element[key] = value
     end
-    
-    # Debugging/ visualization purposes
+
+    # Returns :tag is the node is a tag node, and :text if the node is a text node
     def type
-      return :tag if @element[:is_tag]
-      return :text if !@element[:is_tag]
+      @element[:is_tag] ? :tag : :text
     end
-    
-    # Checks to see if the parameter for the TagNode has been set.  
-    def param_not_set?
-      (@element[:params].nil? or @element[:params][:tag_param].nil?)
+
+    # Returns true if the tag is allowed to have parameters
+    def allow_params?
+      definition[:param_tokens]
     end
-    
-    # check if the parameter for the TagNode is set
-    def param_set?
-      !param_not_set?
+
+    # Returns true if the tag does not have any parameters set.
+    def params_not_set?
+      @element[:params].length == 0
     end
-    
+
+    # Returns true id the node that child nodes
     def has_children?
-      return false if type == :text or children.length == 0  # text nodes return false too
-      return true if children.length > 0
+      type == :tag and children.length > 0
     end
-    
-    def allow_tag_param?
-      definition[:allow_tag_param]
+
+    # Returns true when the quick parameter was invalid (i.e. it did not match the required format)
+    def invalid_quick_param?
+      @element.key? :invalid_quick_param
     end
-    
+
     # shows the tag definition for this TagNode as defined in tags.rb
     def definition
       @element[:definition]
     end
-    
+
+    # Return an list containing the child nodes of this node.
     def children
       @element[:nodes]
     end
-    
-    # Easy way to set the tag_param value of the hash, which represents 
-    # the parameter supplied
-    def tag_param=(param)
-      @element[:params] = {:tag_param => param}
-    end
-    
   end
-end
+end

data/lib/ruby-bbcode/tag_sifter.rb

@@ -6,135 +6,144 @@ module RubyBBCode
   #    "[b]I'm bold and the next word is [i]ITALIC[/i][b]"
   class TagSifter
     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
-      
-      @dictionary = dictionary # the dictionary for all the defined tags in tags.rb
-      @bbtree = BBTree.new({:nodes => TagCollection.new}, dictionary)
+
+      @dictionary = dictionary # dictionary containing all allowed/defined tags
+      @bbtree = BBTree.new({:nodes => TagCollection.new})
       @ti = nil
-      @errors = false
+      @errors = []
     end
-    
-    def invalid?
-      @errors != false
+
+    def valid?
+      @errors.empty?
     end
-    
-    # BBTree#process_text is responsible for parsing the actual BBCode text and converting it 
+
+    # BBTree#process_text is responsible for parsing the actual BBCode text and converting it
     # into a 'syntax tree' of nodes, each node represeting either a tag type or content for a tag
-    # once this tree is built, the to_html method can be invoked where the tree is finally 
-    # converted into HTML syntax.  
+    # 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|
         @ti = TagInfo.new(tag_info, @dictionary)
-        
-        @ti.handle_unregistered_tags_as_text  # if the tag isn't in the @dictionary list, then treat it as text
-        handle_closing_tags_that_are_multi_as_text_if_it_doesnt_match_the_latest_opener_tag_on_the_stack
-        
-        return if !valid_element?
-        
-        case @ti.type   # Validation of tag succeeded, add to @bbtree.tags_list and/or bbtree
+
+        # 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].to_sym, :definition => @ti.definition, :nodes => TagCollection.new }
-          element[:params] = {:tag_param => get_formatted_element_params} if @ti.can_have_params? and @ti.has_params?
-          
+          element = {:is_tag => true, :tag => @ti[:tag], :definition => @ti.definition, :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?
-          
+
           @bbtree.build_up_new_tag(element)
-          
+
           @bbtree.escalate_bbtree(element)
         when :text
-          set_parent_tag_from_multi_tag_to_concrete! if @bbtree.current_node.definition && @bbtree.current_node.definition[:multi_tag] == true
-          element = {:is_tag => false, :text => @ti.text }
-          if within_open_tag?
-            tag = @bbtree.current_node.definition
-            if tag[:require_between]
-              @bbtree.current_node[:between] = get_formatted_element_params
-              if candidate_for_using_between_as_param?
-                use_between_as_tag_param    # Did not specify tag_param, so use between text.
+          tag_def = @bbtree.current_node.definition
+          if tag_def and 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]
+            between = get_formatted_between
+            @bbtree.current_node[:between] = between
+            if use_text_as_parameter?
+              value_array = tag_def[:quick_param_format].nil? ? true : between.scan(tag_def[:quick_param_format])[0]
+              if value_array.nil?
+                if @ti[:invalid_quick_param].nil?
+                  # Add text element (with error(s))
+                  add_element = true
+
+                  # ...and clear between, as this would result in two 'between' texts
+                  @bbtree.current_node[:between] = ""
+                end
+              else
+                # Between text can be used as (first) parameter
+                @bbtree.current_node[:params][tag_def[:param_tokens][0][:token]] = between
               end
-              next  # don't add this node to @bbtree.current_node.children if we're within an open tag that requires_between (to be a param), and the between couldn't be used as a param... Yet it passed validation so the param must have been specified within the opening tag???
             end
+            # Don't add this text node, as it is used as between (and might be used as first param)
+            next unless add_element
           end
-          @bbtree.build_up_new_tag(element)
+
+          create_text_element
         when :closing_tag
-          @bbtree.retrogress_bbtree if parent_of_self_closing_tag? and @bbtree.within_open_tag?
-          @bbtree.retrogress_bbtree
+          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?
+            @bbtree.retrogress_bbtree
+          end
         end
-        
       end # end of scan loop
-      
-      validate_all_tags_closed_off   # TODO: consider automatically closing off all the tags... I think that's how the HTML 5 parser works too
+
+      validate_all_tags_closed_off
       validate_stack_level_too_deep_potential
     end
-    
-    def set_parent_tag_from_multi_tag_to_concrete!
-      # if the proper tag can't be matched, we need to treat the parent tag as text instead!  Or throw an error message....
-      
-      proper_tag = get_proper_tag
-      if proper_tag == :tag_not_found
-        @bbtree.redefine_parent_tag_as_text
-        
-        @bbtree.nodes << TagNode.new(@ti.tag_data)      # escalate the bbtree with this element as though it's regular text data...
-        return
+
+    private
+
+    def set_multi_tag_to_actual_tag
+      # Try to find the actual tag
+      tag = get_actual_tag
+      if tag == :tag_not_found
+        # Add error
+        add_tag_error "Unknown multi-tag type for [#{@bbtree.current_node[:tag]}]", @bbtree.current_node
+      else
+        # Update current_node with found information, so it behaves as the actual tag
+        @bbtree.current_node[:definition] = @dictionary[tag]
+        @bbtree.current_node[:tag] = tag
       end
-      @bbtree.current_node[:definition] = @dictionary[proper_tag]
-      @bbtree.current_node[:tag] = proper_tag
     end
 
-    def get_proper_tag
+    # The media tag support multiple other tags, this method checks the tag url param to find actual tag type (to use)
+    def get_actual_tag
       supported_tags = @bbtree.current_node[:definition][:supported_tags]
 
       supported_tags.each do |tag|
         regex_list = @dictionary[tag][:url_matches]
-        
+
         regex_list.each do |regex|
-          return tag if regex =~ @ti.tag_data[:text]
+          return tag if regex =~ @ti.text
         end
       end
       :tag_not_found
     end
-    
-    def handle_closing_tags_that_are_multi_as_text_if_it_doesnt_match_the_latest_opener_tag_on_the_stack
-      if @ti.element_is_closing_tag?
-        return if @bbtree.current_node[:definition].nil?
-        if parent_tag != @ti[:tag].to_sym and @bbtree.current_node[:definition][:multi_tag]       # if opening tag doesn't match this closing tag... and if the opener was a multi_tag...
-          @ti[:is_tag] = false
-          @ti[:closing_tag] = false
-          @ti[:text] = @ti.tag_data[:complete_match]
-        end
-      end
-      
+
+    def create_text_element
+      element = {:is_tag => false, :text => @ti.text, :errors => @ti[:errors] }
+      @bbtree.build_up_new_tag(element)
     end
-    
-    
-    private
-    
-    # This method allows us to format params if needed...  
-    # TODO:  Maybe this kind of thing *could* be handled in the bbtree_to_html where the %between% is
-    # sorted out and the html is generated, but...  That code has yet to be refactored and we can.
-    # refactor this code easily to happen over there if necessary...  Yes, I think it's more logical 
-    # to be put over there, but that method needs to be cleaned up before we introduce the formatting overthere... and knowing the parent node is helpful!    
+
+    # Gets the params, and format them if needed...
     def get_formatted_element_params
-      if @ti[:is_tag]
-        param = @ti[:params][:tag_param]
-        if @ti.can_have_params? and @ti.has_params?
-          # perform special formatting for cenrtain tags
-          param = conduct_special_formatting(param) if @ti[:tag].to_sym == :youtube  # note:  this line isn't ever used because @@tags don't allow it... I think if we have tags without the same kind of :require_between restriction, we'll need to pay close attention to this case
-        end
-        return param
-      else  # must be text... @ti[:is_tag] == false
-        param = @ti[:text]
-        # perform special formatting for cenrtain tags
-        param = conduct_special_formatting(param) if @bbtree.current_node.definition[:url_matches]
-        return param
+      params = @ti[:params]
+      if @ti.definition[:url_matches]
+        # perform special formatting for certain tags
+        params[:url] = match_url_id(params[:url], @ti.definition[:url_matches])
       end
+      return params
+    end
+
+    # Get 'between tag' for tag
+    def get_formatted_between
+      between = @ti[:text]
+      # perform special formatting for cenrtain tags
+      between = match_url_id(between, @bbtree.current_node.definition[:url_matches]) if @bbtree.current_node.definition[:url_matches]
+      return between
     end
-    
-    def conduct_special_formatting(url, regex_matches = nil)
-      regex_matches = @bbtree.current_node.definition[:url_matches] if regex_matches.nil?   # for testing purposes we can force in regex_matches
-      
+
+    def match_url_id(url, regex_matches)
       regex_matches.each do |regex|
         if url =~ regex
           id = $1
@@ -142,188 +151,209 @@ module RubyBBCode
         end
       end
 
-      return url # if we couldn't find a match, then just return the url, hopefully it's a valid youtube ID...
+      return url # if we couldn't find a match, then just return the url, hopefully it's a valid ID...
     end
-    
-    
+
     # Validates the element
-    def valid_element?
-      return false if !valid_text_or_opening_element?
-      return false if !valid_closing_element?
-      return false if !valid_param_supplied_as_text?
-      true
+    def validate_element
+      return unless valid_text_or_opening_element?
+      return unless valid_closing_element?
+      return unless valid_param_supplied_as_text?
     end
-    
+
     def valid_text_or_opening_element?
       if @ti.element_is_text? or @ti.element_is_opening_tag?
-        return false if validate_opening_tag == false
-        return false if validate_constraints_on_child == false
+        return false unless valid_opening_tag?
+        return false unless valid_constraints_on_child?
       end
       true
     end
-    
-    def validate_opening_tag
+
+    def valid_opening_tag?
       if @ti.element_is_opening_tag?
-        unless @ti.allowed_outside_parent_tags? or (within_open_tag? and @ti.allowed_in(parent_tag.to_sym)) or self_closing_tag_reached_a_closer?
+        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?
           # Tag doesn't belong in the last opened tag
-          throw_child_requires_specific_parent_error; return false
+          throw_child_requires_specific_parent_error
+          return false
         end
 
-        # Originally:  tag[:allow_tag_param] and ti[:params][:tag_param] != nil
-        if @ti.can_have_params? and @ti.has_params?
-          # Test if matches
-          if @ti.invalid_param?
-            throw_invalid_param_error; return false
+        if @ti.invalid_quick_param?
+          throw_invalid_quick_param_error @ti
+          return false
+        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
+          # 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
+          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
           end
         end
       end
       true
     end
-    
+
     def self_closing_tag_reached_a_closer?
-      @ti.definition[:self_closable] and @bbtree.current_node[:tag] == @ti.tag_data[:tag].to_sym
+      @ti.definition[:self_closable] and @bbtree.current_node[:tag] == @ti[:tag]
     end
-    
-    def validate_constraints_on_child
-      # TODO:  Rename this if statement to #validate_constraints_on_child
+
+    def valid_constraints_on_child?
       if within_open_tag? and parent_has_constraints_on_children?
         # Check if the found tag is allowed
-        last_tag = @dictionary[parent_tag]
-        allowed_tags = last_tag[:only_allow]
-        if (!@ti[:is_tag] and last_tag[:require_between] != true and @ti[:text].lstrip != "") or (@ti[:is_tag] and (allowed_tags.include?(@ti[:tag].to_sym) == false))  # TODO: refactor this, it's just too long
+        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
           # Last opened tag does not allow tag
-          throw_parent_prohibits_this_child_error; return false
+          throw_parent_prohibits_this_child_error
+          return false
         end
       end
       true
     end
-    
+
     def valid_closing_element?
-      tag = @ti.definition
-      
+
       if @ti.element_is_closing_tag?
-        if parent_tag != @ti[:tag].to_sym and !parent_of_self_closing_tag?
-          @errors = ["Closing tag [/#{@ti[:tag]}] doesn't match [#{parent_tag}]"] 
+
+        if parent_tag.nil?
+          add_tag_error "Closing tag [/#{@ti[:tag]}] doesn't match an opening tag"
+          @ti[:wrong_closing] = true
           return false
         end
-        
-        if tag[:require_between] == true and @bbtree.current_node[:between].nil?
-          @errors = ["No text between [#{@ti[:tag]}] and [/#{@ti[:tag]}] tags."]
+
+        if parent_tag[:tag] != @ti[:tag] and !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]
+            add_tag_error "Closing tag [/#{@ti[:tag]}] doesn't match [#{parent_tag[:tag]}]"
+            @ti[:wrong_closing] = true
+            return false
+          end
+        end
+
+        tag_def = @bbtree.current_node.definition
+        if tag_def[:require_between] and @bbtree.current_node[:between].nil?
+          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
           return false
         end
-      end  
+      end
       true
     end
-    
+
     def parent_of_self_closing_tag?
       tag_being_parsed = @ti.definition
       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?
     end
-    
+
     def last_tag_fit_in_this_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
-    
-    # This validation is for text elements with between text 
+
+    # This validation is for text elements with between text
     # that might be construed as a param.
     # The validation code checks if the params match constraints
-    # imposed by the node/tag/parent.  
+    # imposed by the node/tag/parent.
     def valid_param_supplied_as_text?
-      tag = @bbtree.current_node.definition
-      
+      tag_def = @bbtree.current_node.definition
+
       # this conditional ensures whether the validation is apropriate to this tag type
-      if @ti.element_is_text? and within_open_tag? and tag[:require_between] and candidate_for_using_between_as_param?
-      
+      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?
+
         # check if valid
-        if @ti[:text].match(tag[:tag_param]).nil?
-          @errors = [tag[:tag_param_description].gsub('%param%', @ti[:text])]
+        if @ti[:text].match(tag_def[:quick_param_format]).nil?
+          add_tag_error tag_def[:quick_param_format_description].gsub('%param%', @ti[:text])
           return false
         end
       end
       true
     end
-    
+
     def validate_all_tags_closed_off
-      # if we're still expecting a closing tag and we've come to the end of the string... throw error
-      throw_unexpected_end_of_string_error if 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
+      end
     end
-    
+
     def validate_stack_level_too_deep_potential
       if @bbtree.nodes.count > 2200
         throw_stack_level_will_be_too_deep_error
       end
     end
-    
+
     def throw_child_requires_specific_parent_error
       err = "[#{@ti[:tag]}] can only be used in [#{@ti.definition[:only_in].to_sentence(to_sentence_bbcode_tags)}]"
-      err += ", so using it in a [#{parent_tag}] tag is not allowed" if expecting_a_closing_tag?
-      @errors = [err]
+      err += ", so using it in a [#{parent_tag[:tag]}] tag is not allowed" if expecting_a_closing_tag?
+      add_tag_error err
     end
-    
-    def throw_invalid_param_error
-      @errors = [@ti.definition[:tag_param_description].gsub('%param%', @ti[:params][:tag_param])]
+
+    def throw_invalid_quick_param_error(tag)
+      add_tag_error tag.definition[:quick_param_format_description].gsub('%param%', tag[:invalid_quick_param]), tag
     end
-    
+
     def throw_parent_prohibits_this_child_error
-      allowed_tags = @dictionary[parent_tag][:only_allow]
-      err = "[#{parent_tag}] can only contain [#{allowed_tags.to_sentence(to_sentence_bbcode_tags)}] tags, so "
+      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 += ' is not allowed'
-      @errors = [err]
-    end
-    
-    def throw_unexpected_end_of_string_error
-      @errors = ["[#{@bbtree.tags_list.to_sentence(to_sentence_bbcode_tags)}] not closed"]
+      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 [", 
+      {:words_connector => "], [",
+        :two_words_connector => "] and [",
         :last_word_connector => "] and ["}
     end
-    
-    
+
     def expecting_a_closing_tag?
       @bbtree.expecting_a_closing_tag?
     end
-    
+
     def within_open_tag?
       @bbtree.within_open_tag?
     end
-    
-    def use_between_as_tag_param
-      param = get_formatted_element_params
-      @bbtree.current_node.tag_param = param      # @bbtree.current_node[:params] = {:tag_param => @ti[:text]}
-    end
-    
-    def candidate_for_using_between_as_param?
-      # TODO:  the bool values... 
-      # are unclear and should be worked on.  Additional tag might be tag[:requires_param] such that
-      # [img] would have that as true...  and [url] would have that as well...  
-      # as it is now, if a tag (say youtube) has tag[:require_between] == true and tag[:allow_tag_param].nil?
-      # then the :between is assumed to be the param...  that is, a tag that should respond 'true' to tag.requires_param?  
-      tag = @bbtree.current_node.definition
-      tag[:allow_tag_param_between] and @bbtree.current_node.param_not_set?
+
+    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?
     end
-    
+
     def parent_tag
       @bbtree.parent_tag
     end
-    
+
     def parent_has_constraints_on_children?
       @bbtree.parent_has_constraints_on_children?
     end
-    
+
+    private
+
+    def add_tag_error(message, tag = @ti)
+      @errors << message
+      tag[:errors] << message
+    end
   end
 end