sass 3.3.0.alpha.149 → 3.3.0.alpha.162

data/test/test_helper.rb

@@ -16,7 +16,7 @@ end
 
 module Sass::Script::Functions
   def option(name)
-    Sass::Script::String.new(@options[name.value.to_sym].to_s)
+    Sass::Script::Value::String.new(@options[name.value.to_sym].to_s)
   end
 end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302631
+  hash: 592302665
   prerelease: 6
   segments: 
   - 3
   - 3
   - 0
   - alpha
-  - 149
-  version: 3.3.0.alpha.149
+  - 162
+  version: 3.3.0.alpha.162
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-05-24 00:00:00 -04:00
+date: 2013-05-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -113,26 +113,30 @@ files:
 - lib/sass/repl.rb
 - lib/sass/root.rb
 - lib/sass/script.rb
-- lib/sass/script/arg_list.rb
-- lib/sass/script/bool.rb
-- lib/sass/script/color.rb
 - lib/sass/script/css_lexer.rb
 - lib/sass/script/css_parser.rb
-- lib/sass/script/funcall.rb
 - lib/sass/script/functions.rb
-- lib/sass/script/interpolation.rb
 - lib/sass/script/lexer.rb
-- lib/sass/script/list.rb
-- lib/sass/script/literal.rb
-- lib/sass/script/node.rb
-- lib/sass/script/null.rb
-- lib/sass/script/number.rb
-- lib/sass/script/operation.rb
 - lib/sass/script/parser.rb
-- lib/sass/script/string.rb
-- lib/sass/script/string_interpolation.rb
-- lib/sass/script/unary_operation.rb
-- lib/sass/script/variable.rb
+- lib/sass/script/tree.rb
+- lib/sass/script/tree/funcall.rb
+- lib/sass/script/tree/interpolation.rb
+- lib/sass/script/tree/list_literal.rb
+- lib/sass/script/tree/literal.rb
+- lib/sass/script/tree/node.rb
+- lib/sass/script/tree/operation.rb
+- lib/sass/script/tree/string_interpolation.rb
+- lib/sass/script/tree/unary_operation.rb
+- lib/sass/script/tree/variable.rb
+- lib/sass/script/value.rb
+- lib/sass/script/value/arg_list.rb
+- lib/sass/script/value/base.rb
+- lib/sass/script/value/bool.rb
+- lib/sass/script/value/color.rb
+- lib/sass/script/value/list.rb
+- lib/sass/script/value/null.rb
+- lib/sass/script/value/number.rb
+- lib/sass/script/value/string.rb
 - lib/sass/scss.rb
 - lib/sass/scss/css_parser.rb
 - lib/sass/scss/parser.rb

data/lib/sass/script/funcall.rb

@@ -1,238 +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 = {})
-        arg_to_sass = lambda do |arg|
-          sass = arg.to_sass(opts)
-          sass = "(#{sass})" if arg.is_a?(Sass::Script::List) && arg.separator == :comma
-          sass
-        end
-
-        args = @args.map(&arg_to_sass).join(', ')
-        keywords = Sass::Util.hash_to_a(@keywords).
-          map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}.join(', ')
-        if self.splat
-          splat = (args.empty? && keywords.empty?) ? "" : ", "
-          splat = "#{splat}#{arg_to_sass[self.splat]}..."
-        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
-          local_environment = Environment.new(environment.global_env, environment.options)
-          opts(Functions::EvaluationContext.new(local_environment).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/literal.rb

@@ -1,221 +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 `=` 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