compass-core-sass37 1.1.0

data/data/caniuse_extras/css-placeholder.json

@@ -0,0 +1,171 @@
+{
+  "title":"::placeholder CSS pseudo-element",
+  "description":"The ::placeholder pseudo-element represents any form element displaying placeholder text.",
+  "spec":"https://developer.mozilla.org/en-US/docs/Web/CSS/::-moz-placeholder",
+  "status":"unoff",
+  "links":[
+    {
+      "url":"http://css-tricks.com/snippets/css/style-placeholder-text/",
+      "title":"CSS-Tricks article with all prefixes"
+    },
+    {
+      "url":"http://wiki.csswg.org/ideas/placeholder-styling",
+      "title":"CSSWG discussion"
+    },
+    {
+      "url":"http://msdn.microsoft.com/en-us/library/ie/hh772745(v=vs.85).aspx",
+      "title":"MSDN article"
+    }
+  ],
+  "bugs":[
+    
+  ],
+  "categories":[
+    "CSS"
+  ],
+  "stats":{
+    "ie":{
+      "5.5":"n",
+      "6":"n",
+      "7":"n",
+      "8":"n",
+      "9":"n",
+      "10":"y x",
+      "11":"y x"
+    },
+    "firefox":{
+      "2":"n",
+      "3":"n",
+      "3.5":"n",
+      "3.6":"n",
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x"
+    },
+    "chrome":{
+      "4":"y x",
+      "5":"y x",
+      "6":"y x",
+      "7":"y x",
+      "8":"y x",
+      "9":"y x",
+      "10":"y x",
+      "11":"y x",
+      "12":"y x",
+      "13":"y x",
+      "14":"y x",
+      "15":"y x",
+      "16":"y x",
+      "17":"y x",
+      "18":"y x",
+      "19":"y x",
+      "20":"y x",
+      "21":"y x",
+      "22":"y x",
+      "23":"y x",
+      "24":"y x",
+      "25":"y x",
+      "26":"y x",
+      "27":"y x",
+      "28":"y x",
+      "29":"y x",
+      "30":"y x",
+      "31":"y x",
+      "32":"y x"
+    },
+    "safari":{
+      "3.1":"n",
+      "3.2":"n",
+      "4":"n",
+      "5":"y x",
+      "5.1":"y x",
+      "6":"y x",
+      "7":"y x"
+    },
+    "opera":{
+      "9":"n",
+      "9.5-9.6":"n",
+      "10.0-10.1":"n",
+      "10.5":"n",
+      "10.6":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "11.6":"n",
+      "12":"n",
+      "12.1":"n",
+      "15":"y x",
+      "16":"a",
+      "17":"a"
+    },
+    "ios_saf":{
+      "3.2":"n",
+      "4.0-4.1":"n",
+      "4.2-4.3":"y x",
+      "5.0-5.1":"y x",
+      "6.0-6.1":"y x",
+      "7.0":"y x"
+    },
+    "op_mini":{
+      "5.0-7.0":"n"
+    },
+    "android":{
+      "2.1":"u",
+      "2.2":"u",
+      "2.3":"u",
+      "3":"u",
+      "4":"u",
+      "4.1":"u",
+      "4.2":"u"
+    },
+    "bb":{
+      "7":"u",
+      "10":"u"
+    },
+    "op_mob":{
+      "10":"n",
+      "11":"n",
+      "11.1":"n",
+      "11.5":"n",
+      "12":"n",
+      "12.1":"n",
+      "14":"y x"
+    },
+    "and_chr":{
+      "0":"y x"
+    },
+    "and_ff":{
+      "0":"n"
+    },
+    "ie_mob":{
+      "10":"y x"
+    }
+  },
+  "notes":"",
+  "usage_perc_y":70.21,
+  "usage_perc_a":0.18,
+  "ucprefix":false,
+  "parent":"",
+  "keywords":"::placeholder,placeholder",
+  "shown":false
+}

data/lib/compass/browser_support.rb

@@ -0,0 +1,64 @@
+module Compass
+  module BrowserSupport
+    extend self
+
+    ASPECTS = %w(webkit moz o ms svg css2)
+
+    SIMPLE_FUNCTIONS = {
+           "image" => %w(webkit),
+      "cross-fade" => %w(webkit),
+      "repeating-linear-gradient" => %w(webkit moz), # Hacky implementation
+      "repeating-radial-gradient" => %w(webkit moz)  # Hacky implementation
+    }
+
+    # Adds support for one or more aspects for the given simple function
+    # Example:
+    #
+    #   Compass::BrowserSupport.add_support("image", "moz", "webkit")
+    #   # => Adds support for moz and webkit to the image() function.
+    #
+    # This function can be called one or more times in a compass configuration
+    # file in order to add support for new, simple browser functions without
+    # waiting for a new compass release.
+    def add_support(function, *aspects)
+      aspects.each do |aspect|
+        unless ASPECTS.include?(aspect)
+          Compass::Util.compass_warn "Unknown support aspect: #{aspect}"
+          next
+        end
+        unless supports?(function, aspect)
+          SIMPLE_FUNCTIONS[function.to_s] ||= []
+          SIMPLE_FUNCTIONS[function.to_s] << aspect.to_s
+        end
+      end
+    end
+
+    # Removes support for one or more aspects for the given simple function
+    # Example:
+    #
+    #   Compass::BrowserSupport.remove_support("image", "o", "ms")
+    #   # => Adds support for moz and webkit to the image() function.
+    #
+    # This function can be called one or more times in a compass configuration
+    # file in order to remove support for simple functions that no longer need to
+    # a prefix without waiting for a new compass release.
+    def remove_support(function, *aspects)
+      aspects.each do |aspect|
+        unless ASPECTS.include?(aspect)
+          Compass::Util.compass_warn "Unknown support aspect: #{aspect}"
+          next
+        end
+        SIMPLE_FUNCTIONS[function.to_s].reject!{|a| a == aspect.to_s}
+      end
+    end
+
+    def supports?(function, aspect)
+      SIMPLE_FUNCTIONS.has_key?(function.to_s) && SIMPLE_FUNCTIONS[function.to_s].include?(aspect.to_s)
+    end
+
+    def has_aspect?(function)
+      SIMPLE_FUNCTIONS.has_key?(function.to_s) && SIMPLE_FUNCTIONS[function.to_s].size > 0
+    end
+
+  end
+end

data/lib/compass/configuration/adapters.rb

@@ -0,0 +1,109 @@
+module Compass
+  module Configuration
+    # The adapters module provides methods that make configuration data from a compass project
+    # adapt to various consumers of configuration data
+    module Adapters
+      def to_compiler_arguments(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
+        locations = []
+        locations << [sass_path, css_path] if sass_path && css_path
+        Compass::Frameworks::ALL.each do |framework|
+          locations << [framework.stylesheets_directory, File.join(css_path || css_dir || ".", framework.name)]
+        end
+        plugin_opts = {:template_location => locations}
+        plugin_opts[:style] = output_style if output_style
+        plugin_opts[:line_comments] = line_comments
+        if sass_3_4?
+          plugin_opts[:sourcemap] = sourcemap ? :auto : :none
+        else
+          plugin_opts[:sourcemap] = sourcemap
+        end
+        plugin_opts[:cache] = cache unless cache.nil?
+        plugin_opts[:cache_location] = cache_path unless cache_path.nil?
+        plugin_opts[:quiet] = disable_warnings if disable_warnings
+        plugin_opts[:compass] = {}
+        plugin_opts[:compass][:environment] = environment
+        plugin_opts.merge!(sass_options || {})
+        plugin_opts[:load_paths] ||= []
+        plugin_opts[:load_paths] += resolve_additional_import_paths
+        # TODO: When sprites are extracted to their own plugin, this
+        # TODO: will need to be extracted to there.
+        if defined?(Compass::SpriteImporter.new)
+          plugin_opts[:load_paths] << Compass::SpriteImporter.new
+        end
+        plugin_opts[:full_exception] = (environment == :development)
+        plugin_opts
+      end
+
+      def resolve_additional_import_paths
+        (additional_import_paths || []).map do |path|
+          if path.is_a?(String) && project_path && !absolute_path?(path)
+            File.join(project_path, path)
+          else
+            path
+          end
+        end
+      end
+
+      def absolute_path?(path)
+        # Pretty basic implementation
+        path.index(File::SEPARATOR) == 0 || path.index(':') == 1
+      end
+
+      def to_sass_engine_options
+        engine_opts = {:load_paths => sass_load_paths}
+        engine_opts[:style] = output_style if output_style
+        engine_opts[:line_comments] = line_comments
+        if sass_3_4?
+          engine_opts[:sourcemap] = sourcemap ? :auto : :none
+        else
+          engine_opts[:sourcemap] = sourcemap
+        end
+        engine_opts[:cache] = cache
+        engine_opts[:cache_location] = cache_path
+        engine_opts[:quiet] = disable_warnings if disable_warnings
+        engine_opts[:compass] = {}
+        engine_opts[:compass][:environment] = environment
+        engine_opts[:full_exception] = (environment == :development)
+        engine_opts.merge!(sass_options || {})
+      end
+
+      def sass_load_paths
+        load_paths = []
+        load_paths << sass_path if sass_path && File.directory?(sass_path)
+        Compass::Frameworks::ALL.each do |f|
+          load_paths << f.stylesheets_directory if File.directory?(f.stylesheets_directory)
+        end
+        importer = sass_options[:filesystem_importer] if sass_options && sass_options[:filesystem_importer]
+        importer ||= Sass::Importers::Filesystem
+        load_paths += resolve_additional_import_paths
+        load_paths.map! do |p|
+          next p if p.respond_to?(:find_relative)
+          importer.new(p.to_s)
+        end
+        # TODO: When sprites are extracted to their own plugin, this
+        # TODO: will need to be extracted to there.
+        if defined?(Compass::SpriteImporter.new)
+          load_paths << Compass::SpriteImporter.new
+        end
+        load_paths
+      end
+
+      def sass_3_4?
+        Sass.version[:major] == 3 && Sass.version[:minor] == 4
+      end
+    end
+    class Data
+      include Adapters
+    end
+  end
+end

data/lib/compass/configuration/data.rb

@@ -0,0 +1,199 @@
+module Compass
+  module Configuration
+    # The Compass configuration data storage class manages configuration data that comes from a variety of
+    # different sources and aggregates them together into a consistent API
+    # Some of the possible sources of configuration data:
+    #   * Compass default project structure for stand alone projects
+    #   * App framework specific project structures for rails, etc.
+    #   * User supplied explicit configuration
+    #   * Configuration data provided via the command line interface
+    #
+    # There are two kinds of configuration data that doesn't come from the user:
+    #
+    # 1. Configuration data that is defaulted as if the user had provided it themselves.
+    #    This is useful for providing defaults that the user is likely to want to edit
+    #    but shouldn't have to provide explicitly when getting started
+    # 2. Configuration data that is defaulted behind the scenes because _some_ value is
+    #    required.
+    class Data
+
+      attr_reader :name
+      extend Sass::Callbacks
+
+
+      include Compass::Configuration::Inheritance
+      extend  Compass::Configuration::Paths
+
+      # on_sprite_saved
+      # yields the filename
+      # usage: on_sprite_saved {|filename| do_something(filename) }
+      define_callback :sprite_saved
+      chained_method :run_sprite_saved
+
+      # on_sprite_generated
+      # yields 'ChunkyPNG::Image'
+      # usage: on_sprite_generated {|sprite_data| do_something(sprite_data) }
+      define_callback :sprite_generated
+      chained_method :run_sprite_generated
+
+      # on_sprite_removed
+      # yields the filename
+      # usage: on_sprite_removed {|filename| do_something(filename) }
+      define_callback :sprite_removed
+      chained_method :run_sprite_removed
+
+      # on_stylesheet_saved
+      # yields the filename
+      # usage: on_stylesheet_saved {|filename| do_something(filename) }
+      define_callback :stylesheet_saved
+      chained_method :run_stylesheet_saved
+
+      # on_sourcemap_saved
+      # yields the filename
+      # usage: on_sourcemap_saved {|filename| do_something(filename) }
+      define_callback :sourcemap_saved
+      chained_method :run_sourcemap_saved
+
+      # on_stylesheet_removed
+      # yields the filename
+      # usage: on_stylesheet_removed {|filename| do_something(filename) }
+      define_callback :stylesheet_removed
+      chained_method :run_stylesheet_removed
+
+      # on_sourcemap_removed
+      # yields the filename
+      # usage: on_sourcemap_removed {|filename| do_something(filename) }
+      define_callback :sourcemap_removed
+      chained_method :run_sourcemap_removed
+
+      # on_stylesheet_error
+      # yields the filename & message
+      # usage: on_stylesheet_error {|filename, message| do_something(filename, message) }
+      define_callback :stylesheet_error
+      chained_method :run_stylesheet_error
+
+      inherited_accessor(*ATTRIBUTES)
+
+      strip_trailing_separator(*ATTRIBUTES.select{|a| a.to_s =~ /dir|path/})
+
+      ARRAY_ATTRIBUTES.each do |array_attr|
+        inherited_array(array_attr, ARRAY_ATTRIBUTE_OPTIONS.fetch(array_attr, {}))
+      end
+
+      def initialize(name, attr_hash = nil)
+        raise "I need a name!" unless name
+        @name = name
+        set_all(attr_hash) if attr_hash
+        self.top_level = self
+      end
+
+      def set_all(attr_hash)
+        attr_hash.each do |a, v|
+          if self.respond_to?("#{a}=")
+            self.send("#{a}=", v)
+          end
+        end
+      end
+
+      def add_import_path(*paths)
+        paths.map!{|p| defined?(Pathname) && Pathname === p ? p.to_s : p}
+        # The @added_import_paths variable works around an issue where
+        # the additional_import_paths gets overwritten during parse
+        @added_import_paths ||= []
+        @added_import_paths += paths
+        paths.each do |p|
+          self.additional_import_paths << p unless additional_import_paths.include?(p)
+        end
+      end
+
+      # When called with a block, defines the asset host url to be used.
+      # The block must return a string that starts with a protocol (E.g. http).
+      # The block will be passed the root-relative url of the asset.
+      # When called without a block, returns the block that was previously set.
+      def asset_host(&block)
+        @set_attributes ||= {}
+        if block_given?
+          @set_attributes[:asset_host] = true
+          @asset_host = block
+        else
+          if @asset_host
+            @asset_host
+          elsif inherited_data.respond_to?(:asset_host)
+            inherited_data.asset_host
+          end
+        end
+      end
+
+      # When called with a block, defines the cache buster strategy to be used.
+      # If the block returns nil or a string, then it is appended to the url as a query parameter.
+      # In this case, the returned string must not include the starting '?'.
+      # The block may also return a hash with :path and/or :query values and it
+      # will replace the original path and query string with the busted values returned.
+      # The block will be passed the root-relative url of the asset.
+      # If the block accepts two arguments, it will also be passed a File object
+      # that points to the asset on disk -- which may or may not exist.
+      # When called without a block, returns the block that was previously set.
+      #
+      # To disable the asset cache buster:
+      #
+      #     asset_cache_buster :none
+      def asset_cache_buster(simple = nil, &block)
+        @set_attributes ||= {}
+        if block_given?
+          @set_attributes[:asset_cache_buster] = true
+          @asset_cache_buster = block
+        elsif !simple.nil?
+          if simple == :none
+            @set_attributes[:asset_cache_buster] = true
+            @asset_cache_buster = Proc.new {|_,_| nil}
+          else
+            raise ArgumentError, "Unexpected argument: #{simple.inspect}"
+          end
+        else
+          if set?(:asset_cache_buster)
+            @asset_cache_buster
+          elsif inherited_data.respond_to?(:asset_cache_buster)
+            inherited_data.asset_cache_buster
+          end
+        end
+      end
+
+      def watch(glob, &block)
+        @watches ||= []
+        @watches << Watch.new(glob, &block)
+      end
+
+      def watches
+        if defined?(@watches)
+          @watches
+        elsif inherited_data.respond_to?(:watches)
+          inherited_data.watches
+        else
+          []
+        end
+      end
+
+      # Require a compass plugin and capture that it occured so that the configuration serialization works next time.
+      def require(lib)
+        (self.required_libraries ||= []) << lib
+        super
+      end
+
+      def load(framework_dir)
+        (self.loaded_frameworks ||= []) << framework_dir
+        Compass::Frameworks.register_directory framework_dir
+      end
+
+      # Finds all extensions within a directory and registers them.
+      def discover(frameworks_dir)
+        (self.framework_path ||= []) << frameworks_dir
+        Compass::Frameworks.discover frameworks_dir
+      end
+
+      def relative_assets?
+        # the http_images_path is deprecated, but here for backwards compatibility.
+        relative_assets || http_images_path == :relative
+      end
+    end
+  end
+end