class Sass::Importers::Filesystem

def _find(dir, name, options)
  full_filename, syntax = Sass::Util.destructure(find_real_file(dir, name, options))
  return unless full_filename && File.readable?(full_filename)
  options[:syntax] = syntax
  options[:filename] = full_filename
  options[:importer] = self
  Sass::Engine.new(File.read(full_filename), options)
end

def eql?(other)
  root.eql?(other.root)
end

def escape_glob_characters(name)
  name.gsub(/[\*\[\]\{\}\?]/) do |char|
    "\\#{char}"
  end
end

def extensions
  {'sass' => :sass, 'scss' => :scss}
end

def find(name, options)
  _find(@root, name, options)
end

def find_real_file(dir, name, options)
  # on windows 'dir' can be in native File::ALT_SEPARATOR form
  dir = dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
  found = possible_files(remove_root(name)).map do |f, s|
    path = (dir == "." || Pathname.new(f).absolute?) ? f : "#{dir}/#{f}"
    Dir[path].map do |full_path|
      full_path.gsub!(REDUNDANT_DIRECTORY, File::SEPARATOR)
      [full_path, 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 = Pathname.new(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 {|(f, _)| "  " + Pathname.new(f).relative_path_from(relative_to).to_s}.join("\n")
      raise Sass::SyntaxError.new(<<MESSAGE)
ot clear which file to import for '@import "#{name}"'.
ates:
idates}
 delete or rename all but one of these files.
E
    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
G: In #{File.dirname(name)}:
e are multiple files that match the name "#{File.basename(name)}":
idates}
G
    end
  end
  found.first
end

def find_relative(name, base, options)
  _find(File.dirname(base), name, options)
end

def hash
  @root.hash
end

def initialize(root)
  @root = File.expand_path(root)
  @same_name_warnings = Set.new
end

def join(base, path)
  Pathname.new(base).join(path).to_s
end

def key(name, options)
  [self.class.name + ":" + File.dirname(File.expand_path(name)),
    File.basename(name)]
end

def mtime(name, options)
  file, _ = Sass::Util.destructure(find_real_file(@root, name, options))
  File.mtime(file) if file
rescue Errno::ENOENT
  nil
end

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(%r{^\./}, ''), s]}
end

def remove_root(name)
  if name.index(@root + "/") == 0
    name[(@root.length + 1)..-1]
  else
    name
  end
end

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

def to_s
  @root
end