compass-core-sass37 1.1.0

data/lib/compass/configuration.rb

@@ -0,0 +1,175 @@
+module Compass
+  module Configuration
+
+    class << self
+      def attributes_for_directory(dir_name, http_dir_name = dir_name)
+        [
+          "#{dir_name}_dir",
+          "#{dir_name}_path",
+          ("http_#{http_dir_name}_dir" if http_dir_name),
+          ("http_#{http_dir_name}_path" if http_dir_name)
+        ].compact.map{|a| a.to_sym}
+      end
+
+      # Registers a new configuration property.
+      # Extensions can use this to add new configuration options to compass.
+      #
+      # @param [Symbol] name The name of the property.
+      # @param [String] comment A comment for the property.
+      # @param [Proc] default A method to calculate the default value for the property.
+      #                       The proc is executed in the context of the project's configuration data.
+      def add_configuration_property(name, comment = nil, &default)
+        ATTRIBUTES << name
+        if comment.is_a?(String)
+          unless comment[0..0] == "#"
+            comment = "# #{comment}"
+          end
+          unless comment[-1..-1] == "\n"
+            comment = comment + "\n"
+          end
+          Data.class_eval <<-COMMENT
+          def comment_for_#{name}
+          #{comment.inspect}
+          end
+          COMMENT
+        end
+        Data.send(:define_method, :"default_#{name}", &default) if default
+        Data.inherited_accessor(name)
+        if name.to_s =~ /dir|path/
+          Data.strip_trailing_separator(name)
+        end
+      end
+
+      # For testing purposes
+      def remove_configuration_property(name)
+        ATTRIBUTES.delete(name)
+      end
+
+    end
+
+    ATTRIBUTES = [
+      # What kind of project?
+      :project_type,
+      # Where is the project?
+      :project_path,
+      :http_path,
+      # Where are the various bits of the project
+      attributes_for_directory(:css, :stylesheets),
+      attributes_for_directory(:sass, nil),
+      attributes_for_directory(:images),
+      attributes_for_directory(:generated_images),
+      attributes_for_directory(:javascripts),
+      attributes_for_directory(:fonts),
+      attributes_for_directory(:extensions, nil),
+      # Compilation options
+      :output_style,
+      :sourcemap,
+      :environment,
+      :relative_assets,
+      :sass_options,
+      attributes_for_directory(:cache, nil),
+      :cache,
+      # Helper configuration
+      :asset_host,
+      :asset_cache_buster,
+      :line_comments,
+      :color_output,
+      :preferred_syntax,
+      :disable_warnings,
+      :sprite_engine,
+      :chunky_png_options
+    ].flatten
+
+    ARRAY_ATTRIBUTES = [
+      :additional_import_paths,
+      :sprite_load_path,
+      :required_libraries,
+      :loaded_frameworks,
+      :framework_path
+    ]
+
+    ARRAY_ATTRIBUTE_OPTIONS = {
+      :sprite_load_path => { :clobbers => true }
+    }
+
+    RUNTIME_READONLY_ATTRIBUTES = [
+      :cache,
+      attributes_for_directory(:cache, nil),
+      :chunky_png_options,
+      :color_output,
+      attributes_for_directory(:css, :stylesheets),
+      :environment,
+      attributes_for_directory(:extensions, nil),
+      :framework_path,
+      attributes_for_directory(:javascripts),
+      :line_comments,
+      :loaded_frameworks,
+      :output_style,
+      :preferred_syntax,
+      :project_path,
+      :project_type,
+      :required_libraries,
+      attributes_for_directory(:sass, nil),
+      :sass_options,
+      :sourcemap,
+      :sprite_engine,
+    ].flatten
+
+  end
+
+  class << self
+    # The Compass configuration singleton.
+    def configuration
+      @configuration ||= default_configuration
+      if block_given?
+        yield @configuration
+      end
+      @configuration
+    end
+
+    def default_configuration
+      Compass::Configuration::Data.new('defaults').extend(Compass::Configuration::Defaults)
+    end
+
+    def add_configuration(data, filename = nil)
+      return if data.nil?
+
+
+      unless data.is_a?(Compass::Configuration::Data)
+        # XXX HAX Need to properly factor this apart from the main compass project
+        if respond_to?(:configuration_for)
+          data = configuration_for(data, filename)
+        else
+          raise ArgumentError, "Invalid argument: #{data.inspect}"
+        end
+      end
+
+      data.inherit_from!(configuration) if configuration
+      data.on_top!
+      @configuration = data
+    end
+
+    def reset_configuration!
+      @configuration = nil
+    end
+
+    # Returns a full path to the relative path to the project directory
+    def projectize(path, project_path = nil)
+      project_path ||= configuration.project_path
+      File.join(project_path, *path.split('/'))
+    end
+
+    def deprojectize(path, project_path = nil)
+      project_path ||= configuration.project_path
+      if path[0..(project_path.size - 1)] == project_path
+        path[(project_path.size + 1)..-1]
+      else
+        path
+      end
+    end
+  end
+end
+
+%w(defaults inheritance paths data watch adapters).each do |lib|
+  require "compass/configuration/#{lib}"
+end

data/lib/compass/core/caniuse.rb

@@ -0,0 +1,314 @@
+require 'multi_json'
+require 'singleton'
+class Compass::Core::CanIUse
+  include Singleton
+
+  DATA_FILE_NAME = File.join(Compass::Core.base_directory, "data", "caniuse.json")
+  DATA_FEATURE_FILES = Dir.glob(File.join(Compass::Core.base_directory, "data", "caniuse_extras", "**", "*.json"))
+
+  def initialize
+    @data = MultiJson.load(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] = MultiJson.load(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)
+    version = caniuse_version(browser, version)
+    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_ranges(capability, prefix = nil, include_unprefixed_versions = true)
+    assert_valid_capability capability
+    browsers = prefix.nil? ? browsers() : browsers_with_prefix(prefix)
+    browsers.inject({}) do |m, browser|
+      browser_versions = versions(browser)
+      min_version = find_first_prefixed_version(browser, browser_versions, capability, prefix)
+      if min_version
+        max_version = if include_unprefixed_versions
+                        browser_versions.last
+                      else
+                        find_first_prefixed_version(browser, browser_versions.reverse, capability, prefix)
+                      end
+        m.update(browser => [min_version, max_version])
+      end
+      m
+    end
+  end
+
+  def find_first_prefixed_version(browser, versions, capability, prefix)
+    versions.find do |version|
+      support = browser_support(browser, version, capability)
+      if prefix.nil?
+        support !~ /\b(n|p)\b/ && support !~ /\bx\b/
+      else
+        actual_prefix = prefix(browser, version)
+        support !~ /\b(n|p)\b/ && support =~ /\bx\b/ && prefix == actual_prefix
+      end
+    end
+  end
+
+  # @overload omitted_usage(browser, min_supported_version)
+  #   How many users would be omitted if support for the given browser starts
+  #   with the given version.
+  #
+  # @overload omitted_usage(browser, min_unsupported_version, max_unsupported_version)
+  #   How many users would be omitted if the browsers with version
+  def omitted_usage(browser, min_version, max_version = nil)
+    versions = versions(browser)
+    min_version = caniuse_version(browser, min_version)
+    max_version = caniuse_version(browser, max_version)
+    if max_version.nil?
+      assert_valid_version browser, min_version
+    else
+      assert_valid_version browser, min_version, max_version
+    end
+    usage = 0
+    in_range = max_version.nil?
+    versions.each do |version|
+      break if max_version.nil? && version == min_version
+      in_range = true if (!max_version.nil? && version == min_version)
+      usage += usage(browser, version) if in_range
+      break if !max_version.nil? && version == max_version
+    end
+    return usage
+  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
+
+  def next_version(browser, version)
+    version = caniuse_version(browser, version)
+    versions = versions(browser)
+    index = versions.index(version)
+    index < versions.length - 1 ? versions[index + 1] : nil
+  end
+
+  def previous_version(browser, version)
+    version = caniuse_version(browser, version)
+    versions = versions(browser)
+    index = versions.index(version)
+    index > 0 ? versions[index - 1] : nil
+  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)
+    min_version = caniuse_version(browser, min_version)
+    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
+
+  # These are versions that users might reasonably type
+  # mapped to the caniuse version.
+  ALTERNATE_VERSIONS = {
+    "android" => {
+      "4.2" => "4.2-4.3",
+      "4.3" => "4.2-4.3"
+    },
+    "opera" => {
+      "9.5" => "9.5-9.6",
+      "9.6" => "9.5-9.6",
+      "10.0" => "10.0-10.1",
+      "10.1" => "10.0-10.1",
+    },
+    "opera-mobile" => {
+      "14" => "0"
+    }
+  }
+
+  # 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
+
+  # returns a valid version given the version provided by the user
+  # This is used to maintain API compatibility when caniuse removes
+  # a version from their data (which seems to be replaced with a semantic equivalent).
+  def caniuse_version(browser, version)
+    return unless version
+    ALTERNATE_VERSIONS[browser] && ALTERNATE_VERSIONS[browser][version] || version
+  end
+
+  def inspect
+    "#{self.class.name}(#{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)
+    version = caniuse_version(browser, version)
+    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)
+    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/core/generated_version.rb

@@ -0,0 +1,6 @@
+module Compass
+  module Core
+    # This file intentionally does nothing.
+    # The build process will generate a VERSION constant here.
+  end
+end

data/lib/compass/core/sass_extensions/functions/colors.rb

@@ -0,0 +1,67 @@
+module Compass::Core::SassExtensions::Functions::Colors
+
+  # a genericized version of lighten/darken so that negative values can be used.
+  def adjust_lightness(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:lightness => Sass::Util.restrict(color.lightness + amount.value, 0..100))
+  end
+
+  # Scales a color's lightness by some percentage.
+  # If the amount is negative, the color is scaled darker, if positive, it is scaled lighter.
+  # This will never return a pure light or dark color unless the amount is 100%.
+  def scale_lightness(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:lightness => scale_color_value(color.lightness, amount.value))
+  end
+
+  # a genericized version of saturation/desaturate so that negative values can be used.
+  def adjust_saturation(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:saturation => Sass::Util.restrict(color.saturation + amount.value, 0..100))
+  end
+
+  # Scales a color's saturation by some percentage.
+  # If the amount is negative, the color is desaturated, if positive, it is saturated.
+  # This will never return a pure saturated or desaturated color unless the amount is 100%.
+  def scale_saturation(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:saturation => scale_color_value(color.saturation, amount.value))
+  end
+
+  def shade(color, percentage)
+    assert_type color, :Color
+    assert_type percentage, :Number
+    black = rgb_color(0, 0, 0)
+    mix(black, color, percentage)
+  end
+
+  def tint(color, percentage)
+    assert_type color, :Color
+    assert_type percentage, :Number
+    white = rgb_color(255, 255, 255)
+    mix(white, color, percentage)
+  end
+
+  # returns an IE hex string for a color with an alpha channel
+  # suitable for passing to IE filters.
+  def ie_hex_str(color)
+    assert_type color, :Color
+    alpha = (color.alpha * 255).round
+    alphastr = alpha.to_s(16).rjust(2, '0')
+    identifier("##{alphastr}#{color.send(:hex_str)[1..-1]}".upcase)
+  end
+  
+  private
+  def scale_color_value(value, amount)
+    if amount > 0
+      value += (100 - value) * (amount / 100.0)
+    elsif amount < 0
+      value += value * amount / 100.0
+    end
+    value
+  end
+end