compass-core 1.0.0.alpha.13

data/lib/compass/configuration/paths.rb

@@ -0,0 +1,19 @@
+module Compass::Configuration::Paths
+
+  TRAILING_SEPARATOR = %r{.(/|#{Regexp.escape(File::SEPARATOR)})$}
+
+  def strip_trailing_separator(*attributes)
+    attributes.each do |attr|
+      alias_method "#{attr}_with_trailing_separator".to_sym, attr
+      class_eval %Q{
+        def #{attr}                                # def css_dir
+          path = #{attr}_with_trailing_separator   #   path = css_dir_with_trailing_separator
+          if path.to_s =~ TRAILING_SEPARATOR       #   if path =~ TRAILING_SEPARATOR
+            path = path[0..-($1.length+1)]         #     path = path[0..-($1.length+1)]
+          end                                      #   end
+          path                                     #   path
+        end                                        # end
+      }
+    end
+  end
+end

data/lib/compass/core.rb

@@ -0,0 +1,64 @@
+require "compass/core/version"
+
+module Compass
+  module Core
+    class << self
+      attr_accessor :module_deprecation_warning_issued
+    end
+    def base_directory(*subdirs)
+      File.expand_path(File.join(File.dirname(__FILE__), '..', "..", *subdirs))
+    end
+    def lib_directory(*subdirs)
+      File.expand_path(File.join(File.dirname(__FILE__), "..", *subdirs))
+    end
+
+    module_function :base_directory, :lib_directory
+  end
+
+  module HasDeprecatedConstantsFromCore
+    def self.extended(base)
+      new_base = base.name.sub(/^Compass/,"Compass::Core")
+      base.class_eval <<-RUBY
+        def self.const_missing(const_name)
+          puts "cannot find \#{const_name}"
+          if #{new_base}.const_defined?(const_name)
+            unless Compass::Core.module_deprecation_warning_issued
+              Compass::Core.module_deprecation_warning_issued = true
+              Compass::Util.compass_warn(
+                "DEPRECATED: #{base.name}::\#{const_name} has been moved to " +
+                "#{new_base}::\#{const_name}.\\n" +
+                "Please update \#{caller[0]}")
+            end
+            #{new_base}.const_get(const_name)
+          end
+        end
+      RUBY
+    end
+  end
+
+  extend HasDeprecatedConstantsFromCore
+
+  module SassExtensions
+    extend HasDeprecatedConstantsFromCore
+
+    module Functions
+      extend HasDeprecatedConstantsFromCore
+    end
+  end
+end
+
+require "sass"
+require "sass/plugin"
+require "compass/core/caniuse"
+require 'compass/core/sass_extensions'
+require 'compass/error'
+require 'compass/browser_support'
+require 'compass/configuration'
+
+if defined?(Compass::Frameworks)
+  Compass::Frameworks.register(
+    "compass",
+    :stylesheets_directory => Compass::Core.base_directory("stylesheets"),
+    :templates_directory => Compass::Core.base_directory("templates")
+  )
+end

data/lib/compass/core/caniuse.rb

@@ -0,0 +1,282 @@
+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)
+    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 !~ /\bn\b/ && support !~ /\bx\b/
+      else
+        actual_prefix = prefix(browser, version)
+        support !~ /\bn\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)
+    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)
+    versions = versions(browser)
+    index = versions.index(version)
+    index < versions.length - 1 ? versions[index + 1] : nil
+  end
+
+  def previous_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)
+    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
+    "#{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)
+    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/sass_extensions.rb

@@ -0,0 +1,10 @@
+require 'sass'
+unless Sass::Script::Functions.methods.grep(/\Adeclare\Z/).any?
+  raise LoadError, "It looks like you've got an incompatible version of Sass. This often happens when you have an old haml gem installed. Please upgrade Haml to v3.1 or above."
+end
+
+module Compass::Core::SassExtensions
+end
+
+require 'compass/core/sass_extensions/functions'
+require 'compass/core/sass_extensions/monkey_patches'

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

@@ -0,0 +1,39 @@
+module Compass::Core::SassExtensions::Functions
+  module SassDeclarationHelper
+    def declare(*args)
+      Sass::Script::Functions.declare(*args)
+    end
+  end
+end
+
+%w(
+  selectors    enumerate  urls      display
+  inline_image image_size constants gradient_support
+  font_files   lists      colors    math
+  env          cross_browser_support configuration
+).each do |func|
+  require "compass/core/sass_extensions/functions/#{func}"
+end
+
+module Sass::Script::Functions
+  include Compass::Core::SassExtensions::Functions::Configuration
+  include Compass::Core::SassExtensions::Functions::Selectors
+  include Compass::Core::SassExtensions::Functions::Enumerate
+  include Compass::Core::SassExtensions::Functions::Urls
+  include Compass::Core::SassExtensions::Functions::Display
+  include Compass::Core::SassExtensions::Functions::InlineImage
+  include Compass::Core::SassExtensions::Functions::ImageSize
+  include Compass::Core::SassExtensions::Functions::GradientSupport::Functions
+  include Compass::Core::SassExtensions::Functions::FontFiles
+  include Compass::Core::SassExtensions::Functions::Constants
+  include Compass::Core::SassExtensions::Functions::Lists
+  include Compass::Core::SassExtensions::Functions::Colors
+  include Compass::Core::SassExtensions::Functions::Math
+  include Compass::Core::SassExtensions::Functions::CrossBrowserSupport
+  include Compass::Core::SassExtensions::Functions::Env
+end
+
+# Wierd that this has to be re-included to pick up sub-modules. Ruby bug?
+class Sass::Script::Functions::EvaluationContext
+  include Sass::Script::Functions
+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 = Sass::Script::Color.new([0, 0, 0])
+    mix(black, color, percentage)
+  end
+
+  def tint(color, percentage)
+    assert_type color, :Color
+    assert_type percentage, :Number
+    white = Sass::Script::Color.new([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')
+    Sass::Script::String.new("##{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