sass 3.2.7 → 3.3.0.rc.1

data/lib/sass/script/bool.rb

@@ -1,18 +0,0 @@
-require 'sass/script/literal'
-
-module Sass::Script
-  # A SassScript object representing a boolean (true or false) value.
-  class Bool < Literal
-    # The Ruby value of the boolean.
-    #
-    # @return [Boolean]
-    attr_reader :value
-    alias_method :to_bool, :value
-
-    # @return [String] "true" or "false"
-    def to_s(opts = {})
-      @value.to_s
-    end
-    alias_method :to_sass, :to_s
-  end
-end

data/lib/sass/script/funcall.rb

@@ -1,231 +0,0 @@
-require 'sass/script/functions'
-
-module Sass
-  module Script
-    # A SassScript parse node representing a function call.
-    #
-    # A function call either calls one of the functions in {Script::Functions},
-    # or if no function with the given name exists
-    # it returns a string representation of the function call.
-    class Funcall < Node
-      # The name of the function.
-      #
-      # @return [String]
-      attr_reader :name
-
-      # The arguments to the function.
-      #
-      # @return [Array<Script::Node>]
-      attr_reader :args
-
-      # The keyword arguments to the function.
-      #
-      # @return [{String => Script::Node}]
-      attr_reader :keywords
-
-      # The splat argument for this function, if one exists.
-      #
-      # @return [Script::Node?]
-      attr_accessor :splat
-
-      # @param name [String] See \{#name}
-      # @param args [Array<Script::Node>] See \{#args}
-      # @param splat [Script::Node] See \{#splat}
-      # @param keywords [{String => Script::Node}] See \{#keywords}
-      def initialize(name, args, keywords, splat)
-        @name = name
-        @args = args
-        @keywords = keywords
-        @splat = splat
-        super()
-      end
-
-      # @return [String] A string representation of the function call
-      def inspect
-        args = @args.map {|a| a.inspect}.join(', ')
-        keywords = Sass::Util.hash_to_a(@keywords).
-            map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
-        if self.splat
-          splat = (args.empty? && keywords.empty?) ? "" : ", "
-          splat = "#{splat}#{self.splat.inspect}..."
-        end
-        "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
-      end
-
-      # @see Node#to_sass
-      def to_sass(opts = {})
-        args = @args.map {|a| a.to_sass(opts)}.join(', ')
-        keywords = Sass::Util.hash_to_a(@keywords).
-          map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
-        if self.splat
-          splat = (args.empty? && keywords.empty?) ? "" : ", "
-          splat = "#{splat}#{self.splat.inspect}..."
-        end
-        "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
-      end
-
-      # Returns the arguments to the function.
-      #
-      # @return [Array<Node>]
-      # @see Node#children
-      def children
-        res = @args + @keywords.values
-        res << @splat if @splat
-        res
-      end
-
-      # @see Node#deep_copy
-      def deep_copy
-        node = dup
-        node.instance_variable_set('@args', args.map {|a| a.deep_copy})
-        node.instance_variable_set('@keywords', Hash[keywords.map {|k, v| [k, v.deep_copy]}])
-        node
-      end
-
-      protected
-
-      # Evaluates the function call.
-      #
-      # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-      # @return [Literal] The SassScript object that is the value of the function call
-      # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
-      def _perform(environment)
-        args = @args.map {|a| a.perform(environment)}
-        splat = @splat.perform(environment) if @splat
-        if fn = environment.function(@name)
-          keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
-          return perform_sass_fn(fn, args, keywords, splat)
-        end
-
-        ruby_name = @name.tr('-', '_')
-        args = construct_ruby_args(ruby_name, args, splat, environment)
-
-        unless Functions.callable?(ruby_name)
-          opts(to_literal(args))
-        else
-          opts(Functions::EvaluationContext.new(environment.options).send(ruby_name, *args))
-        end
-      rescue ArgumentError => e
-        message = e.message
-
-        # If this is a legitimate Ruby-raised argument error, re-raise it.
-        # Otherwise, it's an error in the user's stylesheet, so wrap it.
-        if Sass::Util.rbx?
-          # Rubinius has a different error report string than vanilla Ruby. It
-          # also doesn't put the actual method for which the argument error was
-          # thrown in the backtrace, nor does it include `send`, so we look for
-          # `_perform`.
-          if e.message =~ /^method '([^']+)': given (\d+), expected (\d+)/
-            error_name, given, expected = $1, $2, $3
-            raise e if error_name != ruby_name || e.backtrace[0] !~ /:in `_perform'$/
-            message = "wrong number of arguments (#{given} for #{expected})"
-          end
-        elsif Sass::Util.jruby?
-          if Sass::Util.jruby1_6?
-            should_maybe_raise = e.message =~ /^wrong number of arguments \((\d+) for (\d+)\)/ &&
-              # The one case where JRuby does include the Ruby name of the function
-              # is manually-thrown ArgumentErrors, which are indistinguishable from
-              # legitimate ArgumentErrors. We treat both of these as
-              # Sass::SyntaxErrors even though it can hide Ruby errors.
-              e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
-          else
-            should_maybe_raise = e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
-            given, expected = $1, $2
-          end
-
-          if should_maybe_raise
-            # JRuby 1.7 includes __send__ before send and _perform.
-            trace = e.backtrace.dup
-            raise e if !Sass::Util.jruby1_6? && trace.shift !~ /:in `__send__'$/
-
-            # JRuby (as of 1.7.2) doesn't put the actual method
-            # for which the argument error was thrown in the backtrace, so we
-            # detect whether our send threw an argument error.
-            if !(trace[0] =~ /:in `send'$/ && trace[1] =~ /:in `_perform'$/)
-              raise e
-            elsif !Sass::Util.jruby1_6?
-              # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
-              message = "wrong number of arguments (#{given} for #{expected})"
-            end
-          end
-        elsif e.message =~ /^wrong number of arguments \(\d+ for \d+\)/ &&
-            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
-          raise e
-        end
-        raise Sass::SyntaxError.new("#{message} for `#{name}'")
-      end
-
-      # This method is factored out from `_perform` so that compass can override
-      # it with a cross-browser implementation for functions that require vendor prefixes
-      # in the generated css.
-      def to_literal(args)
-        Script::String.new("#{name}(#{args.join(', ')})")
-      end
-
-      private
-
-      def construct_ruby_args(name, args, splat, environment)
-        args += splat.to_a if splat
-
-        # If variable arguments were passed, there won't be any explicit keywords.
-        if splat.is_a?(Sass::Script::ArgList)
-          kwargs_size = splat.keywords.size
-          splat.keywords_accessed = false
-        else
-          kwargs_size = @keywords.size
-        end
-
-        unless signature = Functions.signature(name.to_sym, args.size, kwargs_size)
-          return args if @keywords.empty?
-          raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")
-        end
-        keywords = splat.is_a?(Sass::Script::ArgList) ? splat.keywords :
-          Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
-
-        # If the user passes more non-keyword args than the function expects,
-        # but it does expect keyword args, Ruby's arg handling won't raise an error.
-        # Since we don't want to make functions think about this,
-        # we'll handle it for them here.
-        if signature.var_kwargs && !signature.var_args && args.size > signature.args.size
-          raise Sass::SyntaxError.new(
-            "#{args[signature.args.size].inspect} is not a keyword argument for `#{name}'")
-        elsif keywords.empty?
-          return args 
-        end
-
-        args = args + signature.args[args.size..-1].map do |argname|
-          if keywords.has_key?(argname)
-            keywords.delete(argname)
-          else
-            raise Sass::SyntaxError.new("Function #{name} requires an argument named $#{argname}")
-          end
-        end
-
-        if keywords.size > 0
-          if signature.var_kwargs
-            args << keywords
-          else
-            argname = keywords.keys.sort.first
-            if signature.args.include?(argname)
-              raise Sass::SyntaxError.new("Function #{name} was passed argument $#{argname} both by position and by name")
-            else
-              raise Sass::SyntaxError.new("Function #{name} doesn't have an argument named $#{argname}")
-            end
-          end
-        end
-
-        args
-      end
-
-      def perform_sass_fn(function, args, keywords, splat)
-        Sass::Tree::Visitors::Perform.perform_arguments(function, args, keywords, splat) do |env|
-          val = catch :_sass_return do
-            function.tree.each {|c| Sass::Tree::Visitors::Perform.visit(c, env)}
-            raise Sass::SyntaxError.new("Function #{@name} finished without @return")
-          end
-          val
-        end
-      end
-    end
-  end
-end

data/lib/sass/script/list.rb

@@ -1,84 +0,0 @@
-module Sass::Script
-  # A SassScript object representing a CSS list.
-  # This includes both comma-separated lists and space-separated lists.
-  class List < Literal
-    # The Ruby array containing the contents of the list.
-    #
-    # @return [Array<Literal>]
-    attr_reader :value
-    alias_method :children, :value
-    alias_method :to_a, :value
-
-    # The operator separating the values of the list.
-    # Either `:comma` or `:space`.
-    #
-    # @return [Symbol]
-    attr_reader :separator
-
-    # Creates a new list.
-    #
-    # @param value [Array<Literal>] See \{#value}
-    # @param separator [String] See \{#separator}
-    def initialize(value, separator)
-      super(value)
-      @separator = separator
-    end
-
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@value', value.map {|c| c.deep_copy})
-      node
-    end
-
-    # @see Node#eq
-    def eq(other)
-      Sass::Script::Bool.new(
-        other.is_a?(List) && self.value == other.value &&
-        self.separator == other.separator)
-    end
-
-    # @see Node#to_s
-    def to_s(opts = {})
-      raise Sass::SyntaxError.new("() isn't a valid CSS value.") if value.empty?
-      return value.reject {|e| e.is_a?(Null) || e.is_a?(List) && e.value.empty?}.map {|e| e.to_s(opts)}.join(sep_str)
-    end
-
-    # @see Node#to_sass
-    def to_sass(opts = {})
-      return "()" if value.empty?
-      precedence = Sass::Script::Parser.precedence_of(separator)
-      value.reject {|e| e.is_a?(Null)}.map do |v|
-        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence
-          "(#{v.to_sass(opts)})"
-        else
-          v.to_sass(opts)
-        end
-      end.join(sep_str(nil))
-    end
-
-    # @see Node#inspect
-    def inspect
-      "(#{to_sass})"
-    end
-
-    protected
-
-    # @see Node#_perform
-    def _perform(environment)
-      list = Sass::Script::List.new(
-        value.map {|e| e.perform(environment)},
-        separator)
-      list.options = self.options
-      list
-    end
-
-    private
-
-    def sep_str(opts = self.options)
-      return ' ' if separator == :space
-      return ',' if opts && opts[:style] == :compressed
-      return ', '
-    end
-  end
-end

data/lib/sass/script/literal.rb

@@ -1,239 +0,0 @@
-module Sass::Script
-  # The abstract superclass for SassScript objects.
-  #
-  # Many of these methods, especially the ones that correspond to SassScript operations,
-  # are designed to be overridden by subclasses which may change the semantics somewhat.
-  # The operations listed here are just the defaults.
-  class Literal < Node
-    require 'sass/script/string'
-    require 'sass/script/number'
-    require 'sass/script/color'
-    require 'sass/script/bool'
-    require 'sass/script/null'
-    require 'sass/script/list'
-    require 'sass/script/arg_list'
-
-    # Returns the Ruby value of the literal.
-    # The type of this value varies based on the subclass.
-    #
-    # @return [Object]
-    attr_reader :value
-
-    # Creates a new literal.
-    #
-    # @param value [Object] The object for \{#value}
-    def initialize(value = nil)
-      @value = value
-      super()
-    end
-
-    # Returns an empty array.
-    #
-    # @return [Array<Node>] empty
-    # @see Node#children
-    def children
-      []
-    end
-
-    # @see Node#deep_copy
-    def deep_copy
-      dup
-    end
-
-    # Returns the options hash for this node.
-    #
-    # @return [{Symbol => Object}]
-    # @raise [Sass::SyntaxError] if the options hash hasn't been set.
-    #   This should only happen when the literal was created
-    #   outside of the parser and \{#to\_s} was called on it
-    def options
-      opts = super
-      return opts if opts
-      raise Sass::SyntaxError.new(<<MSG)
-The #options attribute is not set on this #{self.class}.
-  This error is probably occurring because #to_s was called
-  on this literal within a custom Sass function without first
-  setting the #option attribute.
-MSG
-    end
-
-    # The SassScript `==` operation.
-    # **Note that this returns a {Sass::Script::Bool} object,
-    # not a Ruby boolean**.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Bool] True if this literal is the same as the other,
-    #   false otherwise
-    def eq(other)
-      Sass::Script::Bool.new(self.class == other.class && self.value == other.value)
-    end
-
-    # The SassScript `!=` operation.
-    # **Note that this returns a {Sass::Script::Bool} object,
-    # not a Ruby boolean**.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Bool] False if this literal is the same as the other,
-    #   true otherwise
-    def neq(other)
-      Sass::Script::Bool.new(!eq(other).to_bool)
-    end
-
-    # The SassScript `==` operation.
-    # **Note that this returns a {Sass::Script::Bool} object,
-    # not a Ruby boolean**.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Bool] True if this literal is the same as the other,
-    #   false otherwise
-    def unary_not
-      Sass::Script::Bool.new(!to_bool)
-    end
-
-    # The SassScript default operation (e.g. `$a $b`, `"foo" "bar"`).
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing both literals
-    #   separated by a space
-    def space(other)
-      Sass::Script::String.new("#{self.to_s} #{other.to_s}")
-    end
-
-    # The SassScript `,` operation (e.g. `$a, $b`, `"foo", "bar"`).
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing both literals
-    #   separated by `", "`
-    def comma(other)
-      Sass::Script::String.new("#{self.to_s},#{' ' unless options[:style] == :compressed}#{other.to_s}")
-    end
-
-    # The SassScript `=` operation
-    # (used for proprietary MS syntax like `alpha(opacity=20)`).
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing both literals
-    #   separated by `"="`
-    def single_eq(other)
-      Sass::Script::String.new("#{self.to_s}=#{other.to_s}")
-    end
-
-    # The SassScript `+` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing both literals
-    #   without any separation
-    def plus(other)
-      if other.is_a?(Sass::Script::String)
-        return Sass::Script::String.new(self.to_s + other.value, other.type)
-      end
-      Sass::Script::String.new(self.to_s + other.to_s)
-    end
-
-    # The SassScript `-` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing both literals
-    #   separated by `"-"`
-    def minus(other)
-      Sass::Script::String.new("#{self.to_s}-#{other.to_s}")
-    end
-
-    # The SassScript `/` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing both literals
-    #   separated by `"/"`
-    def div(other)
-      Sass::Script::String.new("#{self.to_s}/#{other.to_s}")
-    end
-
-    # The SassScript unary `+` operation (e.g. `+$a`).
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing the literal
-    #   preceded by `"+"`
-    def unary_plus
-      Sass::Script::String.new("+#{self.to_s}")
-    end
-
-    # The SassScript unary `-` operation (e.g. `-$a`).
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing the literal
-    #   preceded by `"-"`
-    def unary_minus
-      Sass::Script::String.new("-#{self.to_s}")
-    end
-
-    # The SassScript unary `/` operation (e.g. `/$a`).
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Script::String] A string containing the literal
-    #   preceded by `"/"`
-    def unary_div
-      Sass::Script::String.new("/#{self.to_s}")
-    end
-
-    # @return [String] A readable representation of the literal
-    def inspect
-      value.inspect
-    end
-
-    # @return [Boolean] `true` (the Ruby boolean value)
-    def to_bool
-      true
-    end
-
-    # Compares this object with another.
-    #
-    # @param other [Object] The object to compare with
-    # @return [Boolean] Whether or not this literal is equivalent to `other`
-    def ==(other)
-      eq(other).to_bool
-    end
-
-    # @return [Fixnum] The integer value of this literal
-    # @raise [Sass::SyntaxError] if this literal isn't an integer
-    def to_i
-      raise Sass::SyntaxError.new("#{self.inspect} is not an integer.")
-    end
-
-    # @raise [Sass::SyntaxError] if this literal isn't an integer
-    def assert_int!; to_i; end
-
-    # Returns the value of this literal as a list.
-    # Single literals are considered the same as single-element lists.
-    #
-    # @return [Array<Literal>] The of this literal as a list
-    def to_a
-      [self]
-    end
-
-    # Returns the string representation of this literal
-    # as it would be output to the CSS document.
-    #
-    # @return [String]
-    def to_s(opts = {})
-      raise Sass::SyntaxError.new("[BUG] All subclasses of Sass::Literal must implement #to_s.")
-    end
-    alias_method :to_sass, :to_s
-
-    # Returns whether or not this object is null.
-    #
-    # @return [Boolean] `false`
-    def null?
-      false
-    end
-
-    protected
-
-    # Evaluates the literal.
-    #
-    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Literal] This literal
-    def _perform(environment)
-      self
-    end
-  end
-end

data/lib/sass/script/null.rb

@@ -1,34 +0,0 @@
-require 'sass/script/literal'
-
-module Sass::Script
-  # A SassScript object representing a null value.
-  class Null < Literal
-    # Creates a new null literal.
-    def initialize
-      super nil
-    end
-
-    # @return [Boolean] `false` (the Ruby boolean value)
-    def to_bool
-      false
-    end
-
-    # @return [Boolean] `true`
-    def null?
-      true
-    end
-
-    # @return [String] '' (An empty string)
-    def to_s(opts = {})
-      ''
-    end
-    alias_method :to_sass, :to_s
-
-    # Returns a string representing a null value.
-    #
-    # @return [String]
-    def inspect
-      'null'
-    end
-  end
-end

data/lib/sass/script/variable.rb

@@ -1,58 +0,0 @@
-module Sass
-  module Script
-    # A SassScript parse node representing a variable.
-    class Variable < Node
-      # The name of the variable.
-      #
-      # @return [String]
-      attr_reader :name
-
-      # The underscored name of the variable.
-      #
-      # @return [String]
-      attr_reader :underscored_name
-
-      # @param name [String] See \{#name}
-      def initialize(name)
-        @name = name
-        @underscored_name = name.gsub(/-/,"_")
-        super()
-      end
-
-      # @return [String] A string representation of the variable
-      def inspect(opts = {})
-        "$#{dasherize(name, opts)}"
-      end
-      alias_method :to_sass, :inspect
-
-      # Returns an empty array.
-      #
-      # @return [Array<Node>] empty
-      # @see Node#children
-      def children
-        []
-      end
-
-      # @see Node#deep_copy
-      def deep_copy
-        dup
-      end
-
-      protected
-
-      # Evaluates the variable.
-      #
-      # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-      # @return [Literal] The SassScript object that is the value of the variable
-      # @raise [Sass::SyntaxError] if the variable is undefined
-      def _perform(environment)
-        raise SyntaxError.new("Undefined variable: \"$#{name}\".") unless val = environment.var(name)
-        if val.is_a?(Number)
-          val = val.dup
-          val.original = nil
-        end
-        return val
-      end
-    end
-  end
-end

data/test/Gemfile

@@ -1,3 +0,0 @@
-source :gemcutter
-
-gem 'rake'