sass 3.3.0.alpha.354 → 3.3.0.alpha.364

data/REVISION

@@ -1 +1 @@
-77ed5f71b755020c48ab0243b667a064b0510efb
+4e515ab6a46507013fcbe426a5ecfa061b4ae571

data/VERSION

@@ -1 +1 @@
-3.3.0.alpha.354
+3.3.0.alpha.364

data/VERSION_DATE

@@ -1 +1 @@
-05 October 2013 01:29:09 GMT
+05 October 2013 16:04:57 GMT

data/lib/sass/environment.rb

@@ -1,28 +1,80 @@
 require 'set'
 
 module Sass
-  # The lexical environment for SassScript.
-  # This keeps track of variable, mixin, and function definitions.
-  #
-  # A new environment is created for each level of Sass nesting.
-  # This allows variables to be lexically scoped.
-  # The new environment refers to the environment in the upper scope,
-  # so it has access to variables defined in enclosing scopes,
-  # but new variables are defined locally.
-  #
-  # Environment also keeps track of the {Engine} options
-  # so that they can be made available to {Sass::Script::Functions}.
-  class Environment
-    # The enclosing environment,
-    # or nil if this is the global environment.
-    #
-    # @return [Environment]
-    attr_reader :parent
+
+  # The abstract base class for lexical environments for SassScript.
+  class BaseEnvironment
+    class << self
+      # Note: when updating this,
+      # update sass/yard/inherited_hash.rb as well.
+      def inherited_hash_accessor(name)
+        inherited_hash_reader(name)
+        inherited_hash_writer(name)
+      end
+
+      def inherited_hash_reader(name)
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}(name)
+            _#{name}(name.tr('_', '-'))
+          end
+
+          def _#{name}(name)
+            (@#{name}s && @#{name}s[name]) || @parent && @parent._#{name}(name)
+          end
+          protected :_#{name}
+        RUBY
+      end
+
+      def inherited_hash_writer(name)
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def set_#{name}(name, value)
+            name = name.tr('_', '-')
+            @#{name}s[name] = value unless try_set_#{name}(name, value)
+          end
+
+          def try_set_#{name}(name, value)
+            @#{name}s ||= {}
+            if @#{name}s.include?(name)
+              @#{name}s[name] = value
+              true
+            elsif @parent
+              @parent.try_set_#{name}(name, value)
+            else
+              false
+            end
+          end
+          protected :try_set_#{name}
+
+          def set_local_#{name}(name, value)
+            @#{name}s ||= {}
+            @#{name}s[name.tr('_', '-')] = value
+          end
+        RUBY
+      end
+    end
+
+    # The options passed to the Sass Engine.
     attr_reader :options
+
+    # [Environment] The caller environment
     attr_writer :caller
+
+    # [Environment] The content environment
     attr_writer :content
     attr_writer :selector
 
+    # variable
+    # Script::Value
+    inherited_hash_reader :var
+
+    # mixin
+    # Sass::Callable
+    inherited_hash_reader :mixin
+
+    # function
+    # Sass::Callable
+    inherited_hash_reader :function
+
     # @param options [{Symbol => Object}] The options hash. See
     #   {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
     # @param parent [Environment] See \{#parent}
@@ -38,7 +90,7 @@ module Sass
       @caller || (@parent && @parent.caller)
     end
 
-    # The content passed to this environmnet. This is naturally only set
+    # The content passed to this environment. This is naturally only set
     # for mixin body environments with content passed in.
     # @return {Environment?}
     def content
@@ -70,62 +122,59 @@ module Sass
     def stack
       @stack || global_env.stack
     end
+  end
 
-    private
-
-    class << self
-
-      private
-
-      UNDERSCORE, DASH = '_', '-'
-
-      # Note: when updating this,
-      # update sass/yard/inherited_hash.rb as well.
-      def inherited_hash(name)
-        class_eval <<RUBY, __FILE__, __LINE__ + 1
-          def #{name}(name)
-            _#{name}(name.tr(UNDERSCORE, DASH))
-          end
-
-          def _#{name}(name)
-            (@#{name}s && @#{name}s[name]) || @parent && @parent._#{name}(name)
-          end
-          protected :_#{name}
-
-          def set_#{name}(name, value)
-            name = name.tr(UNDERSCORE, DASH)
-            @#{name}s[name] = value unless try_set_#{name}(name, value)
-          end
-
-          def try_set_#{name}(name, value)
-            @#{name}s ||= {}
-            if @#{name}s.include?(name)
-              @#{name}s[name] = value
-              true
-            elsif @parent
-              @parent.try_set_#{name}(name, value)
-            else
-              false
-            end
-          end
-          protected :try_set_#{name}
-
-          def set_local_#{name}(name, value)
-            @#{name}s ||= {}
-            @#{name}s[name.tr(UNDERSCORE, DASH)] = value
-          end
-RUBY
-      end
-    end
+  # The lexical environment for SassScript.
+  # This keeps track of variable, mixin, and function definitions.
+  #
+  # A new environment is created for each level of Sass nesting.
+  # This allows variables to be lexically scoped.
+  # The new environment refers to the environment in the upper scope,
+  # so it has access to variables defined in enclosing scopes,
+  # but new variables are defined locally.
+  #
+  # Environment also keeps track of the {Engine} options
+  # so that they can be made available to {Sass::Script::Functions}.
+  class Environment < BaseEnvironment
+    # The enclosing environment,
+    # or nil if this is the global environment.
+    #
+    # @return [Environment]
+    attr_reader :parent
 
     # variable
     # Script::Value
-    inherited_hash :var
+    inherited_hash_writer :var
+
     # mixin
     # Sass::Callable
-    inherited_hash :mixin
+    inherited_hash_writer :mixin
+
     # function
     # Sass::Callable
-    inherited_hash :function
+    inherited_hash_writer :function
+  end
+
+  # A read-only wrapper for a lexical environment for SassScript.
+  class ReadOnlyEnvironment < BaseEnvironment
+    # The read-only environment of the caller of this environment's mixin or function.
+    #
+    # @see BaseEnvironment#caller
+    # @return {ReadOnlyEnvironment}
+    def caller
+      return @caller if @caller
+      env = super
+      @caller ||= env.is_a?(ReadOnlyEnvironment) ? env : ReadOnlyEnvironment.new(env, env.options)
+    end
+
+    # The read-only content passed to this environment.
+    #
+    # @see BaseEnvironment#content
+    # @return {ReadOnlyEnvironment}
+    def content
+      return @content if @content
+      env = super
+      @content ||= env.is_a?(ReadOnlyEnvironment) ? env : ReadOnlyEnvironment.new(env, env.options)
+    end
   end
 end

data/lib/sass/script/functions.rb

@@ -207,6 +207,18 @@ module Sass::Script
   # \{#feature_exists feature-exists($feature)}
   # : Returns whether a feature exists in the current Sass runtime.
   #
+  # \{#variable_exists variable-exists($name)}
+  # : Returns whether a variable with the given name exists in the current scope.
+  #
+  # \{#global_variable_exists global-variable-exists($name)}
+  # : Returns whether a variable with the given name exists in the global scope.
+  #
+  # \{#function_exists function-exists($name)}
+  # : Returns whether a function with the given name exists.
+  #
+  # \{#mixin_exists mixin-exists($name)}
+  # : Returns whether a mixin with the given name exists.
+  #
   # \{#type_of type-of($value)}
   # : Returns the type of a value.
   #
@@ -2033,6 +2045,79 @@ module Sass::Script
     end
     declare :counters, [], :var_args => true
 
+    # Check whether a variable with the given name exists in the current
+    # scope or in the global scope.
+    #
+    # @example
+    #   $a-false-value: false;
+    #   variable-exists(a-false-value) => true
+    #
+    #   variable-exists(nonexistent) => false
+    # @param name [Sass::Script::String] The name of the variable to
+    #   check. The name should not include the `$`.
+    # @return [Sass::Script::Bool] Whether the variable is defined in
+    #   the current scope.
+    def variable_exists(name)
+      assert_type name, :String
+      Sass::Script::Value::Bool.new(environment.caller.var(name.value))
+    end
+    declare :variable_exists, [:name]
+
+    # Check whether a variable with the given name exists in the global
+    # scope (at the top level of the file).
+    #
+    # @example
+    #   $a-false-value: false;
+    #   global-variable-exists(a-false-value) => true
+    #
+    #   .foo {
+    #     $some-var: false;
+    #     @if global-variable-exists(some-var) { /* false, doesn't run */ }
+    #   }
+    # @param name [Sass::Script::String] The name of the variable to
+    #   check.  The name should not include the `$`.
+    # @return [Sass::Script::Bool] Whether the variable is defined in
+    #   the global scope.
+    def global_variable_exists(name)
+      assert_type name, :String
+      Sass::Script::Value::Bool.new(environment.global_env.var(name.value))
+    end
+    declare :global_variable_exists, [:name]
+
+    # Check whether a function with the given name exists.
+    #
+    # @example
+    #   function-exists(lighten) => true
+    #
+    #   @function myfunc { @return "something"; }
+    #   function-exists(myfunc) => true
+    # @param name [Sass::Script::String] The name of the function to
+    #   check.
+    # @return [Sass::Script::Bool] Whether the function is defined.
+    def function_exists(name)
+      assert_type name, :String
+      exists = Sass::Script::Functions.callable?(name.value.tr("-", "_"))
+      exists ||= environment.function(name.value)
+      Sass::Script::Value::Bool.new(exists)
+    end
+    declare :function_exists, [:name]
+
+    # Check whether a mixin with the given name exists.
+    #
+    # @example
+    #   mixin-exists(nonexistent) => false
+    #
+    #   @mixin red-text { color: red; }
+    #   mixin-exists(red-text) => true
+    # @param name [Sass::Script::String] The name of the mixin to
+    #   check.
+    # @return [Sass::Script::Bool] Whether the mixin is defined.
+    def mixin_exists(name)
+      assert_type name, :String
+      Sass::Script::Value::Bool.new(environment.mixin(name.value))
+    end
+    declare :mixin_exists, [:name]
+
     private
 
     # This method implements the pattern of transforming a numeric value into

data/lib/sass/script/tree/funcall.rb

@@ -131,6 +131,7 @@ module Sass::Script::Tree
 
       if Sass::Script::Functions.callable?(ruby_name)
         local_environment = Sass::Environment.new(environment.global_env, environment.options)
+        local_environment.caller = Sass::ReadOnlyEnvironment.new(environment, environment.options)
         opts(Sass::Script::Functions::EvaluationContext.new(
           local_environment).send(ruby_name, *args))
       else

data/test/sass/functions_test.rb

@@ -1,7 +1,9 @@
 #!/usr/bin/env ruby
 require 'test/unit'
 require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
 require 'sass/script'
+require 'mock_importer'
 
 module Sass::Script::Functions
   def no_kw_args
@@ -1450,6 +1452,100 @@ WARNING
     assert_error_message "$color: 3px is not a color for `lighten'", "call(lighten, 3px, 5%)"
   end
 
+  def test_variable_exists
+    assert_equal <<CSS, render(<<SCSS)
+.test {
+  false: false;
+  true: true;
+  true: true;
+  true: true;
+  true: true; }
+CSS
+$global-var: has-value;
+.test {
+  false: variable-exists(foo);
+  $foo: has-value;
+  true: variable-exists(foo);
+  true: variable-exists($name: foo);
+  true: variable-exists(global-var);
+  true: variable-exists($name: global-var);
+}
+SCSS
+  end
+
+  def test_global_variable_exists
+    assert_equal <<CSS, render(<<SCSS)
+.test {
+  false: false;
+  false: false;
+  true: true;
+  true: true;
+  false: false;
+  true: true;
+  true: true; }
+CSS
+$g: something;
+$h: null;
+$false: global-variable-exists(foo);
+$true: global-variable-exists(g);
+$named: global-variable-exists($name: g);
+.test {
+  $foo: locally-defined;
+  false: global-variable-exists(foo);
+  false: global-variable-exists(foo2);
+  true: global-variable-exists(g);
+  true: global-variable-exists(h);
+  false: $false;
+  true: $true;
+  true: $named;
+}
+SCSS
+  end
+
+  def test_function_exists
+    # built-ins
+    assert_equal "true", evaluate("function-exists(lighten)")
+    # with named argument
+    assert_equal "true", evaluate("function-exists($name: lighten)")
+    # user-defined
+    assert_equal <<CSS, render(<<SCSS)
+.test {
+  foo-exists: true;
+  bar-exists: false; }
+CSS
+@function foo() { @return "foo" }
+.test {
+  foo-exists: function-exists(foo);
+  bar-exists: function-exists(bar);
+}
+SCSS
+  end
+
+  def test_mixin_exists
+    assert_equal "false", evaluate("mixin-exists(foo)")
+    # with named argument
+    assert_equal "false", evaluate("mixin-exists($name: foo)")
+    assert_equal <<CSS, render(<<SCSS)
+.test {
+  foo-exists: true;
+  bar-exists: false; }
+CSS
+@mixin foo() { foo: exists }
+.test {
+  foo-exists: mixin-exists(foo);
+  bar-exists: mixin-exists(bar);
+}
+SCSS
+  end
+
+  def test_existence_functions_check_argument_type
+    assert_error_message("2px is not a string for `function-exists'", "function-exists(2px)")
+    assert_error_message("2px is not a string for `mixin-exists'", "mixin-exists(2px)")
+    assert_error_message("2px is not a string for `global-variable-exists'", "global-variable-exists(2px)")
+    assert_error_message("2px is not a string for `variable-exists'", "variable-exists(2px)")
+  end
+
+
   ## Regression Tests
 
   def test_saturation_bounds
@@ -1457,8 +1553,8 @@ WARNING
   end
 
   private
-  def env(hash = {})
-    env = Sass::Environment.new
+  def env(hash = {}, parent = nil)
+    env = Sass::Environment.new(parent)
     hash.each {|k, v| env.set_var(k, v)}
     env
   end
@@ -1473,6 +1569,13 @@ WARNING
     Sass::Script::Parser.parse(value, 0, 0).perform(environment)
   end
 
+  def render(sass, options = {})
+    options[:syntax] ||= :scss
+    munge_filename options
+    options[:importer] ||= MockImporter.new
+    Sass::Engine.new(sass, options).render
+  end
+
   def assert_error_message(message, value)
     evaluate(value)
     flunk("Error message expected but not raised: #{message}")

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302537
+  hash: 592302549
   prerelease: 6
   segments: 
   - 3
   - 3
   - 0
   - alpha
-  - 354
-  version: 3.3.0.alpha.354
+  - 364
+  version: 3.3.0.alpha.364
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-10-04 00:00:00 -04:00
+date: 2013-10-05 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency