### Home Classes Methods

### In Files

- lib/sass/importers/filesystem.rb

### Parent

Sass::Importers::Base

### Methods

- ::new
- #directories_to_watch
- #eql?
- #escape_glob_characters
- #extensions
- #find
- #find_real_file
- #find_relative
- #hash
- #key
- #mtime
- #possible_files
- #public_url
- #remove_root
- #split
- #to_s
- #watched_file?

### Class/Module Index

Quicksearch

- Sass
- Sass::BaseEnvironment
- Sass::CSS
- Sass::CacheStores
- Sass::CacheStores::Base
- Sass::CacheStores::Chain
- Sass::CacheStores::Filesystem
- Sass::CacheStores::Memory
- Sass::CacheStores::Null
- Sass::Callbacks
- Sass::Callbacks::InstanceMethods
- Sass::Engine
- Sass::Engine::Line
- Sass::Environment
- Sass::Exec
- Sass::Exec::Base
- Sass::Exec::SassConvert
- Sass::Exec::SassScss
- Sass::Exec::SassScss::Sass::Plugin.compiler
- Sass::Features
- Sass::Importers
- Sass::Importers::Base
- Sass::Importers::Filesystem
- Sass::Logger
- Sass::Logger::Base
- Sass::Logger::LogLevel
- Sass::Logger::LogLevel::ClassMethods
- Sass::Media
- Sass::Media::Query
- Sass::Media::QueryList
- Sass::Plugin
- Sass::Plugin::Compiler
- Sass::Plugin::Configuration
- Sass::Plugin::MerbBootLoader
- Sass::Plugin::Rack
- Sass::Plugin::StalenessChecker
- Sass::ReadOnlyEnvironment
- Sass::Repl
- Sass::SCSS
- Sass::SCSS::CssParser
- Sass::SCSS::Parser
- Sass::SCSS::RX
- Sass::SCSS::ScriptLexer
- Sass::SCSS::ScriptParser
- Sass::SCSS::StaticParser
- Sass::Script
- Sass::Script::CssLexer
- Sass::Script::CssParser
- Sass::Script::Functions
- Sass::Script::Functions::EvaluationContext
- Sass::Script::Lexer
- Sass::Script::Parser
- Sass::Script::Tree
- Sass::Script::Tree::Funcall
- Sass::Script::Tree::Interpolation
- Sass::Script::Tree::ListLiteral
- Sass::Script::Tree::Literal
- Sass::Script::Tree::MapLiteral
- Sass::Script::Tree::Node
- Sass::Script::Tree::Operation
- Sass::Script::Tree::Selector
- Sass::Script::Tree::StringInterpolation
- Sass::Script::Tree::UnaryOperation
- Sass::Script::Tree::Variable
- Sass::Script::Value
- Sass::Script::Value::ArgList
- Sass::Script::Value::Base
- Sass::Script::Value::Bool
- Sass::Script::Value::Color
- Sass::Script::Value::Helpers
- Sass::Script::Value::List
- Sass::Script::Value::Map
- Sass::Script::Value::Null
- Sass::Script::Value::Number
- Sass::Script::Value::String
- Sass::Selector
- Sass::Selector::AbstractSequence
- Sass::Selector::Attribute
- Sass::Selector::Class
- Sass::Selector::CommaSequence
- Sass::Selector::Element
- Sass::Selector::Id
- Sass::Selector::Parent
- Sass::Selector::Placeholder
- Sass::Selector::Pseudo
- Sass::Selector::Sequence
- Sass::Selector::Simple
- Sass::Selector::SimpleSequence
- Sass::Selector::Universal
- Sass::SemiGlobalEnvironment
- Sass::Shared
- Sass::Source
- Sass::Source::Map
- Sass::Source::Map::Mapping
- Sass::Source::Position
- Sass::Source::Range
- Sass::Stack
- Sass::Stack::Frame
- Sass::Supports
- Sass::Supports::Condition
- Sass::Supports::Declaration
- Sass::Supports::Interpolation
- Sass::Supports::Negation
- Sass::Supports::Operator
- Sass::SyntaxError
- Sass::Tree
- Sass::Tree::AtRootNode
- Sass::Tree::CharsetNode
- Sass::Tree::CommentNode
- Sass::Tree::ContentNode
- Sass::Tree::CssImportNode
- Sass::Tree::DebugNode
- Sass::Tree::DirectiveNode
- Sass::Tree::EachNode
- Sass::Tree::ErrorNode
- Sass::Tree::ExtendNode
- Sass::Tree::ForNode
- Sass::Tree::FunctionNode
- Sass::Tree::IfNode
- Sass::Tree::ImportNode
- Sass::Tree::KeyframeRuleNode
- Sass::Tree::MediaNode
- Sass::Tree::MixinDefNode
- Sass::Tree::MixinNode
- Sass::Tree::Node
- Sass::Tree::PropNode
- Sass::Tree::ReturnNode
- Sass::Tree::RootNode
- Sass::Tree::RuleNode
- Sass::Tree::SupportsNode
- Sass::Tree::TraceNode
- Sass::Tree::VariableNode
- Sass::Tree::Visitors
- Sass::Tree::Visitors::Base
- Sass::Tree::Visitors::CheckNesting
- Sass::Tree::Visitors::Convert
- Sass::Tree::Visitors::Cssize
- Sass::Tree::Visitors::Cssize::Bubble
- Sass::Tree::Visitors::DeepCopy
- Sass::Tree::Visitors::Extend
- Sass::Tree::Visitors::Perform
- Sass::Tree::Visitors::SetOptions
- Sass::Tree::Visitors::ToCss
- Sass::Tree::WarnNode
- Sass::Tree::WhileNode
- Sass::UnitConversionError
- Sass::Util
- Sass::Util::CrossPlatformRandom
- Sass::Util::MultibyteStringScanner
- Sass::Util::NormalizedMap
- Sass::Util::StaticConditionalContext
- Sass::Util::SubsetMap
- Sass::Util::Test
- Sass::Version
- ActionController
- ActionController::Base
- Object
- OrderedHash

No matching classes.

# Sass::Importers::Filesystem

The default importer, used for any strings found in the load path. Simply loads Sass files from the filesystem using the default logic.

### Constants

REDUNDANT_DIRECTORY

### Attributes

root[RW]

### Public Class Methods

new(root) click to toggle source

Creates a new filesystem importer that imports files relative to a given path.

@param root [String] The root path.

    This importer will import files relative to this path.

    # File lib/sass/importers/filesystem.rb, line 14
    def initialize(root)
      @root = File.expand_path(root)
      @real_root = Sass::Util.realpath(@root).to_s
      @same_name_warnings = Set.new
    end

### Public Instance Methods

directories_to_watch() click to toggle source

@see Base#directories_to_watch

    # File lib/sass/importers/filesystem.rb, line 58
    def directories_to_watch
      [root]
    end

eql?(other) click to toggle source

    # File lib/sass/importers/filesystem.rb, line 53
    def eql?(other)
      !other.nil? && other.respond_to?(:root) && root.eql?(other.root)
    end

find(name, options) click to toggle source

@see Base#find

    # File lib/sass/importers/filesystem.rb, line 26
    def find(name, options)
      _find(@root, name, options)
    end

find_relative(name, base, options) click to toggle source

@see Base#find_relative

    # File lib/sass/importers/filesystem.rb, line 21
    def find_relative(name, base, options)
      _find(File.dirname(base), name, options)
    end

hash() click to toggle source

    # File lib/sass/importers/filesystem.rb, line 49
    def hash
      @root.hash
    end

key(name, options) click to toggle source

@see Base#key

    # File lib/sass/importers/filesystem.rb, line 39
    def key(name, options)
      [self.class.name + ":" + File.dirname(File.expand_path(name)),
       File.basename(name)]
    end

mtime(name, options) click to toggle source

@see Base#mtime

    # File lib/sass/importers/filesystem.rb, line 31
    def mtime(name, options)
      file, _ = Sass::Util.destructure(find_real_file(@root, name, options))
      File.mtime(file) if file
    rescue Errno::ENOENT
      nil
    end

public_url(name, sourcemap_directory) click to toggle source

    # File lib/sass/importers/filesystem.rb, line 69
    def public_url(name, sourcemap_directory)
      file_pathname = Sass::Util.cleanpath(Sass::Util.absolute_path(name, @root))
      return Sass::Util.file_uri_from_path(file_pathname) if sourcemap_directory.nil?

      sourcemap_pathname = Sass::Util.cleanpath(sourcemap_directory)
      begin
        Sass::Util.file_uri_from_path(
          Sass::Util.relative_path_from(file_pathname, sourcemap_pathname))
      rescue ArgumentError # when a relative path cannot be constructed
        Sass::Util.file_uri_from_path(file_pathname)
      end
    end

to_s() click to toggle source

@see Base#to_s

    # File lib/sass/importers/filesystem.rb, line 45
    def to_s
      @root
    end

watched_file?(filename) click to toggle source

@see Base#watched_file?

    # File lib/sass/importers/filesystem.rb, line 63
    def watched_file?(filename)
      # Check against the root with symlinks resolved, since Listen
      # returns fully-resolved paths.
      filename =~ /\.s[ac]ss$/ && filename.start_with?(@real_root + File::SEPARATOR)
    end

### Protected Instance Methods

escape_glob_characters(name) click to toggle source

    # File lib/sass/importers/filesystem.rb, line 128
    def escape_glob_characters(name)
      name.gsub(/[\*\[\]\{\}\?]/) do |char|
        "\\#{char}"
      end
    end

extensions() click to toggle source

A hash from file extensions to the syntaxes for those extensions. The syntaxes must be `:sass` or `:scss`.

This can be overridden by subclasses that want normal filesystem importing with unusual extensions.

@return [{String => Symbol}]

    # File lib/sass/importers/filesystem.rb, line 101
    def extensions
      {'sass' => :sass, 'scss' => :scss}
    end

find_real_file(dir, name, options) click to toggle source

Given a base directory and an `@import`ed name, finds an existant file that matches the name.

@param dir [String] The directory relative to which to search. @param name [String] The filename to search for. @return [(String, Symbol)] A filename-syntax pair.

    # File lib/sass/importers/filesystem.rb, line 141
    def find_real_file(dir, name, options)
      # On windows 'dir' or 'name' can be in native File::ALT_SEPARATOR form.
      dir = dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
      name = name.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?

      found = possible_files(remove_root(name)).map do |f, s|
        path = (dir == "." || Sass::Util.pathname(f).absolute?) ? f :
          "#{escape_glob_characters(dir)}/#{f}"
        Dir[path].map do |full_path|
          full_path.gsub!(REDUNDANT_DIRECTORY, File::SEPARATOR)
          [Sass::Util.cleanpath(full_path).to_s, s]
        end
      end
      found = Sass::Util.flatten(found, 1)
      return if found.empty?

      if found.size > 1 && !@same_name_warnings.include?(found.first.first)
        found.each {|(f, _)| @same_name_warnings << f}
        relative_to = Sass::Util.pathname(dir)
        if options[:_from_import_node]
          # If _line exists, we're here due to an actual import in an
          # import_node and we want to print a warning for a user writing an
          # ambiguous import.
          candidates = found.map do |(f, _)|
            "  " + Sass::Util.pathname(f).relative_path_from(relative_to).to_s
          end.join("\n")
          raise Sass::SyntaxError.new(It's not clear which file to import for '@import "#{name}"'.Candidates:#{candidates}Please delete or rename all but one of these files.)
        else
          # Otherwise, we're here via StalenessChecker, and we want to print a
          # warning for a user running `sass --watch` with two ambiguous files.
          candidates = found.map {|(f, _)| "    " + File.basename(f)}.join("\n")
          Sass::Util.sass_warn WARNING: In #{File.dirname(name)}:  There are multiple files that match the name "#{File.basename(name)}":#{candidates}
        end
      end
      found.first
    end

possible_files(name) click to toggle source

Given an `@import`ed path, returns an array of possible on-disk filenames and their corresponding syntaxes for that path.

@param name [String] The filename. @return [Array(String, Symbol)] An array of pairs.

    The first element of each pair is a filename to look for;
    the second element is the syntax that file would be in (`:sass` or `:scss`).

    # File lib/sass/importers/filesystem.rb, line 112
    def possible_files(name)
      name = escape_glob_characters(name)
      dirname, basename, extname = split(name)
      sorted_exts = extensions.sort
      syntax = extensions[extname]

      if syntax
        ret = [["#{dirname}/{_,}#{basename}.#{extensions.invert[syntax]}", syntax]]
      else
        ret = sorted_exts.map {|ext, syn| ["#{dirname}/{_,}#{basename}.#{ext}", syn]}
      end

      # JRuby chokes when trying to import files from JARs when the path starts with './'.
      ret.map {|f, s| [f.sub(/^\.\//, ''), s]}
    end

remove_root(name) click to toggle source

If a full uri is passed, this removes the root from it otherwise returns the name unchanged

    # File lib/sass/importers/filesystem.rb, line 86
    def remove_root(name)
      if name.index(@root + "/") == 0
        name[(@root.length + 1)..-1]
      else
        name
      end
    end

split(name) click to toggle source

Splits a filename into three parts, a directory part, a basename, and an extension Only the known extensions returned from the extensions method will be recognized as such.

    # File lib/sass/importers/filesystem.rb, line 189
    def split(name)
      extension = nil
      dirname, basename = File.dirname(name), File.basename(name)
      if basename =~ /^(.*)\.(#{extensions.keys.map {|e| Regexp.escape(e)}.join('|')})$/
        basename = $1
        extension = $2
      end
      [dirname, basename, extension]
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.