haml 3.1.0 → 3.1.1

data/vendor/sass/lib/sass/tree/media_node.rb

@@ -28,48 +28,5 @@ module Sass::Tree
     def value
       "@media #{query}"
     end
-
-    # Pass on the parent if it's a RuleNode.
-    #
-    # @see Node#cssize
-    def cssize(extends, parent = nil)
-      _cssize(extends, (parent if [MediaNode, RuleNode].include?(parent.class)))
-    rescue Sass::SyntaxError => e
-      e.modify_backtrace(:filename => filename, :line => line)
-      raise e
-    end
-
-    protected
-
-    # Merge nested media queries.
-    #
-    # @see Node#_cssize
-    def _cssize(extends, parent)
-      node = super
-      media = node.children.select {|c| c.is_a?(MediaNode)}
-      node.children.reject! {|c| c.is_a?(MediaNode)}
-      media.each {|n| n.query = "#{query} and #{n.query}"}
-      (node.children.empty? ? [] : [node]) + media
-    end
-
-    # If we're passed a parent, bubble it down.
-    #
-    # @see Node#cssize
-    def cssize!(extends, parent)
-      return super unless parent.is_a?(RuleNode)
-      new_rule = parent.dup
-      new_rule.children = self.children
-      self.children = Array(new_rule.cssize(extends, self))
-      # If the last child is actually the end of the group,
-      # the parent's cssize will set it properly
-      self.children.last.group_end = false unless self.children.empty?
-    end
-
-    # @see Node#to_s
-    def _to_s(tabs)
-      str = super(tabs + self.tabs)
-      str.gsub!(/\n\Z/, '') unless style == :compressed || group_end
-      str
-    end
   end
 end

data/vendor/sass/lib/sass/tree/mixin_def_node.rb

@@ -4,57 +4,24 @@ module Sass
     #
     # @see Sass::Tree
     class MixinDefNode < Node
+      # The mixin name.
+      # @return [String]
+      attr_reader :name
+
+      # The arguments for the mixin.
+      # Each element is a tuple containing the variable for argument
+      # and the parse tree for the default value of the argument.
+      #
+      # @return [Array<(Script::Node, Script::Node)>]
+      attr_reader :args
+
       # @param name [String] The mixin name
-      # @param args [Array<(Script::Node, Script::Node)>] The arguments for the mixin.
-      #   Each element is a tuple containing the variable for argument
-      #   and the parse tree for the default value of the argument
+      # @param args [Array<(Script::Node, Script::Node)>] See \{#args}
       def initialize(name, args)
         @name = name
         @args = args
         super()
       end
-
-      protected
-
-      # @see Node#to_src
-      def to_src(tabs, opts, fmt)
-        args =
-          if @args.empty?
-            ""
-          else
-            '(' + @args.map do |v, d|
-              if d
-                "#{v.to_sass(opts)}: #{d.to_sass(opts)}"
-              else
-                v.to_sass(opts)
-              end
-            end.join(", ") + ')'
-          end
-              
-        "#{'  ' * tabs}#{fmt == :sass ? '=' : '@mixin '}#{dasherize(@name, opts)}#{args}" +
-          children_to_src(tabs, opts, fmt)
-      end
-
-      # Loads the mixin into the environment.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      def _perform(environment)
-        environment.set_mixin(@name, Sass::Mixin.new(@name, @args, environment, children))
-        []
-      end
-
-      # Returns an error message if the given child node is invalid,
-      # and false otherwise.
-      #
-      # {ExtendNode}s are valid within {MixinDefNode}s.
-      #
-      # @param child [Tree::Node] A potential child node.
-      # @return [Boolean, String] Whether or not the child node is valid,
-      #   as well as the error message to display if it is invalid
-      def invalid_child?(child)
-        super unless child.is_a?(ExtendNode)
-      end
     end
   end
 end

data/vendor/sass/lib/sass/tree/mixin_node.rb

@@ -7,137 +7,26 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class MixinNode < Node
-    # @see Node#options=
-    def options=(opts)
-      super
-      @args.each {|a| a.context = :equals} if opts[:sass2]
-      @keywords.each {|k, v| v.context = :equals} if opts[:sass2]
-    end
+    # The name of the mixin.
+    # @return [String]
+    attr_reader :name
+
+    # The arguments to the mixin.
+    # @return [Array<Script::Node>]
+    attr_reader :args
+
+    # A hash from keyword argument names to values.
+    # @return [{String => Script::Node}]
+    attr_reader :keywords
 
     # @param name [String] The name of the mixin
-    # @param args [Array<Script::Node>] The arguments to the mixin
-    # @param keywords [{String => Script::Node}] A hash from keyword argument names to values
+    # @param args [Array<Script::Node>] See \{#args}
+    # @param keywords [{String => Script::Node}] See \{#keywords}
     def initialize(name, args, keywords)
       @name = name
       @args = args
       @keywords = keywords
       super()
     end
-
-    # @see Node#cssize
-    def cssize(extends, parent = nil)
-      _cssize(extends, parent) # Pass on the parent even if it's not a MixinNode
-    end
-
-    protected
-
-    # Returns an error message if the given child node is invalid,
-    # and false otherwise.
-    #
-    # {ExtendNode}s are valid within {MixinNode}s.
-    #
-    # @param child [Tree::Node] A potential child node
-    # @return [Boolean, String] Whether or not the child node is valid,
-    #   as well as the error message to display if it is invalid
-    def invalid_child?(child)
-      super unless child.is_a?(ExtendNode)
-    end
-
-    # @see Node#to_src
-    def to_src(tabs, opts, fmt)
-      unless @args.empty? && @keywords.empty?
-        args = @args.map {|a| a.to_sass(opts)}.join(", ")
-        keywords = @keywords.map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
-        arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
-      end
-      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{dasherize(@name, opts)}#{arglist}#{semi fmt}\n"
-    end
-
-    # @see Node#_cssize
-    def _cssize(extends, parent)
-      children.map do |c|
-        parent.check_child! c
-        c.cssize(extends, parent)
-      end.flatten
-    rescue Sass::SyntaxError => e
-      e.modify_backtrace(:mixin => @name, :filename => filename, :line => line)
-      e.add_backtrace(:filename => filename, :line => line)
-      raise e
-    end
-
-    # Runs the mixin.
-    #
-    # @param environment [Sass::Environment] The lexical environment containing
-    #   variable and mixin values
-    # @raise [Sass::SyntaxError] if there is no mixin with the given name
-    # @raise [Sass::SyntaxError] if an incorrect number of arguments was passed
-    # @see Sass::Tree
-    def perform!(environment)
-      handle_include_loop!(environment) if environment.mixins_in_use.include?(@name)
-
-      original_env = environment
-      original_env.push_frame(:filename => filename, :line => line)
-      original_env.prepare_frame(:mixin => @name)
-      raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.") unless mixin = environment.mixin(@name)
-
-      passed_args = @args.dup
-      passed_keywords = @keywords.dup
-
-      raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < passed_args.size
-Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
- but #{@args.size} #{@args.size == 1 ? 'was' : 'were'} passed.
-END
-
-      passed_keywords.each do |name, value|
-        # TODO: Make this fast
-        unless mixin.args.find {|(var, default)| var.underscored_name == name}
-          raise Sass::SyntaxError.new("Mixin #{@name} doesn't have an argument named $#{name}")
-        end
-      end
-
-      environment = mixin.args.zip(passed_args).
-        inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
-        env.set_local_var(var.name,
-          if value
-            value.perform(environment)
-          elsif kv = passed_keywords[var.underscored_name]
-            kv.perform(env)
-          elsif default
-            val = default.perform(env)
-            if default.context == :equals && val.is_a?(Sass::Script::String)
-              val = Sass::Script::String.new(val.value)
-            end
-            val
-          end)
-        raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter #{var.inspect}.") unless env.var(var.name)
-        env
-      end
-
-      self.children = mixin.tree.map {|c| c.perform(environment)}.flatten
-    rescue Sass::SyntaxError => e
-      if original_env # Don't add backtrace info if this is an @include loop
-        e.modify_backtrace(:mixin => @name, :line => @line)
-        e.add_backtrace(:line => @line)
-      end
-      raise e
-    ensure
-      original_env.pop_frame if original_env
-    end
-
-    private
-
-    def handle_include_loop!(environment)
-      msg = "An @include loop has been found:"
-      mixins = environment.stack.map {|s| s[:mixin]}.compact
-      if mixins.size == 2 && mixins[0] == mixins[1]
-        raise Sass::SyntaxError.new("#{msg} #{@name} includes itself")
-      end
-
-      mixins << @name
-      msg << "\n" << Sass::Util.enum_cons(mixins, 2).map do |m1, m2|
-        "    #{m1} includes #{m2}"
-      end.join("\n")
-      raise Sass::SyntaxError.new(msg)
-    end
   end
 end

data/vendor/sass/lib/sass/tree/node.rb

@@ -8,7 +8,7 @@ module Sass
   # in addition to nodes for CSS rules and properties.
   # Nodes that only appear in this state are called **dynamic nodes**.
   #
-  # {Tree::Node#perform} returns a static Sass tree, which is different.
+  # {Tree::Visitors::Perform} creates a static Sass tree, which is different.
   # It still has nodes for CSS rules and properties
   # but it doesn't have any dynamic-generation-related nodes.
   # The nodes in this state are in the same structure as the Sass document:
@@ -16,12 +16,12 @@ module Sass
   # Nodes that can be in this state or in the dynamic state
   # are called **static nodes**.
   #
-  # {Tree::Node#cssize} then returns a static CSS tree.
+  # {Tree::Visitors::Cssize} is then used to create a static CSS tree.
   # This is like a static Sass tree,
   # but the structure exactly mirrors that of the generated CSS.
   # Rules and properties can't be nested beneath one another in this state.
   #
-  # Finally, {Tree::Node#to_s} can be called on a static CSS tree
+  # Finally, {Tree::Visitors::ToCss} can be called on a static CSS tree
   # to get the actual CSS code as a string.
   module Tree
     # The abstract superclass of all parse-tree nodes.
@@ -86,29 +86,16 @@ module Sass
       #
       # @param child [Tree::Node, Array<Tree::Node>] The child node or nodes
       # @raise [Sass::SyntaxError] if `child` is invalid
-      # @see #invalid_child?
       def <<(child)
         return if child.nil?
         if child.is_a?(Array)
           child.each {|c| self << c}
         else
-          check_child! child
           self.has_children = true
           @children << child
         end
       end
 
-      # Raises an error if the given child node is invalid.
-      #
-      # @param child [Tree::Node] The child node
-      # @raise [Sass::SyntaxError] if `child` is invalid
-      # @see #invalid_child?
-      def check_child!(child)
-        if msg = invalid_child?(child)
-          raise Sass::SyntaxError.new(msg, :line => child.line)
-        end
-      end
-
       # Compares this node and another object (only other {Tree::Node}s will be equal).
       # This does a structural comparison;
       # if the contents of the nodes and all the child nodes are equivalent,
@@ -140,22 +127,13 @@ module Sass
 
       # Computes the CSS corresponding to this static CSS tree.
       #
-      # \{#to_s} shouldn't be overridden directly; instead, override \{#\_to\_s}.
-      # Only static-node subclasses need to implement \{#to\_s}.
-      #
-      # This may return `nil`, but it will only do so if \{#invisible?} is true.
-      #
-      # @param args [Array] Passed on to \{#\_to\_s}
       # @return [String, nil] The resulting CSS
       # @see Sass::Tree
-      def to_s(opts = nil)
-        _to_s(opts)
-      rescue Sass::SyntaxError => e
-        e.modify_backtrace(:filename => filename, :line => line)
-        raise e
+      def to_s
+        Sass::Tree::Visitors::ToCss.visit(self)
       end
 
-      # Converts a static CSS tree (e.g. the output of \{#cssize})
+      # Converts a static CSS tree (e.g. the output of \{Tree::Visitors::Cssize})
       # into another static CSS tree,
       # with the given extensions applied to all relevant {RuleNode}s.
       #
@@ -176,46 +154,6 @@ module Sass
         raise e
       end
 
-      # Converts a static Sass tree (e.g. the output of \{#perform})
-      # into a static CSS tree.
-      #
-      # \{#cssize} shouldn't be overridden directly;
-      # instead, override \{#\_cssize} or \{#cssize!}.
-      #
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
-      #   The extensions defined for this tree
-      # @param parent [Node, nil] The parent node of this node.
-      #   This should only be non-nil if the parent is the same class as this node
-      # @return [Tree::Node] The resulting tree of static nodes
-      # @raise [Sass::SyntaxError] if some element of the tree is invalid
-      # @see Sass::Tree
-      def cssize(extends, parent = nil)
-        _cssize(extends, (parent if parent.class == self.class))
-      rescue Sass::SyntaxError => e
-        e.modify_backtrace(:filename => filename, :line => line)
-        raise e
-      end
-
-      # Converts a dynamic tree into a static Sass tree.
-      # That is, runs the dynamic Sass code:
-      # mixins, variables, control directives, and so forth.
-      # This doesn't modify this node or any of its children.
-      #
-      # \{#perform} shouldn't be overridden directly;
-      # instead, override \{#\_perform} or \{#perform!}.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      # @return [Tree::Node] The resulting tree of static nodes
-      # @raise [Sass::SyntaxError] if some element of the tree is invalid
-      # @see Sass::Tree
-      def perform(environment)
-        _perform(environment)
-      rescue Sass::SyntaxError => e
-        e.modify_backtrace(:filename => filename, :line => line)
-        raise e
-      end
-
       # Iterates through each node in the tree rooted at this node
       # in a pre-order walk.
       #
@@ -228,145 +166,31 @@ module Sass
 
       # Converts a node to Sass code that will generate it.
       #
-      # @param tabs [Fixnum] The amount of tabulation to use for the Sass code
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
       # @return [String] The Sass code corresponding to the node
-      def to_sass(tabs = 0, opts = {})
-        to_src(tabs, opts, :sass)
+      def to_sass(options = {})
+        Sass::Tree::Visitors::Convert.visit(self, options, :sass)
       end
 
       # Converts a node to SCSS code that will generate it.
       #
-      # @param tabs [Fixnum] The amount of tabulation to use for the SCSS code
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
       # @return [String] The Sass code corresponding to the node
-      def to_scss(tabs = 0, opts = {})
-        to_src(tabs, opts, :scss)
-      end
-
-      # Names of options that are saved when the node is serialized and cached.
-      SAVED_OPTIONS = [:importer]
-
-      # Ensures that only {SAVED_OPTIONS} get saved.
-      def _around_dump
-        old_options = @options
-        old_children = @children
-        @options = {}
-        SAVED_OPTIONS.each do |opt|
-          @options[opt] = old_options[opt]
-        end
-        @options = Sass::Util.dump(@options)
-        @children = Sass::Util.dump(@children)
-        yield
-      ensure
-        @options = old_options
-        @children = old_children
-      end
-
-      # Ensures that only {SAVED_OPTIONS} get saved.
-      def _after_load
-        @options = Sass::Util.load(@options)
-        @children = Sass::Util.load(@children)
-      end
-
-      protected
-
-      # Computes the CSS corresponding to this particular Sass node.
-      #
-      # This method should never raise {Sass::SyntaxError}s.
-      # Such errors will not be properly annotated with Sass backtrace information.
-      # All error conditions should be checked in earlier transformations,
-      # such as \{#cssize} and \{#perform}.
-      #
-      # @param args [Array] ignored
-      # @return [String, nil] The resulting CSS
-      # @see #to_s
-      # @see Sass::Tree
-      def _to_s
-        Sass::Util.abstract(self)
-      end
-
-      # Converts this static Sass node into a static CSS node,
-      # returning the new node.
-      # This doesn't modify this node or any of its children.
-      #
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
-      #   The extensions defined for this tree
-      # @param parent [Node, nil] The parent node of this node.
-      #   This should only be non-nil if the parent is the same class as this node
-      # @return [Tree::Node, Array<Tree::Node>] The resulting static CSS nodes
-      # @raise [Sass::SyntaxError] if some element of the tree is invalid
-      # @see #cssize
-      # @see Sass::Tree
-      def _cssize(extends, parent)
-        node = dup
-        node.cssize!(extends, parent)
-        node
-      end
-
-      # Destructively converts this static Sass node into a static CSS node.
-      # This *does* modify this node,
-      # but will be run non-destructively by \{#\_cssize\}.
-      #
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
-      #   The extensions defined for this tree
-      # @param parent [Node, nil] The parent node of this node.
-      #   This should only be non-nil if the parent is the same class as this node
-      # @see #cssize
-      def cssize!(extends, parent)
-        self.children = children.map {|c| c.cssize(extends, self)}.flatten
+      def to_scss(options = {})
+        Sass::Tree::Visitors::Convert.visit(self, options, :scss)
       end
 
-      # Runs any dynamic Sass code in this particular node.
-      # This doesn't modify this node or any of its children.
+      # Return a deep clone of this node.
+      # The child nodes are cloned, but options are not.
       #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      # @return [Tree::Node, Array<Tree::Node>] The resulting static nodes
-      # @see #perform
-      # @see Sass::Tree
-      def _perform(environment)
+      # @return [Node]
+      def deep_copy
         node = dup
-        node.perform!(environment)
+        node.children = children.map {|c| c.deep_copy}
         node
       end
 
-      # Destructively runs dynamic Sass code in this particular node.
-      # This *does* modify this node,
-      # but will be run non-destructively by \{#\_perform\}.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      # @see #perform
-      def perform!(environment)
-        self.children = perform_children(Environment.new(environment))
-      end
-
-      # Non-destructively runs \{#perform} on all children of the current node.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      # @return [Array<Tree::Node>] The resulting static nodes
-      def perform_children(environment)
-        children.map {|c| c.perform(environment)}.flatten
-      end
-
-      # Replaces SassScript in a chunk of text
-      # with the resulting value.
-      #
-      # @param text [Array<String, Sass::Script::Node>] The text to interpolate
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      # @return [String] The interpolated text
-      def run_interp(text, environment)
-        text.map do |r|
-          next r if r.is_a?(String)
-          val = r.perform(environment)
-          # Interpolated strings should never render with quotes
-          next val.value if val.is_a?(Sass::Script::String)
-          val.to_s
-        end.join.strip
-      end
+      protected
 
       # @see Sass::Shared.balance
       # @raise [Sass::SyntaxError] if the brackets aren't balanced
@@ -375,116 +199,6 @@ module Sass
         return res if res
         raise Sass::SyntaxError.new("Unbalanced brackets.", :line => line)
       end
-
-      # Returns an error message if the given child node is invalid,
-      # and false otherwise.
-      #
-      # By default, all child nodes except those only allowed under specific nodes
-      # ({Tree::MixinDefNode}, {Tree::ImportNode}, {Tree::ExtendNode}) are valid.
-      # This is expected to be overriden by subclasses
-      # for which some children are invalid.
-      #
-      # @param child [Tree::Node] A potential child node
-      # @return [Boolean, String] Whether or not the child node is valid,
-      #   as well as the error message to display if it is invalid
-      def invalid_child?(child)
-        case child
-        when Tree::MixinDefNode
-          "Mixins may only be defined at the root of a document."
-        when Tree::ImportNode
-          "Import directives may only be used at the root of a document."
-        when Tree::ExtendNode
-          "Extend directives may only be used within rules."
-        end
-      end
-
-      # Converts a node to Sass or SCSS code that will generate it.
-      #
-      # This method is called by the default \{#to\_sass} and \{#to\_scss} methods,
-      # so that the same code can be used for both with minor variations.
-      #
-      # @param tabs [Fixnum] The amount of tabulation to use for the SCSS code
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @param fmt [Symbol] `:sass` or `:scss`
-      # @return [String] The Sass or SCSS code corresponding to the node
-      def to_src(tabs, opts, fmt)
-        Sass::Util.abstract(self)
-      end
-
-      # Converts the children of this node to a Sass or SCSS string.
-      # This will return the trailing newline for the previous line,
-      # including brackets if this is SCSS.
-      #
-      # @param tabs [Fixnum] The amount of tabulation to use for the Sass code
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @param fmt [Symbol] `:sass` or `:scss`
-      # @return [String] The Sass or SCSS code corresponding to the children
-      def children_to_src(tabs, opts, fmt)
-        return fmt == :sass ? "\n" : " {}\n" if children.empty?
-
-        (fmt == :sass ? "\n" : " {\n") +
-          children.map {|c| c.send("to_#{fmt}", tabs + 1, opts)}.join.rstrip +
-          (fmt == :sass ? "\n" : " }\n")
-      end
-
-      # Converts a selector to a Sass or SCSS string.
-      #
-      # @param sel [Array<String, Sass::Script::Node>] The selector to convert
-      # @param tabs [Fixnum] The indentation of the selector
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @param fmt [Symbol] `:sass` or `:scss`
-      # @return [String] The Sass or SCSS code corresponding to the selector
-      def selector_to_src(sel, tabs, opts, fmt)
-        fmt == :sass ? selector_to_sass(sel, opts) : selector_to_scss(sel, tabs, opts)
-      end
-
-      # Converts a selector to a Sass string.
-      #
-      # @param sel [Array<String, Sass::Script::Node>] The selector to convert
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @return [String] The Sass code corresponding to the selector
-      def selector_to_sass(sel, opts)
-        sel.map do |r|
-          if r.is_a?(String)
-            r.gsub(/(,[ \t]*)?\n\s*/) {$1 ? $1 + "\n" : " "}
-          else
-            "\#{#{r.to_sass(opts)}}"
-          end
-        end.join
-      end
-
-      # Converts a selector to a SCSS string.
-      #
-      # @param sel [Array<String, Sass::Script::Node>] The selector to convert
-      # @param tabs [Fixnum] The indentation of the selector
-      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @return [String] The SCSS code corresponding to the selector
-      def selector_to_scss(sel, tabs, opts)
-        sel.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass(opts)}}"}.
-          join.gsub(/^[ \t]*/, '  ' * tabs)
-      end
-
-      # Convert any underscores in a string into hyphens,
-      # but only if the `:dasherize` option is set.
-      #
-      # @param s [String] The string to convert
-      # @param opts [{Symbol => Object}] The options hash
-      # @return [String] The converted string
-      def dasherize(s, opts)
-        if opts[:dasherize]
-          s.gsub('_', '-')
-        else
-          s
-        end
-      end
-
-      # Returns a semicolon if this is SCSS, or an empty string if this is Sass.
-      #
-      # @param fmt [Symbol] `:sass` or `:scss`
-      # @return [String] A semicolon or the empty string
-      def semi(fmt)
-        fmt == :sass ? "" : ";"
-      end
     end
   end
 end