solargraph 0.18.3 → 0.19.0

data/lib/solargraph/source/range.rb

@@ -5,13 +5,13 @@ module Solargraph
       attr_reader :start
 
       # @return [Position]
-      attr_reader :end
+      attr_reader :ending
 
       # @param start [Position]
       # @param ending [Position]
       def initialize start, ending
         @start = start
-        @end = ending
+        @ending = ending
       end
 
       # Get a hash of the range. This representation is suitable for use in
@@ -20,10 +20,18 @@ module Solargraph
       def to_hash
         {
           start: start.to_hash,
-          end: self.end.to_hash
+          end: ending.to_hash
         }
       end
 
+      def contain? position
+        return false if position.line < start.line
+        return false if position.line == start.line and position.character < start.character
+        return false if position.line > ending.line
+        return false if position.line == ending.line and position.character > ending.character
+        true
+      end
+
       # Create a range from a pair of lines and characters.
       #
       # @param l1 [Integer] Starting line

data/lib/solargraph/source.rb

@@ -7,8 +7,10 @@ module Solargraph
     autoload :Fragment,      'solargraph/source/fragment'
     autoload :Position,      'solargraph/source/position'
     autoload :Range,         'solargraph/source/range'
+    autoload :Location,      'solargraph/source/location'
     autoload :Updater,       'solargraph/source/updater'
     autoload :Change,        'solargraph/source/change'
+    autoload :Mapper,        'solargraph/source/mapper'
 
     # @return [String]
     attr_reader :code
@@ -38,6 +40,12 @@ module Solargraph
     # @return [Time]
     attr_reader :stime
 
+    attr_reader :pins
+
+    attr_reader :requires
+
+    attr_reader :locals
+
     include NodeMethods
 
     def initialize code, filename = nil
@@ -57,78 +65,93 @@ module Solargraph
       @path_macros[path]
     end
 
+    # @todo Temporary blank
+    def path_macros
+      @path_macros ||= {}
+    end
+
+    # @todo Name problem
+    def required
+      requires
+    end
+
     # @return [Array<String>]
     def namespaces
-      @namespaces ||= namespace_pin_map.keys
-    end
-
-    def qualify(signature, fqns)
-      return signature if signature.nil? or signature.empty?
-      base, rest = signature.split('.', 2)
-      parts = fqns.split('::')
-      until parts.empty?
-        here = parts.join('::')
-        parts.pop
-        name = "#{here}::#{base}"
-        next if namespace_pins(name).empty?
-        base = name
-        break
-      end
-      base + (rest.nil? ? '' : ".#{rest}")
+      # @namespaces ||= namespace_pin_map.keys
+      @namespaces ||= pins.select{|pin| pin.kind == Pin::NAMESPACE}.map(&:path)
     end
 
     # @param fqns [String] The namespace (nil for all)
     # @return [Array<Solargraph::Pin::Namespace>]
     def namespace_pins fqns = nil
-      return namespace_pin_map.values.flatten if fqns.nil?
-      namespace_pin_map[fqns] || []
+      pins.select{|pin| pin.kind == Pin::NAMESPACE}
     end
 
     # @param fqns [String] The namespace (nil for all)
     # @return [Array<Solargraph::Pin::Method>]
     def method_pins fqns = nil
-      return method_pin_map.values.flatten if fqns.nil?
-      method_pin_map[fqns] || []
+      pins.select{|pin| pin.kind == Solargraph::Pin::METHOD}
     end
 
     # @return [Array<Solargraph::Pin::Attribute>]
     def attribute_pins
-      @attribute_pins ||= []
+      pins.select{|pin| pin.kind == Pin::ATTRIBUTE}
     end
 
     # @return [Array<Solargraph::Pin::InstanceVariable>]
     def instance_variable_pins
-      @instance_variable_pins ||= []
+      pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE}
     end
 
     # @return [Array<Solargraph::Pin::ClassVariable>]
     def class_variable_pins
-      @class_variable_pins ||= []
+      pins.select{|pin| pin.kind == Pin::CLASS_VARIABLE}
     end
 
-    # @return [Array<Solargraph::Pin::LocalVariable>]
-    def local_variable_pins
-      @local_variable_pins ||= []
+    def locals
+      @locals
     end
 
     # @return [Array<Solargraph::Pin::GlobalVariable>]
     def global_variable_pins
-      @global_variable_pins ||= []
+      pins.select{|pin| pin.kind == Pin::GLOBAL_VARIABLE}
     end
 
     # @return [Array<Solargraph::Pin::Constant>]
     def constant_pins
-      @constant_pins ||= []
+      pins.select{|pin| pin.kind == Pin::CONSTANT}
     end
 
     # @return [Array<Solargraph::Pin::Symbol>]
     def symbol_pins
-      @symbol_pins ||= []
+      @symbols
     end
 
-    # @return [Array<String>]
-    def required
-      @required ||= []
+    def symbols
+      symbol_pins
+    end
+
+    def locate_named_path_pin line, character
+      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD
+    end
+
+    def locate_namespace_pin line, character
+      _locate_pin line, character, Pin::NAMESPACE
+    end
+
+    def locate_block_pin line, character
+      _locate_pin line, character, Pin::NAMESPACE, Pin::METHOD, Pin::BLOCK
+    end
+
+    def _locate_pin line, character, *kinds
+      position = Solargraph::Source::Position.new(line, character)
+      found = nil
+      pins.each do |pin|
+        found = pin if (kinds.empty? or kinds.include?(pin.kind)) and pin.location.range.contain?(position)
+        break if pin.location.range.start.line > line
+      end
+      # @todo Assuming the root pin is always valid
+      found || pins.first
     end
 
     # @return [YARD::Docstring]
@@ -158,28 +181,35 @@ module Solargraph
       tree_at(line, column).first
     end
 
+    def string_at?(line, column)
+      node = node_at(line, column)
+      # @todo raise InvalidOffset or InvalidRange or something?
+      return false if node.nil?
+      node.type == :str or node.type == :dstr
+    end
+
     # Get an array of nodes containing the specified index, starting with the
     # nearest node and ending with the root.
     #
     # @param index [Integer]
     # @return [Array<AST::Node>]
     def tree_at(line, column)
-      # offset = get_parsed_offset(line, column)
       offset = Position.line_char_to_offset(@code, line, column)
-      @all_nodes.reverse.each do |n|
-        if n.respond_to?(:loc)
-          if n.respond_to?(:begin) and n.respond_to?(:end)
-            if offset >= n.begin.begin_pos and offset < n.end.end_pos
-              return [n] + @node_tree[n.object_id]
-            end
-          elsif !n.loc.expression.nil?
-            if offset >= n.loc.expression.begin_pos and offset < n.loc.expression.end_pos
-              return [n] + @node_tree[n.object_id]
-            end
-          end
+      stack = []
+      inner_tree_at @node, offset, stack
+      stack
+    end
+
+    def inner_tree_at node, offset, stack
+      stack.unshift node
+      node.children.each do |c|
+        next unless c.is_a?(AST::Node)
+        next if c.loc.expression.nil?
+        if offset >= c.loc.expression.begin_pos and offset < c.loc.expression.end_pos
+          inner_tree_at(c, offset, stack)
+          break
         end
       end
-      [@node]
     end
 
     # Find the nearest parent node from the specified index. If one or more
@@ -265,7 +295,7 @@ module Solargraph
 
     # @return [Solargraph::Source::Fragment]
     def fragment_at line, column
-      Fragment.new(self, line, column, tree_at(line, column))
+      Fragment.new(self, line, column)
     end
 
     def fragment_for node
@@ -283,71 +313,33 @@ module Solargraph
     private
 
     def parse
-      node, comments = Source.parse(@fixed, filename)
+      node, comments = inner_parse(@fixed, filename)
+      @node = node
+      @comments = comments
       process_parsed node, comments
       @parsed = true
     end
 
     def hard_fix_node
-      @fixed = @code.gsub(/[^\s]/, ' ')
-      node, comments = Source.parse(@fixed, filename)
+      @fixed = @code.gsub(/[^\s]/, '_')
+      node, comments = inner_parse(@fixed, filename)
+      @node = node
+      @comments = comments
       process_parsed node, comments
       @parsed = false
     end
 
+    def inner_parse code, filename
+      parser = Parser::CurrentRuby.new(FlawedBuilder.new)
+      parser.diagnostics.all_errors_are_fatal = true
+      parser.diagnostics.ignore_warnings      = true
+      buffer = Parser::Source::Buffer.new(filename, 1)
+      buffer.source = code.force_encoding(Encoding::UTF_8)
+      parser.parse_with_comments(buffer)
+    end
+
     def process_parsed node, comments
-      root = AST::Node.new(:source, [filename])
-      root = root.append node
-      @node = root
-      @namespaces = nil
-      @comments = comments
-      @directives = {}
-      @path_macros = {}
-      @docstring_hash = associate_comments(node, comments)
-      @mtime = (!filename.nil? and File.exist?(filename) ? File.mtime(filename) : nil)
-      @all_nodes = []
-      @node_stack = []
-      @node_tree = {}
-      namespace_pin_map.clear
-      namespace_pin_map[''] = [Solargraph::Pin::Namespace.new(self, @node, '', :public)]
-      @namespace_pins = nil
-      instance_variable_pins.clear
-      class_variable_pins.clear
-      local_variable_pins.clear
-      symbol_pins.clear
-      constant_pins.clear
-      method_pin_map.clear
-      # namespace_includes.clear
-      attribute_pins.clear
-      @node_object_ids = nil
-      inner_map_node @node
-      @directives.each_pair do |k, v|
-        v.each do |d|
-          ns = namespace_for(k.node)
-          docstring = YARD::Docstring.parser.parse(d.tag.text).to_docstring
-          if d.tag.tag_name == 'attribute'
-            t = (d.tag.types.nil? || d.tag.types.empty?) ? nil : d.tag.types.flatten.join('')
-            if t.nil? or t.include?('r')
-              attribute_pins.push Solargraph::Pin::Directed::Attribute.new(self, k.node, ns, :reader, docstring, d.tag.name)
-            end
-            if t.nil? or t.include?('w')
-              attribute_pins.push Solargraph::Pin::Directed::Attribute.new(self, k.node, ns, :writer, docstring, "#{d.tag.name}=")
-            end
-          elsif d.tag.tag_name == 'method'
-            gen_src = Source.new("def #{d.tag.name};end", filename)
-            gen_pin = gen_src.method_pins.first
-            method_pin_map[ns] ||= []
-            method_pin_map[ns].push Solargraph::Pin::Directed::Method.new(gen_src, gen_pin.node, ns, :instance, :public, docstring, gen_pin.name)
-          elsif d.tag.tag_name == 'macro'
-            # @todo Handle various types of macros (attach, new, whatever)
-            path = path_for(k.node)
-            @path_macros[path] = v
-          else
-            STDERR.puts "Nothing to do for directive: #{d}"
-          end
-        end
-      end
-      @all_pins = namespace_pin_map.values.flatten + instance_variable_pins + class_variable_pins + local_variable_pins + symbol_pins + constant_pins + method_pins + attribute_pins
+      @pins, @locals, @requires, @symbols, @path_macros = Mapper.map filename, code, node, comments
       @stime = Time.now
     end
 
@@ -383,180 +375,6 @@ module Solargraph
       yard_hash
     end
 
-    def inner_map_node node, tree = [], visibility = :public, scope = :instance, fqn = '', stack = []
-      stack.push node
-      source = self
-      if node.kind_of?(AST::Node)
-        @all_nodes.push node
-        @node_stack.unshift node
-        if node.type == :class or node.type == :module
-          visibility = :public
-          if node.children[0].kind_of?(AST::Node) and node.children[0].children[0].kind_of?(AST::Node) and node.children[0].children[0].type == :cbase
-            tree = pack_name(node.children[0])
-          else
-            tree = tree + pack_name(node.children[0])
-          end
-          fqn = tree.join('::')
-          sc = nil
-          nspin = Solargraph::Pin::Namespace.new(self, node, tree[0..-2].join('::') || '', :public, sc)
-          if node.type == :class and !node.children[1].nil?
-            nspin.reference_superclass unpack_name(node.children[1])
-          end
-          namespace_pin_map[nspin.path] ||= []
-          namespace_pin_map[nspin.path].push nspin
-        end
-        file = source.filename
-        node.children.each do |c|
-          if c.kind_of?(AST::Node)
-            @node_tree[c.object_id] = @node_stack.clone
-            if c.type == :ivasgn
-              par = find_parent(stack, :class, :module, :def, :defs)
-              local_scope = ( (par.kind_of?(AST::Node) and par.type == :def) ? :instance : :class )
-              if c.children[1].nil?
-                ora = find_parent(stack, :or_asgn)
-                unless ora.nil?
-                  u = c.updated(:ivasgn, c.children + ora.children[1..-1], nil)
-                  @all_nodes.push u
-                  @node_tree[u.object_id] = @node_stack.clone
-                  @docstring_hash[u.loc] = docstring_for(ora)
-                  instance_variable_pins.push Solargraph::Pin::InstanceVariable.new(self, u, fqn || '', local_scope)
-                end
-              else
-                instance_variable_pins.push Solargraph::Pin::InstanceVariable.new(self, c, fqn || '', local_scope)
-              end
-            elsif c.type == :cvasgn
-              if c.children[1].nil?
-                ora = find_parent(stack, :or_asgn)
-                unless ora.nil?
-                  u = c.updated(:cvasgn, c.children + ora.children[1..-1], nil)
-                  @node_tree[u.object_id] = @node_stack.clone
-                  @all_nodes.push u
-                  @docstring_hash[u.loc] = docstring_for(ora)
-                  class_variable_pins.push Solargraph::Pin::ClassVariable.new(self, u, fqn || '')
-                end
-              else
-                class_variable_pins.push Solargraph::Pin::ClassVariable.new(self, c, fqn || '')
-              end
-            elsif c.type == :lvasgn
-              if c.children[1].nil?
-                ora = find_parent(stack, :or_asgn)
-                unless ora.nil?
-                  u = c.updated(:lvasgn, c.children + ora.children[1..-1], nil)
-                  @all_nodes.push u
-                  @node_tree[u] = @node_stack.clone
-                  @docstring_hash[u.loc] = docstring_for(ora)
-                  local_variable_pins.push Solargraph::Pin::LocalVariable.new(self, u, fqn || '', @node_stack.clone)
-                end
-              else
-                @node_tree[c] = @node_stack.clone
-                local_variable_pins.push Solargraph::Pin::LocalVariable.new(self, c, fqn || '', @node_stack.clone)
-              end
-            elsif c.type == :gvasgn
-              global_variable_pins.push Solargraph::Pin::GlobalVariable.new(self, c, fqn || '')
-            elsif c.type == :sym
-              symbol_pins.push Solargraph::Pin::Symbol.new(self, c, fqn)
-            elsif c.type == :casgn
-              constant_pins.push Solargraph::Pin::Constant.new(self, c, fqn, :public)
-            elsif c.type == :def and c.children[0].to_s[0].match(/[a-z]/i)
-              method_pin_map[fqn || ''] ||= []
-              method_pin_map[fqn || ''].push Solargraph::Pin::Method.new(source, c, fqn || '', scope, visibility)
-            elsif c.type == :defs
-              s_visi = visibility
-              s_visi = :public if scope != :class
-              if c.children[0].is_a?(AST::Node) and c.children[0].type == :self
-                dfqn = fqn || ''
-              else
-                dfqn = unpack_name(c.children[0])
-              end
-              unless dfqn.nil?
-                method_pin_map[dfqn] ||= []
-                method_pin_map[dfqn].push Solargraph::Pin::Method.new(source, c, dfqn, :class, s_visi)
-                inner_map_node c, tree, scope, :class, dfqn, stack
-              end
-              next
-            elsif c.type == :send and [:public, :protected, :private].include?(c.children[1])
-              visibility = c.children[1]
-            elsif c.type == :send and [:private_class_method].include?(c.children[1]) and c.children[2].kind_of?(AST::Node)
-              if c.children[2].type == :sym or c.children[2].type == :str
-                ref = method_pins(fqn || '').select{|p| p.name == c.children[2].children[0].to_s}.first
-                unless ref.nil?
-                  method_pin_map[fqn || ''].delete ref
-                  method_pin_map[fqn || ''].push Solargraph::Pin::Method.new(ref.source, ref.node, ref.namespace, ref.scope, :private)
-                end
-              else
-                inner_map_node c, tree, :private, :class, fqn, stack
-                next
-              end
-            elsif c.type == :send and [:private_constant].include?(c.children[1]) and c.children[2].kind_of?(AST::Node)
-              if c.children[2].type == :sym or c.children[2].type == :str
-                cn = c.children[2].children[0].to_s
-                ref = constant_pins.select{|p| p.name == cn}.first
-                if ref.nil?
-                  ref = namespace_pin_map.values.flatten.select{|p| p.name == cn and p.namespace == fqn}.last
-                  unless ref.nil?
-                    namespace_pin_map[ref.path].delete ref
-                    namespace_pin_map[ref.path].push Solargraph::Pin::Namespace.new(ref.source, ref.node, ref.namespace, :private, (ref.superclass_reference.nil? ? nil : ref.superclass_reference.name))
-                  end
-                else
-                  source.constant_pins.delete ref
-                  source.constant_pins.push Solargraph::Pin::Constant.new(ref.source, ref.node, ref.namespace, :private)
-                end
-              end
-              next
-            elsif c.type == :send and c.children[1] == :include and c.children[0].nil?
-              if @node_tree[0].nil? or @node_tree[0].type == :source or @node_tree[0].type == :class or @node_tree[0].type == :module or (@node_tree.length > 1 and @node_tree[0].type == :begin and (@node_tree[1].type == :class or @node_tree[1].type == :module))
-                if c.children[2].kind_of?(AST::Node) and c.children[2].type == :const
-                  c.children[2..-1].each do |i|
-                    namespace_pins(fqn || '').last.reference_include unpack_name(i)
-                  end
-                end
-              end
-            elsif c.type == :send and c.children[1] == :extend and c.children[0].nil?
-              if @node_tree[0].nil? or @node_tree[0].type == :source or @node_tree[0].type == :class or @node_tree[0].type == :module or (@node_tree.length > 1 and @node_tree[0].type == :begin and (@node_tree[1].type == :class or @node_tree[1].type == :module))
-                if c.children[2].kind_of?(AST::Node) and c.children[2].type == :const
-                  # namespace_extends[fqn || ''] ||= []
-                  c.children[2..-1].each do |i|
-                    namespace_pin_map[fqn || ''].last.reference_extend unpack_name(i)
-                  end
-                end
-              end
-            elsif c.type == :send and [:attr_reader, :attr_writer, :attr_accessor].include?(c.children[1])
-              c.children[2..-1].each do |a|
-                if c.children[1] == :attr_reader or c.children[1] == :attr_accessor
-                  attribute_pins.push Solargraph::Pin::Attribute.new(self, a, fqn || '', :reader, docstring_for(c)) #AttrPin.new(c)
-                end
-                if c.children[1] == :attr_writer or c.children[1] == :attr_accessor
-                  attribute_pins.push Solargraph::Pin::Attribute.new(self, a, fqn || '', :writer, docstring_for(c)) #AttrPin.new(c)
-                end
-              end
-            elsif c.type == :sclass and c.children[0].type == :self
-              inner_map_node c, tree, :public, :class, fqn || '', stack
-              next
-            elsif c.type == :send and c.children[1] == :require
-              if c.children[2].kind_of?(AST::Node) and c.children[2].type == :str
-                required.push c.children[2].children[0].to_s
-              end
-            elsif c.type == :args
-              if @node_stack.first.type == :block
-                pi = 0
-                c.children.each do |u|
-                  local_variable_pins.push Solargraph::Pin::BlockParameter.new(self, u, fqn || '', @node_stack.clone, pi)
-                  pi += 1
-                end
-              else
-                c.children.each do |u|
-                  local_variable_pins.push Solargraph::Pin::MethodParameter.new(self, u, fqn || '', @node_stack.clone)
-                end
-              end
-            end
-            inner_map_node c, tree, visibility, scope, fqn, stack
-          end
-        end
-        @node_stack.shift
-      end
-      stack.pop
-    end
-
     def find_parent(stack, *types)
       stack.reverse.each { |p|
         return p if types.include?(p.type)
@@ -590,15 +408,6 @@ module Solargraph
         Source.new code, filename
       end
 
-      def parse code, filename = nil
-        parser = Parser::CurrentRuby.new(FlawedBuilder.new)
-        parser.diagnostics.all_errors_are_fatal = true
-        parser.diagnostics.ignore_warnings      = true
-        buffer = Parser::Source::Buffer.new(filename, 1)
-        buffer.source = code.force_encoding(Encoding::UTF_8)
-        parser.parse_with_comments(buffer)
-      end
-
       def fix code, filename = nil, offset = nil
         tries = 0
         offset = Source.get_offset(code, offset[0], offset[1]) if offset.kind_of?(Array)

data/lib/solargraph/version.rb

@@ -1,3 +1,3 @@
 module Solargraph
-  VERSION = '0.18.3'
+  VERSION = '0.19.0'
 end

data/lib/solargraph/views/_method.erb

@@ -1,60 +1,59 @@
-<h2>
-    Namespace:
-</h2>
-<p>
-    <a href="command:solargraph._openDocument?<%= URI.escape "\"solargraph:/document?#{object.namespace}\"" %>"><%= object.namespace %></a>
-</p>
-<h2>
-    Overview:
-</h2>
-<%= htmlify object.docstring %>
-<h2>
-    Parameters:
-</h2>
-<% if object.parameters.empty? %>
-    <p>
-        None
-    </p>
-<% else %>
-    <ul>
-    <% object.parameters.each do |p| %>
-        <li>
-            <%= p[0] %>
-            <%= " = #{p[1]}" unless p[1].nil? %>
-        </li>
-    <% end %>
-    </ul>
-<% end %>
-<h2>
-    Returns:
-</h2>
-<% if object.tag(:return).nil? %>
-    <p>
-        Undefined/unknown
-    </p>
-<% else %>
-    <% tag = object.tag(:return) %>
-    <% unless tag.types.nil? or tag.types.empty? %>
-    <ul>
-        <% tag.types.each do |r| %>
-            <li>
-                <a href="command:solargraph._openDocument?<%= URI.escape "\"solargraph:/document?#{r}\"" %>"><%= r %></a>
-            </li>
-        <% end %>
-    </ul>
-    <% end %>
-    <% unless tag.text.empty? %>
-        <p>
-            <%= tag.text %>
-        </p>
-    <% end %>
-<% end %>
-<% examples = object.tags(:example) %>
-<% unless examples.nil? %>
-    <% examples.each do |example| %>
-        <h2>
-            Example: <%= example.name %>
-        </h2>
-        <%= ruby_to_html example.text.strip %>
-    <% end %>
-<% end %>
+<h2>
+    Namespace:
+</h2>
+<p>
+    <a href="command:solargraph._openDocument?<%= URI.escape "\"solargraph:/document?query=#{object.namespace}\"" %>"><%= object.namespace %></a>
+</p>
+<h2>
+    Overview:
+</h2>
+<%= htmlify object.docstring %>
+<% unless object.tags(:param).empty? %>
+    <h2>
+        Parameters:
+    </h2>
+    <ul>
+        <% object.tags(:param).each do |tag| %>
+            <li>
+                <%= erb :_name_type_tag, layout: false, locals: {tag: tag} %>
+            </li>
+        <% end %>
+    </ul>
+<% end %>
+<% unless object.tags(:raise).empty? %>
+<h2>
+    Raises:
+</h2>
+<ul>
+    <% object.tags(:raise).each do |tag| %>
+        <li>
+            <%= erb :_name_type_tag, layout: false, locals: {tag: tag} %>
+        </li>
+    <% end %>
+</ul>
+<% end %>
+<h2>
+    Returns:
+</h2>
+<% if object.tag(:return).nil? %>
+    <p>
+        Undefined/unknown
+    </p>
+<% else %>
+    <ul>
+        <% object.tags(:return).each do |tag| %>
+            <li>
+                <%= erb :_name_type_tag, layout: false, locals: {tag: tag} %>
+            </li>
+        <% end %>
+    </ul>
+<% end %>
+<% examples = object.tags(:example) %>
+<% unless examples.nil? %>
+    <% examples.each do |example| %>
+        <h2>
+            Example: <%= example.name %>
+        </h2>
+        <%= ruby_to_html example.text.strip %>
+    <% end %>
+<% end %>

data/lib/solargraph/views/_name_type_tag.erb

@@ -0,0 +1,10 @@
+<%= tag.name %>
+<% unless tag.types.nil? or tag.types.empty? %>
+	[<%= tag.types.join(', ') %>]
+<% end %>
+<% unless tag.text.empty? %>
+	<% unless (tag.name.nil? or tag.name.empty?) and (tag.types.nil? or tag.types.empty?) %>
+		-
+	<% end %>
+	<%= tag.text %>
+<% end %>