compass 0.13.alpha.4 → 0.13.alpha.5

data/frameworks/compass/stylesheets/compass/utilities/sprites/_sprite-img.scss

@@ -1,3 +1,5 @@
+@import "compass/typography/text/replacement";
+
 // @doc off
 // Example 1:
 //
@@ -76,4 +78,4 @@ $sprite-image-default-height: $sprite-default-size !default;
 // The name of the image in the sprite folder should be `$img-name`
 @mixin sprite-replace-text-with-dimensions ($map, $sprite, $offset-x: 0, $offset-y: 0){    
   @include sprite-replace-text ($map, $sprite, true, $offset-x, $offset-y);
-}
+}

data/frameworks/compass/stylesheets/compass/utilities/tables/_borders.scss

@@ -9,7 +9,7 @@
     th, td {
       border-top: $width solid $color; } }
   th {
-    &:first-child #{if($legacy-support-for-ie6, ', &.first', '')} {
+    &:first-child #{if(support-legacy-browser(ie, "6"), ', &.first', null)} {
       border-right: $width solid $color; } } }
 
 @mixin inner-table-borders($width: 2px, $color: black) {
@@ -24,7 +24,7 @@
 
     // IE8 ignores rules that are included on the same line as :last-child
     // see http://www.richardscarrott.co.uk/posts/view/ie8-last-child-bug for details
-    @if $legacy-support-for-ie6 or $legacy-support-for-ie7 or $legacy-support-for-ie8 {
+    @if support-legacy-browser(ie, "8") {
       &.last {
         border-right-width: 0px; } } }
 
@@ -32,7 +32,7 @@
     tr:last-child {
       th, td {
         border-bottom-width: 0px; } }
-    @if $legacy-support-for-ie6 or $legacy-support-for-ie7 or $legacy-support-for-ie8 {
+    @if support-legacy-browser(ie, "8") {
       tr.last {
         th, td {
           border-bottom-width: 0px; } } } } }

data/lib/compass.rb

@@ -29,7 +29,7 @@ module Compass
   extend QuickCache
 end
 
-%w(watcher configuration frameworks app_integration compiler).each do |lib|
+%w(watcher configuration frameworks app_integration compiler caniuse).each do |lib|
   require "compass/#{lib}"
 end
 

data/lib/compass/browser_support.rb

@@ -2,7 +2,7 @@ module Compass
   module BrowserSupport
     extend self
 
-    ASPECTS = %w(webkit moz o ms svg pie css2)
+    ASPECTS = %w(webkit moz o ms svg css2)
 
     SIMPLE_FUNCTIONS = {
            "image" => %w(), # No browsers implement this yet.

data/lib/compass/caniuse.rb

@@ -0,0 +1,247 @@
+require 'json'
+require 'singleton'
+class Compass::CanIUse
+  include Singleton
+
+  DATA_FILE_NAME = File.join(Compass.base_directory, "data", "caniuse.json")
+  DATA_FEATURE_FILES = Dir.glob(File.join(Compass.base_directory, "data", "caniuse_extras", "**", "*.json"))
+
+  def initialize
+    @data = JSON.parse(File.read(DATA_FILE_NAME))
+    # support ad-hoc features
+    DATA_FEATURE_FILES.each do |feature_file|
+      feature_name = File.basename(feature_file, ".json")
+      # if the feature doesn't exist in the master `caniuse.json`
+      if @data["data"][feature_name].nil?
+        @data["data"][feature_name] = JSON.parse(File.read(feature_file))
+      end
+    end
+  end
+
+  # The browser names from caniuse are ugly.
+  PUBLIC_BROWSER_NAMES = Hash.new {|h, k| k}
+  PUBLIC_BROWSER_NAMES.update(
+    "and_chr" => "android-chrome",
+    "and_ff"  => "android-firefox",
+    "android" => "android",
+    "bb"      => "blackberry",
+    "chrome"  => "chrome",
+    "firefox" => "firefox",
+    "ie"      => "ie",
+    "ie_mob"  => "ie-mobile",
+    "ios_saf" => "ios-safari",
+    "op_mini" => "opera-mini",
+    "op_mob"  => "opera-mobile",
+    "opera"   => "opera",
+    "safari"  => "safari"
+  )
+  CAN_I_USE_NAMES = Hash.new {|h, k| k}
+  CAN_I_USE_NAMES.update(PUBLIC_BROWSER_NAMES.invert)
+
+  # Returns all the known browsers according to caniuse
+  def browsers
+    @browsers ||= @data["agents"].keys.map{|b| PUBLIC_BROWSER_NAMES[b] }.sort
+  end
+
+  # Returns the prefix corresponding to a particular browser
+  def prefix(browser, version = nil)
+    assert_valid_browser browser
+    assert_valid_version browser, version if version
+    data = browser_data(browser)
+    p = if data["prefix_exceptions"] && data["prefix_exceptions"][version]
+          data["prefix_exceptions"][version]
+        else
+          data["prefix"]
+        end
+    "-#{p}"
+  end
+
+  # returns all possible prefixes a browser might use.
+  def all_prefixes(browser)
+    assert_valid_browser browser
+    data = browser_data(browser)
+    prefixes = ["-#{data["prefix"]}"]
+    if data["prefix_exceptions"]
+      prefixes += data["prefix_exceptions"].values.uniq.map{|p| "-#{p}"}
+    end
+    prefixes
+  end
+
+  # returns the prefixes needed by the list of browsers given
+  def prefixes(browsers = browsers)
+    result = browsers.map{|b| all_prefixes(b) }
+    result.flatten!
+    result.uniq!
+    result.sort!
+    result
+  end
+
+  def browser_minimums(capability, prefix = nil)
+    assert_valid_capability capability
+    browsers = prefix.nil? ? browsers() : browsers_with_prefix(prefix)
+    browsers.inject({}) do |m, browser|
+      version = versions(browser).find do |version|
+                  support = browser_support(browser, version, capability)
+                  if prefix.nil?
+                    support !~ /\bn\b/ && support !~ /\bx\b/
+                  else
+                    actual_prefix = prefix(browser, version)
+                    support !~ /\bn\b/ && support =~ /\bx\b/ && prefix == actual_prefix
+                  end
+                end
+      m.update(browser => version) if version
+      m
+    end
+  end
+
+  # How many users would be omitted if support for the given browser starts
+  # with the given version.
+  def omitted_usage(browser, min_version)
+    assert_valid_browser browser
+    usage = 0
+    versions(browser).each do |version|
+      return usage if version == min_version
+      usage += usage(browser, version)
+    end
+    raise ArgumentError, "#{min_version} is not a version for #{browser}"
+  end
+
+  # returns the list of browsers that use the given prefix
+  def browsers_with_prefix(prefix)
+    assert_valid_prefix prefix
+    prefix = "-" + prefix unless prefix.start_with?("-")
+    browsers.select {|b| all_prefixes(b).include?(prefix) }
+  end
+
+  SPEC_VERSION_MATCHERS = Hash.new do |h, k|
+    h[k] = /##{k}\b/
+  end
+
+  CAPABILITY_MATCHERS = {
+    :full_support => lambda {|support, capability| !support ^ (capability =~ /\by\b/) },
+    :partial_support => lambda {|support, capability| !support ^ (capability =~ /\ba\b/) },
+    :prefixed => lambda {|support, capability| !support ^ (capability =~ /\bx\b/) },
+    :spec_versions => lambda {|versions, capability| versions.any? {|v| capability =~ SPEC_VERSION_MATCHERS[v] } }
+  }
+
+  # Return whether the capability matcher the options specified.
+  # For each capability option in the options the capability will need to match it.
+  def capability_matches(support, capability_options_list)
+    capability_options_list.any? do |capability_options|
+      capability_options.all? {|c, v| CAPABILITY_MATCHERS[c].call(v, support)}
+    end
+  end
+
+  # returns the percentage of users (0-100) that would be affected if the prefix
+  # was not used with the given capability.
+  def prefixed_usage(prefix, capability, capability_options_list)
+    assert_valid_prefix prefix
+    assert_valid_capability capability
+    usage = 0
+    browsers_with_prefix(prefix).each do |browser|
+      versions(browser).each do |version|
+        next unless prefix == prefix(browser, version)
+        support = browser_support(browser, version, capability)
+        if capability_matches(support, capability_options_list) and support =~ /\bx\b/
+          usage += usage(browser, version)
+        end
+      end
+    end
+    usage
+  end
+
+  # Returns whether the given minimum version of a browser
+  # requires the use of a prefix for the stated capability.
+  def requires_prefix(browser, min_version, capability, capability_options_list)
+    assert_valid_browser browser
+    assert_valid_capability capability
+    found_version = false
+    versions(browser).each do |version|
+      found_version ||= version == min_version
+      next unless found_version
+      support = browser_support(browser, version, capability)
+      if capability_matches(support, capability_options_list) and support =~ /\bx\b/
+        return prefix(browser, version)
+      end
+    end
+    raise ArgumentError, "#{min_version} is not a version for #{browser}" unless found_version
+    nil
+  end
+
+  # Returns the versions of a browser. If the min_usage parameter is provided,
+  # only those versions having met the threshold of user percentage.
+  #
+  # @param min_usage a decimal number betwee 0 and 100
+  def versions(browser, min_usage = 0)
+    assert_valid_browser browser
+    versions = browser_data(browser)["versions"].compact
+    return versions if min_usage == 0
+    versions.select {|v| browser_data(browser)["usage_global"][v] > min_usage }
+  end
+
+  # The list of capabilities tracked by caniuse.
+  def capabilities
+    @capabilities ||= @data["data"].keys.select do |cap|
+      cats = @data["data"][cap]["categories"]
+      cats.any?{|cat| cat =~ /CSS/ }
+    end.sort
+  end
+
+  # the usage % for a given browser version.
+  def usage(browser, version)
+    browser_data(browser)["usage_global"][version]
+  end
+
+
+  def inspect
+    "Compass::CanIUse(#{browsers.join(", ")})"
+  end
+
+  # the browser data assocated with a given capability
+  def capability_data(capability)
+    @data["data"][capability]
+  end
+
+  def browser_support(browser, version, capability)
+    capability_data(capability)["stats"][CAN_I_USE_NAMES[browser]][version]
+  end
+
+  # the metadata assocated with a given browser
+  def browser_data(browser)
+    @data["agents"][CAN_I_USE_NAMES[browser]]
+  end
+
+  # efficiently checks if a prefix is valid
+  def assert_valid_prefix(prefix)
+    @known_prefixes ||= Set.new(prefixes(browsers))
+    unless @known_prefixes.include?(prefix)
+      raise ArgumentError, "#{prefix} is not known browser prefix."
+    end
+  end
+
+  # efficiently checks if a browser is valid
+  def assert_valid_browser(browser)
+    @known_browsers ||= Set.new(browsers)
+    @known_browsers.include?(browser)
+    unless @known_browsers.include?(browser)
+      raise ArgumentError, "#{browser} is not known browser."
+    end
+  end
+
+  # efficiently checks if a capability is valid
+  def assert_valid_capability(capability)
+    @known_capabilities ||= Set.new(capabilities)
+    unless @known_capabilities.include?(capability)
+      raise ArgumentError, "#{capability} is not known browser capability."
+    end
+    nil
+  end
+
+  def assert_valid_version(browser, *versions)
+    versions.each do |v|
+      unless versions(browser).include?(v)
+        raise ArgumentError, "#{v} is not known version for #{browser}."
+      end
+    end
+  end
+end

data/lib/compass/configuration/adapters.rb

@@ -4,7 +4,13 @@ module Compass
     # adapt to various consumers of configuration data
     module Adapters
       def to_compiler_arguments(additional_options = {})
-        [project_path, sass_path, css_path, to_sass_engine_options.merge(additional_options)]
+        engine_opts = to_sass_engine_options.merge(additional_options)
+        # we have to pass the quiet option in the nested :sass hash to disambiguate it from the compass compiler's own quiet option.
+        if engine_opts.has_key?(:quiet)
+          engine_opts[:sass] ||= {}
+          engine_opts[:sass][:quiet] = engine_opts.delete(:quiet)
+        end
+        [project_path, sass_path, css_path, engine_opts]
       end
 
       def to_sass_plugin_options

data/lib/compass/sass_extensions/functions.rb

@@ -1,4 +1,9 @@
 module Compass::SassExtensions::Functions
+  module SassDeclarationHelper
+    def register_sass_function(*args)
+      Sass::Script::Functions.declare(*args)
+    end
+  end
 end
 
 %w(

data/lib/compass/sass_extensions/functions/constants.rb

@@ -1,6 +1,6 @@
 module Compass::SassExtensions::Functions::Constants
-  if defined?(Sass::Script::List)
-    POSITIONS = /top|bottom|left|right|center/
+  POSITIONS = /top|bottom|left|right|center/
+  if defined?(Sass::Script::Value::List)
     def is_position(position)
       Sass::Script::Bool.new(position.is_a?(Sass::Script::String) && !!(position.value =~ POSITIONS))
     end

data/lib/compass/sass_extensions/functions/cross_browser_support.rb

@@ -28,12 +28,13 @@ module Compass::SassExtensions::Functions::CrossBrowserSupport
 
   # Check if any of the arguments passed require a vendor prefix.
   def prefixed(prefix, *args)
+    assert_type prefix, :String
     aspect = prefix.value.sub(/^-/,"")
     needed = args.any?{|a| a.respond_to?(:supports?) && a.supports?(aspect)}
     Sass::Script::Bool.new(needed)
   end
 
-  %w(webkit moz o ms svg pie css2).each do |prefix|
+  %w(webkit moz o ms svg css2).each do |prefix|
     class_eval <<-RUBY, __FILE__, __LINE__ + 1
       # Syntactic sugar to apply the given prefix
       # -moz($arg) is the same as calling prefix(-moz, $arg)
@@ -44,6 +45,7 @@ module Compass::SassExtensions::Functions::CrossBrowserSupport
   end
 
   def prefix(prefix, *objects)
+    assert_type prefix, :String if prefix.is_a?(Sass::Script::Value::Base)
     prefix = prefix.value if prefix.is_a?(Sass::Script::String)
     prefix = prefix[1..-1] if prefix[0] == ?-
     if objects.size > 1
@@ -67,4 +69,177 @@ module Compass::SassExtensions::Functions::CrossBrowserSupport
     CSS2FallbackValue.new(value, css2_value)
   end
 
+  # The known browsers.
+  #
+  # If prefix is given, limits the returned browsers to those using the specified prefix.
+  def browsers(prefix = nil)
+    browsers = if prefix
+                 assert_type prefix, :String
+                 Compass::CanIUse.instance.browsers_with_prefix(prefix.value)
+               else
+                 Compass::CanIUse.instance.browsers
+               end
+    list(browsers.map{|b| identifier(b)}, :comma)
+  end
+  Sass::Script::Functions.declare(:browsers, [])
+  Sass::Script::Functions.declare(:browsers, [:prefix])
+
+  # The known capabilities of browsers.
+  def browser_capabilities
+    list(Compass::CanIUse.instance.capabilities.map{|c| identifier(c)}, :comma)
+  end
+  Sass::Script::Functions.declare(:browser_capabilities, [])
+
+  # The versions for the given browser.
+  def browser_versions(browser)
+    assert_type browser, :String
+    list(Compass::CanIUse.instance.versions(browser.value).map{|v| quoted_string(v)}, :comma)
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_versions, [:browser])
+
+  # whether the browser uses a prefix for the given capability at the version
+  # specified or a later version. Returns the prefix it requires, or null.
+  def browser_requires_prefix(browser, version, capability, capability_options)
+    assert_type browser, :String
+    assert_type version, :String
+    assert_type capability, :String
+    p = Compass::CanIUse.instance.requires_prefix(browser.value,
+                                                  version.value,
+                                                  capability.value,
+                                                  unbox_capability_options_list(capability_options))
+    p ? identifier(p) : null()
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_requires_prefix, [:browser, :version, :capability])
+
+  # the prefix for the given browser.
+  def browser_prefix(browser, version = nil)
+    assert_type browser, :String
+    identifier(Compass::CanIUse.instance.prefix(browser.value))
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_prefix, [:browser])
+  Sass::Script::Functions.declare(:browser_prefix, [:browser, :version])
+
+  # The prefixes used by the given browsers.
+  def browser_prefixes(browsers)
+    browsers = list(browsers, :comma) if browsers.is_a?(Sass::Script::Value::String)
+    assert_type browsers, :List
+    browser_strings = browsers.value.map {|b| assert_type(b, :String); b.value }
+    prefix_strings = Compass::CanIUse.instance.prefixes(browser_strings)
+    list(prefix_strings.map {|p| identifier(p)}, :comma)
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_prefixes, [:browsers])
+
+  # The percent of users that are omitted by setting the min_version of browser
+  # as specified.
+  def omitted_usage(browser, min_version)
+    assert_type browser, :String
+    assert_type min_version, :String
+    number(Compass::CanIUse.instance.omitted_usage(browser.value, min_version.value))
+  end
+  Sass::Script::Functions.declare(:omitted_usage, [:browser, :min_version])
+
+  # The percent of users relying on a particular prefix
+  def prefix_usage(prefix, capability, capability_options)
+    assert_type prefix, :String
+    assert_type capability, :String
+    number(Compass::CanIUse.instance.prefixed_usage(prefix.value,
+                                                    capability.value,
+                                                    unbox_capability_options_list(capability_options)))
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:prefix_usage, [:prefix, :capability])
+
+  # Compares two browser versions. Returning:
+  #
+  # * 0 if they are the same
+  # * <0 if the first version is less than the second
+  # * >0 if the first version is more than the second
+  def compare_browser_versions(browser, version1, version2)
+    assert_type browser, :String
+    assert_type version1, :String
+    assert_type version2, :String
+    index1 = index2 = nil
+    Compass::CanIUse.instance.versions(browser.value).each_with_index do |v, i|
+      index1 = i if v == version1.value
+      index2 = i if v == version2.value
+      break if index1 && index2
+    end
+    unless index1
+      raise Sass::SyntaxError.new("#{version1} is not a version for #{browser}")
+    end
+    unless index2
+      raise Sass::SyntaxError.new("#{version2} is not a version for #{browser}")
+    end
+    number(index1 <=> index2)
+  end
+  Sass::Script::Functions.declare(:compare_browser_versions, [:browser, :version1, :version2])
+
+  # Returns a map of browsers to the first version the capability became available
+  # without a prefix.
+  #
+  # If a prefix is provided, only those browsers using that prefix will be returned
+  # and the minimum version will be when it first became available as a prefix or
+  # without a prefix.
+  #
+  # If a browser does not have the capability, it will not included in the map.
+  def browser_minimums(capability, prefix = null())
+    assert_type capability, :String
+    assert_type(prefix, :String) unless prefix == null()
+    mins = Compass::CanIUse.instance.browser_minimums(capability.value, prefix.value)
+    Sass::Script::Value::Map.new(mins.inject({}) do |m, (h, k)|
+      m[identifier(h)] = quoted_string(k)
+      m
+    end)
+  end
+  Sass::Script::Functions.declare(:browser_minimums, [:capability])
+  Sass::Script::Functions.declare(:browser_minimums, [:capability, :prefix])
+
+  private
+
+  def unbox_capability_options_list(capability_options_list)
+    if capability_options_list.is_a?(Sass::Script::Value::Map)
+      [unbox_capability_options(capability_options_list)]
+    elsif capability_options_list.is_a?(Sass::Script::Value::List)
+      capability_options_list.to_a.map{|opts| unbox_capability_options(opts) }
+    else
+      assert_type capability_options_list, :List
+    end
+  end
+
+  CAPABILITY_OPTION_KEYS = {
+    "full-support" => :full_support,
+    "partial-support" => :partial_support,
+    "prefixed" => :prefixed,
+    "spec-versions" => :spec_versions,
+  }
+
+  CAPABILITY_OPTION_UNBOXER = {
+    :full_support => lambda {|v| v.to_bool },
+    :partial_support => lambda {|v| v.to_bool },
+    :prefixed => lambda {|v| v.to_bool },
+    :spec_versions => lambda {|versions| versions.to_a.map {|v| v.value } }
+  }
+
+  def unbox_capability_options(capability_options)
+    assert_type capability_options, :Map
+    result = {}
+    capability_options.value.each do |k, v|
+      assert_type k, :String
+      key = CAPABILITY_OPTION_KEYS[k.value]
+      unless key
+        raise Sass::SyntaxError, "#{k} is not valid capability option"
+      end
+      result[key] = CAPABILITY_OPTION_UNBOXER[key].call(v)
+    end
+    result
+  end
 end