xass 0.1.0 → 0.1.1

data/lib/sass/shared.rb

@@ -1,76 +0,0 @@
-module Sass
-  # This module contains functionality that's shared between Haml and Sass.
-  module Shared
-    extend self
-
-    # Scans through a string looking for the interoplation-opening `#{`
-    # and, when it's found, yields the scanner to the calling code
-    # so it can handle it properly.
-    #
-    # The scanner will have any backslashes immediately in front of the `#{`
-    # as the second capture group (`scan[2]`),
-    # and the text prior to that as the first (`scan[1]`).
-    #
-    # @yieldparam scan [StringScanner] The scanner scanning through the string
-    # @return [String] The text remaining in the scanner after all `#{`s have been processed
-    def handle_interpolation(str)
-      scan = Sass::Util::MultibyteStringScanner.new(str)
-      yield scan while scan.scan(/(.*?)(\\*)\#\{/m)
-      scan.rest
-    end
-
-    # Moves a scanner through a balanced pair of characters.
-    # For example:
-    #
-    #     Foo (Bar (Baz bang) bop) (Bang (bop bip))
-    #     ^                       ^
-    #     from                    to
-    #
-    # @param scanner [StringScanner] The string scanner to move
-    # @param start [Character] The character opening the balanced pair.
-    #   A `Fixnum` in 1.8, a `String` in 1.9
-    # @param finish [Character] The character closing the balanced pair.
-    #   A `Fixnum` in 1.8, a `String` in 1.9
-    # @param count [Fixnum] The number of opening characters matched
-    #   before calling this method
-    # @return [(String, String)] The string matched within the balanced pair
-    #   and the rest of the string.
-    #   `["Foo (Bar (Baz bang) bop)", " (Bang (bop bip))"]` in the example above.
-    def balance(scanner, start, finish, count = 0)
-      str = ''
-      scanner = Sass::Util::MultibyteStringScanner.new(scanner) unless scanner.is_a? StringScanner
-      regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
-      while scanner.scan(regexp)
-        str << scanner.matched
-        count += 1 if scanner.matched[-1] == start
-        count -= 1 if scanner.matched[-1] == finish
-        return [str.strip, scanner.rest] if count == 0
-      end
-    end
-
-    # Formats a string for use in error messages about indentation.
-    #
-    # @param indentation [String] The string used for indentation
-    # @param was [Boolean] Whether or not to add `"was"` or `"were"`
-    #   (depending on how many characters were in `indentation`)
-    # @return [String] The name of the indentation (e.g. `"12 spaces"`, `"1 tab"`)
-    def human_indentation(indentation, was = false)
-      if !indentation.include?(?\t)
-        noun = 'space'
-      elsif !indentation.include?(?\s)
-        noun = 'tab'
-      else
-        return indentation.inspect + (was ? ' was' : '')
-      end
-
-      singular = indentation.length == 1
-      if was
-        was = singular ? ' was' : ' were'
-      else
-        was = ''
-      end
-
-      "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
-    end
-  end
-end

data/lib/sass/supports.rb

@@ -1,229 +0,0 @@
-# A namespace for the `@supports` condition parse tree.
-module Sass::Supports
-  # The abstract superclass of all Supports conditions.
-  class Condition
-    # Runs the SassScript in the supports condition.
-    #
-    # @param env [Sass::Environment] The environment in which to run the script.
-    def perform(environment); Sass::Util.abstract(self); end
-
-    # Returns the CSS for this condition.
-    #
-    # @return [String]
-    def to_css; Sass::Util.abstract(self); end
-
-    # Returns the Sass/CSS code for this condition.
-    #
-    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
-    # @return [String]
-    def to_src(options); Sass::Util.abstract(self); end
-
-    # Returns a deep copy of this condition and all its children.
-    #
-    # @return [Condition]
-    def deep_copy; Sass::Util.abstract(self); end
-
-    # Sets the options hash for the script nodes in the supports condition.
-    #
-    # @param options [{Symbol => Object}] The options has to set.
-    def options=(options); Sass::Util.abstract(self); end
-  end
-
-  # An operator condition (e.g. `CONDITION1 and CONDITION2`).
-  class Operator < Condition
-    # The left-hand condition.
-    #
-    # @return [Sass::Supports::Condition]
-    attr_accessor :left
-
-    # The right-hand condition.
-    #
-    # @return [Sass::Supports::Condition]
-    attr_accessor :right
-
-    # The operator ("and" or "or").
-    #
-    # @return [String]
-    attr_accessor :op
-
-    def initialize(left, right, op)
-      @left = left
-      @right = right
-      @op = op
-    end
-
-    def perform(env)
-      @left.perform(env)
-      @right.perform(env)
-    end
-
-    def to_css
-      "#{left_parens @left.to_css} #{op} #{right_parens @right.to_css}"
-    end
-
-    def to_src(options)
-      "#{left_parens @left.to_src(options)} #{op} #{right_parens @right.to_src(options)}"
-    end
-
-    def deep_copy
-      copy = dup
-      copy.left = @left.deep_copy
-      copy.right = @right.deep_copy
-      copy
-    end
-
-    def options=(options)
-      @left.options = options
-      @right.options = options
-    end
-
-    private
-
-    def left_parens(str)
-      return "(#{str})" if @left.is_a?(Negation)
-      return str
-    end
-
-    def right_parens(str)
-      return "(#{str})" if @right.is_a?(Negation) || @right.is_a?(Operator)
-      return str
-    end
-  end
-
-  # A negation condition (`not CONDITION`).
-  class Negation < Condition
-    # The condition being negated.
-    #
-    # @return [Sass::Supports::Condition]
-    attr_accessor :condition
-
-    def initialize(condition)
-      @condition = condition
-    end
-
-    def perform(env)
-      @condition.perform(env)
-    end
-
-    def to_css
-      "not #{parens @condition.to_css}"
-    end
-
-    def to_src(options)
-      "not #{parens @condition.to_src(options)}"
-    end
-
-    def deep_copy
-      copy = dup
-      copy.condition = condition.deep_copy
-      copy
-    end
-
-    def options=(options)
-      condition.options = options
-    end
-
-    private
-
-    def parens(str)
-      return "(#{str})" if @condition.is_a?(Negation) || @condition.is_a?(Operator)
-      return str
-    end
-  end
-
-  # A declaration condition (e.g. `(feature: value)`).
-  class Declaration < Condition
-    # The feature name.
-    #
-    # @param [Sass::Script::Node]
-    attr_accessor :name
-
-    # The name of the feature after any SassScript has been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_name
-
-    # The feature value.
-    #
-    # @param [Sass::Script::Node]
-    attr_accessor :value
-
-    # The value of the feature after any SassScript has been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_value
-
-    def initialize(name, value)
-      @name = name
-      @value = value
-    end
-
-    def perform(env)
-      @resolved_name = name.perform(env)
-      @resolved_value = value.perform(env)
-    end
-
-    def to_css
-      "(#{@resolved_name}: #{@resolved_value})"
-    end
-
-    def to_src(options)
-      "(#{@name.to_sass(options)}: #{@value.to_sass(options)})"
-    end
-
-    def deep_copy
-      copy = dup
-      copy.name = @name.deep_copy
-      copy.value = @value.deep_copy
-      copy
-    end
-
-    def options=(options)
-      @name.options = options
-      @value.options = options
-    end
-  end
-
-  # An interpolation condition (e.g. `#{$var}`).
-  class Interpolation < Condition
-    # The SassScript expression in the interpolation.
-    #
-    # @param [Sass::Script::Node]
-    attr_accessor :value
-
-    # The value of the expression after it's been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_value
-
-    def initialize(value)
-      @value = value
-    end
-
-    def perform(env)
-      val = value.perform(env)
-      @resolved_value = val.is_a?(Sass::Script::String) ? val.value : val.to_s
-    end
-
-    def to_css
-      @resolved_value
-    end
-
-    def to_src(options)
-      "\#{#{@value.to_sass(options)}}"
-    end
-
-    def deep_copy
-      copy = dup
-      copy.value = @value.deep_copy
-      copy
-    end
-
-    def options=(options)
-      @value.options = options
-    end
-  end
-end

data/lib/sass/tree/charset_node.rb

@@ -1,22 +0,0 @@
-module Sass::Tree
-  # A static node representing an unproccessed Sass `@charset` directive.
-  #
-  # @see Sass::Tree
-  class CharsetNode < Node
-    # The name of the charset.
-    #
-    # @return [String]
-    attr_accessor :name
-
-    # @param name [String] see \{#name}
-    def initialize(name)
-      @name = name
-      super()
-    end
-
-    # @see Node#invisible?
-    def invisible?
-      !Sass::Util.ruby1_8?
-    end
-  end
-end

data/lib/sass/tree/comment_node.rb

@@ -1,82 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A static node representing a Sass comment (silent or loud).
-  #
-  # @see Sass::Tree
-  class CommentNode < Node
-    # The text of the comment, not including `/*` and `*/`.
-    # Interspersed with {Sass::Script::Node}s representing `#{}`-interpolation
-    # if this is a loud comment.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :value
-
-    # The text of the comment
-    # after any interpolated SassScript has been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_value
-
-    # The type of the comment. `:silent` means it's never output to CSS,
-    # `:normal` means it's output in every compile mode except `:compressed`,
-    # and `:loud` means it's output even in `:compressed`.
-    #
-    # @return [Symbol]
-    attr_accessor :type
-
-    # @param value [Array<String, Sass::Script::Node>] See \{#value}
-    # @param type [Symbol] See \{#type}
-    def initialize(value, type)
-      @value = Sass::Util.with_extracted_values(value) {|str| normalize_indentation str}
-      @type = type
-      super()
-    end
-
-    # Compares the contents of two comments.
-    #
-    # @param other [Object] The object to compare with
-    # @return [Boolean] Whether or not this node and the other object
-    #   are the same
-    def ==(other)
-      self.class == other.class && value == other.value && type == other.type
-    end
-
-    # Returns `true` if this is a silent comment
-    # or the current style doesn't render comments.
-    #
-    # Comments starting with ! are never invisible (and the ! is removed from the output.)
-    #
-    # @return [Boolean]
-    def invisible?
-      case @type
-      when :loud; false
-      when :silent; true
-      else; style == :compressed
-      end
-    end
-
-    # Returns the number of lines in the comment.
-    #
-    # @return [Fixnum]
-    def lines
-      @value.inject(0) do |s, e|
-        next s + e.count("\n") if e.is_a?(String)
-        next s
-      end
-    end
-
-    private
-
-    def normalize_indentation(str)
-      ind = str.split("\n").inject(str[/^[ \t]*/].split("")) do |pre, line|
-        line[/^[ \t]*/].split("").zip(pre).inject([]) do |arr, (a, b)|
-          break arr if a != b
-          arr << a
-        end
-      end.join
-      str.gsub(/^#{ind}/, '')
-    end
-  end
-end

data/lib/sass/tree/content_node.rb

@@ -1,9 +0,0 @@
-module Sass
-  module Tree
-    # A node representing the placement within a mixin of the include statement's content.
-    #
-    # @see Sass::Tree
-    class ContentNode < Node
-    end
-  end
-end

data/lib/sass/tree/css_import_node.rb

@@ -1,60 +0,0 @@
-module Sass::Tree
-  # A node representing an `@import` rule that's importing plain CSS.
-  #
-  # @see Sass::Tree
-  class CssImportNode < DirectiveNode
-    # The URI being imported, either as a plain string or an interpolated
-    # script string.
-    #
-    # @return [String, Sass::Script::Node]
-    attr_accessor :uri
-
-    # The text of the URI being imported after any interpolated SassScript has
-    # been resolved. Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_uri
-
-    # The media query for this rule, interspersed with {Sass::Script::Node}s
-    # representing `#{}`-interpolation. Any adjacent strings will be merged
-    # together.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :query
-
-    # The media query for this rule, without any unresolved interpolation. It's
-    # only set once {Tree::Node#perform} has been called.
-    #
-    # @return [Sass::Media::QueryList]
-    attr_accessor :resolved_query
-
-    # @param uri [String, Sass::Script::Node] See \{#uri}
-    # @param query [Array<String, Sass::Script::Node>] See \{#query}
-    def initialize(uri, query = nil)
-      @uri = uri
-      @query = query
-      super('')
-    end
-
-    # @param uri [String] See \{#resolved_uri}
-    # @return [CssImportNode]
-    def self.resolved(uri)
-      node = new(uri)
-      node.resolved_uri = uri
-      node
-    end
-
-    # @see DirectiveNode#value
-    def value; raise NotImplementedError; end
-
-    # @see DirectiveNode#resolved_value
-    def resolved_value
-      @resolved_value ||=
-        begin
-          str = "@import #{resolved_uri}"
-          str << " #{resolved_query.to_css}" if resolved_query
-          str
-        end
-    end
-  end
-end

data/lib/sass/tree/debug_node.rb

@@ -1,18 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a Sass `@debug` statement.
-    #
-    # @see Sass::Tree
-    class DebugNode < Node
-      # The expression to print.
-      # @return [Script::Node] 
-      attr_accessor :expr
-
-      # @param expr [Script::Node] The expression to print
-      def initialize(expr)
-        @expr = expr
-        super()
-      end
-    end
-  end
-end

data/lib/sass/tree/directive_node.rb

@@ -1,42 +0,0 @@
-module Sass::Tree
-  # A static node representing an unproccessed Sass `@`-directive.
-  # Directives known to Sass, like `@for` and `@debug`,
-  # are handled by their own nodes;
-  # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
-  #
-  # `@import` and `@charset` are special cases;
-  # they become {ImportNode}s and {CharsetNode}s, respectively.
-  #
-  # @see Sass::Tree
-  class DirectiveNode < Node
-    # The text of the directive, `@` and all, with interpolation included.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :value
-
-    # The text of the directive after any interpolated SassScript has been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_value
-
-    # @param value [Array<String, Sass::Script::Node>] See \{#value}
-    def initialize(value)
-      @value = value
-      super()
-    end
-
-    # @param value [String] See \{#resolved_value}
-    # @return [DirectiveNode]
-    def self.resolved(value)
-      node = new([value])
-      node.resolved_value = value
-      node
-    end
-
-    # @return [String] The name of the directive, including `@`.
-    def name
-      value.first.gsub(/ .*$/, '')
-    end
-  end
-end

data/lib/sass/tree/each_node.rb

@@ -1,24 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A dynamic node representing a Sass `@each` loop.
-  #
-  # @see Sass::Tree
-  class EachNode < Node
-    # The name of the loop variable.
-    # @return [String]
-    attr_reader :var
-
-    # The parse tree for the list.
-    # @param [Script::Node]
-    attr_accessor :list
-
-    # @param var [String] The name of the loop variable
-    # @param list [Script::Node] The parse tree for the list
-    def initialize(var, list)
-      @var = var
-      @list = list
-      super()
-    end
-  end
-end

data/lib/sass/tree/extend_node.rb

@@ -1,36 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A static node reprenting an `@extend` directive.
-  #
-  # @see Sass::Tree
-  class ExtendNode < Node
-    # The parsed selector after interpolation has been resolved.
-    # Only set once {Tree::Visitors::Perform} has been run.
-    #
-    # @return [Selector::CommaSequence]
-    attr_accessor :resolved_selector
-
-    # The CSS selector to extend, interspersed with {Sass::Script::Node}s
-    # representing `#{}`-interpolation.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :selector
-
-    # Whether the `@extend` is allowed to match no selectors or not.
-    #
-    # @return [Boolean]
-    def optional?; @optional; end
-
-    # @param selector [Array<String, Sass::Script::Node>]
-    #   The CSS selector to extend,
-    #   interspersed with {Sass::Script::Node}s
-    #   representing `#{}`-interpolation.
-    # @param optional [Boolean] See \{#optional}
-    def initialize(selector, optional)
-      @selector = selector
-      @optional = optional
-      super()
-    end
-  end
-end

data/lib/sass/tree/for_node.rb

@@ -1,36 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A dynamic node representing a Sass `@for` loop.
-  #
-  # @see Sass::Tree
-  class ForNode < Node
-    # The name of the loop variable.
-    # @return [String]
-    attr_reader :var
-
-    # The parse tree for the initial expression.
-    # @return [Script::Node]
-    attr_accessor :from
-
-    # The parse tree for the final expression.
-    # @return [Script::Node]
-    attr_accessor :to
-
-    # Whether to include `to` in the loop or stop just before.
-    # @return [Boolean]
-    attr_reader :exclusive
-
-    # @param var [String] See \{#var}
-    # @param from [Script::Node] See \{#from}
-    # @param to [Script::Node] See \{#to}
-    # @param exclusive [Boolean] See \{#exclusive}
-    def initialize(var, from, to, exclusive)
-      @var = var
-      @from = from
-      @to = to
-      @exclusive = exclusive
-      super()
-    end
-  end
-end

data/lib/sass/tree/function_node.rb

@@ -1,34 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a function definition.
-    #
-    # @see Sass::Tree
-    class FunctionNode < Node
-      # The name of the function.
-      # @return [String]
-      attr_reader :name
-
-      # The arguments to the function. 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>]
-      attr_accessor :args
-
-      # The splat argument for this function, if one exists.
-      #
-      # @return [Script::Node?]
-      attr_accessor :splat
-
-      # @param name [String] The function name
-      # @param args [Array<(Script::Node, Script::Node)>] The arguments for the function.
-      # @param splat [Script::Node] See \{#splat}
-      def initialize(name, args, splat)
-        @name = name
-        @args = args
-        @splat = splat
-        super()
-      end
-    end
-  end
-end