compass-core-sass37 1.1.0

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

@@ -0,0 +1,173 @@
+require 'pathname'
+module Compass::Core::SassExtensions::Functions::Configuration
+  extend Compass::Core::SassExtensions::Functions::SassDeclarationHelper
+
+  # Users who need to support windows and unix paths in their configuration
+  # should construct them with this helper function.
+  def join_file_segments(*segments)
+    quoted_string(File.join(*segments.map{|s| assert_type s, :String; s.value}))
+  end
+  declare :absolute_path, [], :var_args => true
+
+  # Returns an absolute path for the path relative to the sass file it was called from.
+  def absolute_path(relative_path)
+    quoted_string(File.expand_path(File.join(File.dirname(options[:filename]), relative_path.value)))
+  end
+  declare :absolute_path, [:relative_path]
+
+  # split a file into directory, basename, and extension
+  def split_filename(path)
+    pathname = Pathname.new(path.value)
+    list(quoted_string(pathname.dirname.to_s),
+         quoted_string(pathname.basename(pathname.extname).to_s),
+         quoted_string(pathname.extname.to_s),
+         :space)
+  end
+  declare :split_filename, [:path]
+
+  # Returns true if the compass compiler is compiling this stylesheet.
+  def using_compass_compiler
+    bool(options[:compass] && options[:compass][:compiler_in_use])
+  end
+  declare :using_compass_compiler, []
+
+  def reset_configuration()
+    Compass.reset_configuration!
+    null()
+  end
+  declare :reset_configuration, []
+
+  def add_sass_configuration(project_path)
+    css_location = template_location = nil
+    if options[:template_location] && options[:template_location].is_a?(Array)
+      css_location = File.expand_path(options[:template_location].first.last)
+      template_location = File.expand_path(options[:template_location].first.first)
+    else
+      css_location = File.expand_path(options[:css_location]) if options[:css_location]
+      template_location = File.expand_path(options[:template_location]) if options[:template_location]
+    end
+    original_filename = File.expand_path(options[:original_filename]) if options[:original_filename]
+    project_path = if project_path.value.nil?
+                     if css_location && template_location
+                       common_parent_directory(css_location, template_location)
+                     end
+                   else
+                     project_path.value
+                   end
+    config = {
+      :project_path => project_path,
+      :cache => options[:cache],
+      :additional_import_paths => options[:load_paths],
+      :line_comments => options[:line_comments]
+    }
+    unless options[:quiet].nil?
+      config.update(:disable_warnings => options[:quiet])
+    end
+    if project_path && css_location && (css_dir = relative_path_from(css_location, project_path))
+      config.update(:css_dir => css_dir)
+    elsif css_location
+      config.update(:css_path => css_location)
+    end
+    if project_path && template_location && (sass_dir = relative_path_from(template_location, project_path))
+      config.update(:sass_dir => sass_dir)
+    elsif template_location
+      config.update(:css_path => template_location)
+    end
+    config_name = "Sass Defaults: #{project_path ? relative_path_from(original_filename, project_path) : original_filename}"
+    Compass.add_configuration(Compass::Configuration::Data.new(config_name, config))
+    update_sass_options!
+    null
+  rescue => e
+    puts e.backtrace.join("\n")
+    raise
+  end
+  declare :add_sass_configuration, [:project_path]
+
+  OPTION_TRANSFORMER = Hash.new() {|h, k| proc {|v, ctx| v.value } }
+  OPTION_TRANSFORMER[:asset_cache_buster] = proc do |v, ctx|
+    proc do |url, file|
+      if ctx.environment.function(v.value) || Sass::Script::Functions.callable?(v.value.tr('-', '_'))
+        # Sass 3.5+: Use get_function() instead of passing string to call()
+        fn = ctx.get_function(v)
+        result = ctx.call(fn, ctx.quoted_string(url),
+                             file.nil? ? ctx.null() : ctx.quoted_string(file.path))
+        case result
+        when Sass::Script::Value::String, Sass::Script::Value::Null
+          result.value
+        else
+          ctx.assert_type(result, :Map) 
+          result.value.keys.inject({}) do |r, k|
+            ctx.assert_type k, :String
+            ctx.assert_type(result.value[k], :String) unless result.value[k].value.nil?
+            if k.value == "path" || k.value == "query"
+              r[k.value.to_sym] = result.value[k].value
+            end
+            r
+          end
+        end
+      else
+        raise ArgumentError, "#{v.value} is not a function."
+      end
+    end
+  end
+  OPTION_TRANSFORMER[:asset_host] = proc do |v, ctx|
+    proc do |file|
+      if ctx.environment.function(v.value) || Sass::Script::Functions.callable?(v.value.tr('-', '_'))
+        # Sass 3.5+: Use get_function() instead of passing string to call()
+        fn = ctx.get_function(v)
+        result = ctx.call(fn, ctx.quoted_string(file))
+        case result
+        when Sass::Script::Value::String, Sass::Script::Value::Null
+          result.value
+        else
+          ctx.assert_type(result, :String)
+        end
+      else
+        raise ArgumentError, "#{v.value} is not a function."
+      end
+    end
+  end
+
+  def add_configuration(options)
+    attributes = {}
+    options.value.keys.each do |key|
+      underscored = key.value.to_s.tr("-", "_")
+      unless runtime_writable_attributes.find{|a| a.to_s == underscored}
+        raise ArgumentError, "#{key} is not a valid configuration option."
+      end
+      underscored = underscored.to_sym
+      attributes[underscored] = OPTION_TRANSFORMER[underscored].call(options.value[key], self)
+    end
+    name = "#{options.source_range.file}:#{options.source_range.start_pos.line}"
+    Compass.add_configuration(Compass::Configuration::Data.new(name, attributes))
+    update_sass_options!
+    null
+  end
+  declare :add_configuration, [:options]
+
+  private
+
+  def runtime_writable_attributes
+    Compass::Configuration::ATTRIBUTES - Compass::Configuration::RUNTIME_READONLY_ATTRIBUTES
+  end
+
+  def common_parent_directory(directory1, directory2)
+    relative = Pathname.new(directory1).relative_path_from(Pathname.new(directory2))
+    File.expand_path(directory2, relative.to_s.scan("..#{File::SEPARATOR}").join)
+  end
+
+  def relative_path_from(directory1, directory2)
+    Pathname.new(directory1).relative_path_from(Pathname.new(directory2)).to_s
+  end
+
+  def update_sass_options!
+    Compass.configuration.additional_import_paths.each do |lp|
+      options[:load_paths] << lp unless options[:load_paths].include?(lp)
+    end
+    if Compass.configuration.disable_warnings
+      Sass.logger.log_level = :error
+    else
+      Sass.logger.log_level = :warn
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Compass::Core::SassExtensions::Functions::Constants
+  POSITIONS = /top|bottom|left|right|center/
+  def is_position(position)
+    bool(position.is_a?(Sass::Script::Value::String) && !!(position.value =~ POSITIONS))
+  end
+  def is_position_list(position_list)
+    bool(position_list.is_a?(Sass::Script::Value::List) && position_list.value.all?{|p| is_position(p).to_bool})
+  end
+  # returns the opposite position of a side or corner.
+  def opposite_position(position)
+    position = unless position.is_a?(Sass::Script::Value::List)
+      list(position, :space)
+    else
+      list(position.value.dup, position.separator)
+    end
+    position = list(position.value.map do |pos|
+      if pos.is_a? Sass::Script::Value::String
+        opposite = case pos.value
+        when "top" then "bottom"
+        when "bottom" then "top"
+        when "left" then "right"
+        when "right" then "left"
+        when "center" then "center"
+        else
+          Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+          pos.value
+        end
+        identifier(opposite)
+      elsif pos.is_a? Sass::Script::Value::Number
+        if pos.numerator_units == ["%"] && pos.denominator_units == []
+          number(100-pos.value, "%")
+        else
+          Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+          pos
+        end
+      else
+        Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+        pos
+      end
+    end, position.separator)
+    if position.value.size == 1
+      position.value.first
+    else
+      position
+    end
+  end
+
+  def is_url(string)
+    if string.is_a?(Sass::Script::Value::String)
+      is_url = !!(string.value =~ /^url\(.*\)$/)
+      bool(is_url)
+    else
+      bool(false)
+    end
+  end
+end

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

@@ -0,0 +1,270 @@
+module Compass::Core::SassExtensions::Functions::CrossBrowserSupport
+  extend Compass::Core::SassExtensions::Functions::SassDeclarationHelper
+
+  class CSS2FallbackValue < Sass::Script::Value::Base
+    attr_accessor :value, :css2_value
+    def children
+      [value, css2_value]
+    end
+    def initialize(value, css2_value)
+      self.value = value
+      self.css2_value = css2_value
+    end
+    def inspect
+      to_s
+    end
+    def to_s(options = self.options)
+      value.to_s(options)
+    end
+    def supports?(aspect)
+      aspect == "css2"
+    end
+    def has_aspect?
+      true
+    end
+    def to_css2(options = self.options)
+      css2_value
+    end
+  end
+
+  # 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)}
+    bool(needed)
+  end
+
+  %w(webkit moz o ms svg css2 owg).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)
+      def _#{prefix}(*args)
+        prefix("#{prefix}", *args)
+      end
+    RUBY
+  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::Value::String)
+    prefix = prefix[1..-1] if prefix[0] == ?-
+    if objects.size > 1
+      self.prefix(prefix, list(objects, :comma))
+    else
+      object = objects.first
+      if object.is_a?(Sass::Script::Value::List)
+        list(object.value.map{|e|
+          self.prefix(prefix, e)
+        }, object.separator)
+      elsif object.respond_to?(:supports?) && object.supports?(prefix) && object.respond_to?(:"to_#{prefix}")
+        object.options = options
+        object.send(:"to_#{prefix}")
+      else
+        object
+      end
+    end
+  end
+
+  def css2_fallback(value, css2_value)
+    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::Core::CanIUse.instance.browsers_with_prefix(prefix.value)
+               else
+                 Compass::Core::CanIUse.instance.browsers
+               end
+    list(browsers.map{|b| identifier(b)}, :comma)
+  end
+  declare(:browsers, [])
+  declare(:browsers, [:prefix])
+
+  # The known capabilities of browsers.
+  def browser_capabilities
+    list(Compass::Core::CanIUse.instance.capabilities.map{|c| identifier(c)}, :comma)
+  end
+  declare(:browser_capabilities, [])
+
+  # The versions for the given browser.
+  def browser_versions(browser)
+    assert_type browser, :String
+    list(Compass::Core::CanIUse.instance.versions(browser.value).map{|v| quoted_string(v)}, :comma)
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  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::Core::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
+  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::Core::CanIUse.instance.prefix(browser.value))
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  declare(:browser_prefix, [:browser])
+  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::Core::CanIUse.instance.prefixes(browser_strings)
+    list(prefix_strings.map {|p| identifier(p)}, :comma)
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  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, max_version = nil)
+    assert_type browser, :String
+    assert_type min_version, :String, :min_version
+    assert_type(max_version, :String, :max_version) if max_version
+    versions = [min_version.value]
+    versions << max_version.value if max_version
+    number(Compass::Core::CanIUse.instance.omitted_usage(browser.value, *versions))
+  end
+  declare(:omitted_usage, [:browser, :min_version])
+  declare(:omitted_usage, [:browser, :min_version, :max_version])
+
+  # The version before the version for the browser specified
+  def previous_version(browser, version)
+    assert_type browser, :String
+    assert_type version, :String
+    previous = Compass::Core::CanIUse.instance.previous_version(browser.value, version.value)
+    previous.nil? ? null() : quoted_string(previous)
+  end
+  declare(:previous_version, [:browser, :version])
+
+  # The version before the version for the browser specified
+  def next_version(browser, version)
+    assert_type browser, :String
+    assert_type version, :String
+    next_version = Compass::Core::CanIUse.instance.next_version(browser.value, version.value)
+    next_version.nil? ? null() : quoted_string(next_version)
+  end
+  declare(:next_version, [:browser, :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::Core::CanIUse.instance.prefixed_usage(prefix.value,
+                                                    capability.value,
+                                                    unbox_capability_options_list(capability_options)))
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  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, :browser
+    assert_type version1, :String, :version1
+    assert_type version2, :String, :version2
+    index1 = index2 = nil
+    Compass::Core::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
+  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_ranges(capability, prefix = null(), include_unprefixed_versions = bool(true))
+    assert_type capability, :String
+    assert_type(prefix, :String) unless prefix == null()
+    mins = Compass::Core::CanIUse.instance.browser_ranges(capability.value,
+                                                          prefix.value,
+                                                          include_unprefixed_versions.to_bool)
+    Sass::Script::Value::Map.new(mins.inject({}) do |m, (h, range)|
+      m[identifier(h)] = list(range.map{|version| quoted_string(version)}, :space)
+      m
+    end)
+  end
+  declare(:browser_minimums, [:capability])
+  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

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

@@ -0,0 +1,32 @@
+module Compass::Core::SassExtensions::Functions::Display
+  DEFAULT_DISPLAY = {
+                 "block" => %w{address article aside blockquote center dir div dd details dl dt fieldset
+                               figcaption figure form footer frameset h1 h2 h3 h4 h5 h6 hr header hgroup
+                               isindex main menu nav noframes noscript ol p pre section summary ul},
+                "inline" => %w{a abbr acronym audio b basefont bdo big br canvas cite code command
+                               datalist dfn em embed font i img input keygen kbd label mark meter output
+                               progress q rp rt ruby s samp select small span strike strong sub
+                               sup textarea time tt u var video wbr},
+          "inline-block" => %w{img},
+                 "table" => %w{table},
+             "list-item" => %w{li},
+       "table-row-group" => %w{tbody},
+    "table-header-group" => %w{thead},
+    "table-footer-group" => %w{tfoot},
+             "table-row" => %w{tr},
+            "table-cell" => %w{th td},
+           "html5-block" => %w{article aside details figcaption figure footer header hgroup main menu nav
+                               section summary},
+          "html5-inline" => %w{audio canvas command datalist embed keygen mark meter output progress rp
+                               rt ruby time video wbr},
+            "text-input" => %w{input textarea}
+  }
+
+  DEFAULT_DISPLAY["html5"] = (DEFAULT_DISPLAY["html5-block"] + DEFAULT_DISPLAY["html5-inline"]).sort.uniq
+
+  # returns a comma delimited string for all the
+  # elements according to their default css3 display value.
+  def elements_of_type(display)
+    identifier(DEFAULT_DISPLAY.fetch(display.value.to_s).join(", "))
+  end
+end

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

@@ -0,0 +1,7 @@
+module Compass::Core::SassExtensions::Functions::Enumerate
+  def enumerate(prefix, from, through, separator = nil)
+    separator ||= identifier("-")
+    selectors = (from.value..through.value).map{|i| "#{prefix.value}#{separator.value}#{i}"}.join(", ")
+    identifier(selectors)
+  end
+end

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

@@ -0,0 +1,72 @@
+module Compass::Core::SassExtensions::Functions::Env
+  extend Compass::Core::SassExtensions::Functions::SassDeclarationHelper
+  extend Sass::Script::Value::Helpers
+
+  def compass_env
+    compass_opts = options[:compass] || {}
+    identifier((compass_opts[:environment] || "development").to_s)
+  end
+  declare :compass_env, []
+
+  DEFAULT_TIME = identifier("%T%:z")
+  def current_time(format = DEFAULT_TIME)
+    assert_type format, :String
+    identifier(Time.now.strftime(format.value))
+  end
+  declare :current_time, []
+  declare :current_time, [:format]
+
+  DEFAULT_DATE = identifier("%F")
+  def current_date(format = DEFAULT_DATE)
+    current_time(format)
+  end
+  declare :current_date, []
+  declare :current_date, [:format]
+
+  NOT_ABSOLUTE = bool(false)
+  def current_source_file(absolute = NOT_ABSOLUTE)
+    if absolute.to_bool
+      identifier(options[:original_filename].to_s)
+    else
+      filename = Pathname.new(options[:original_filename].to_s)
+      sass_path = Pathname.new(Compass.configuration.sass_path)
+      relative_filename = filename.relative_path_from(sass_path).to_s rescue filename
+      identifier(relative_filename.to_s)
+    end
+  end
+  declare :current_source_file, []
+  declare :current_source_file, [:absolute]
+
+  def current_output_file(absolute = NOT_ABSOLUTE)
+    if absolute.to_bool
+      identifier(options[:css_filename].to_s)
+    else
+      filename = Pathname.new(options[:css_filename].to_s)
+      css_path = Pathname.new(Compass.configuration.css_path)
+      relative_filename = filename.relative_path_from(css_path).to_s rescue filename
+      identifier(relative_filename.to_s)
+    end
+  end
+  declare :current_output_file, []
+  declare :current_output_file, [:absolute]
+
+  def compass_extensions
+    # Sass::Util.ordered_hash was removed in Sass 3.7
+    # Ruby 1.9+ hashes maintain insertion order, so we can use a regular Hash
+    exts = {identifier("compass") => quoted_string(Compass::Core::VERSION)}
+    if defined?(Compass::Frameworks::ALL)
+      Compass::Frameworks::ALL.each do |framework|
+        next if framework.name == "compass"
+        exts[identifier(framework.name)] =
+          framework.version ? quoted_string(framework.version) : bool(true);
+      end
+    end
+    map(exts)
+  end
+  declare :compass_extensions, []
+
+  def at_stylesheet_root
+    bool(environment.selector.nil?)
+  end
+  declare :at_stylesheet_root, []
+end

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

@@ -0,0 +1,33 @@
+require 'digest/md5'
+
+module Compass::Core::SassExtensions::Functions::Files
+  extend Compass::Core::SassExtensions::Functions::SassDeclarationHelper
+  extend Sass::Script::Value::Helpers
+
+  def md5sum(file, format = nil)
+    assert_type file, :String
+    filename = nil
+    if options[:css_filename] && File.exist?(options[:css_filename])
+      filename = File.expand_path(file.value, File.dirname(options[:css_filename]))
+    elsif Pathname.new(file.value).absolute?
+      filename = file.value
+    end
+    if filename && File.exist?(filename)
+      assert_type file, :String if format
+      digest = Digest::MD5.new()
+      digest << File.read(filename)
+      if !format || format.value == "hex"
+        unquoted_string(digest.hexdigest)
+      elsif format && format.value == "integer"
+        number(digest.hexdigest.hex)
+      elsif format
+        raise Sass::SyntaxError, "Unknown format '#{format}' for md5sum"
+      end
+    else
+      raise Sass::SyntaxError, "File not found: #{file}"
+    end
+  end
+  declare :md5sum, [:file]
+  declare :md5sum, [:file, :format]
+end
+