simple-templater 0.0.1

data/vendor/fakefs/lib/fakefs/file.rb

@@ -0,0 +1,330 @@
+module FakeFS
+  class File < StringIO
+    PATH_SEPARATOR = '/'
+
+    MODES = [
+      READ_ONLY           = "r",
+      READ_WRITE          = "r+",
+      WRITE_ONLY          = "w",
+      READ_WRITE_TRUNCATE = "w+",
+      APPEND_WRITE_ONLY   = "a",
+      APPEND_READ_WRITE   = "a+"
+    ]
+
+    FILE_CREATION_MODES = MODES - [READ_ONLY, READ_WRITE]
+
+    MODE_BITMASK = RealFile::RDONLY   |
+                   RealFile::WRONLY   |
+                   RealFile::RDWR     |
+                   RealFile::APPEND   |
+                   RealFile::CREAT    |
+                   RealFile::EXCL     |
+                   RealFile::NONBLOCK |
+                   RealFile::TRUNC    |
+                   RealFile::NOCTTY   |
+                   RealFile::SYNC
+
+    FILE_CREATION_BITMASK = RealFile::CREAT
+
+    def self.extname(path)
+      RealFile.extname(path)
+    end
+
+    def self.join(*parts)
+      parts * PATH_SEPARATOR
+    end
+
+    def self.exist?(path)
+      !!FileSystem.find(path)
+    end
+
+    class << self
+      alias_method :exists?, :exist?
+
+      # Assuming that everyone can read and write files
+      alias_method :readable?, :exist?
+      alias_method :writable?, :exist?
+    end
+
+    def self.mtime(path)
+      if exists?(path)
+        FileSystem.find(path).mtime
+      else
+        raise Errno::ENOENT
+      end
+    end
+
+    def self.size(path)
+      read(path).length
+    end
+
+    def self.size?(path)
+      if exists?(path) && !size(path).zero?
+        true
+      else
+        nil
+      end
+    end
+
+    def self.const_missing(name)
+      RealFile.const_get(name)
+    end
+
+    def self.directory?(path)
+      if path.respond_to? :entry
+        path.entry.is_a? FakeDir
+      else
+        result = FileSystem.find(path)
+        result ? result.entry.is_a?(FakeDir) : false
+      end
+    end
+
+    def self.symlink?(path)
+      if path.respond_to? :entry
+        path.is_a? FakeSymlink
+      else
+        FileSystem.find(path).is_a? FakeSymlink
+      end
+    end
+
+    def self.file?(path)
+      if path.respond_to? :entry
+        path.entry.is_a? FakeFile
+      else
+        result = FileSystem.find(path)
+        result ? result.entry.is_a?(FakeFile) : false
+      end
+    end
+
+    def self.expand_path(*args)
+      RealFile.expand_path(*args)
+    end
+
+    def self.basename(*args)
+      RealFile.basename(*args)
+    end
+
+    def self.dirname(path)
+      RealFile.dirname(path)
+    end
+
+    def self.readlink(path)
+      symlink = FileSystem.find(path)
+      FileSystem.find(symlink.target).to_s
+    end
+
+    def self.read(path)
+      file = new(path)
+      if file.exists?
+        file.read
+      else
+        raise Errno::ENOENT
+      end
+    end
+
+    def self.readlines(path)
+      read(path).split("\n")
+    end
+
+    def self.link(source, dest)
+      if directory?(source)
+        raise Errno::EPERM, "Operation not permitted - #{source} or #{dest}"
+      end
+
+      if !exists?(source)
+        raise Errno::ENOENT, "No such file or directory - #{source} or #{dest}"
+      end
+
+      if exists?(dest)
+        raise Errno::EEXIST, "File exists - #{source} or #{dest}"
+      end
+
+      source = FileSystem.find(source)
+      dest = FileSystem.add(dest, source.entry.clone)
+      source.link(dest)
+
+      0
+    end
+
+    def self.delete(file_name, *additional_file_names)
+      if !exists?(file_name)
+        raise Errno::ENOENT, "No such file or directory - #{file_name}"
+      end
+
+      FileUtils.rm(file_name)
+
+      additional_file_names.each do |file_name|
+        FileUtils.rm(file_name)
+      end
+
+      additional_file_names.size + 1
+    end
+
+    class << self
+      alias_method :unlink, :delete
+    end
+
+    def self.symlink(source, dest)
+      FileUtils.ln_s(source, dest)
+    end
+
+    def self.stat(file)
+      File::Stat.new(file)
+    end
+
+    class Stat
+      def initialize(file)
+        if !File.exists?(file)
+          raise(Errno::ENOENT, "No such file or directory - #{file}")
+        end
+
+        @file = file
+      end
+
+      def symlink?
+        File.symlink?(@file)
+      end
+
+      def directory?
+        File.directory?(@file)
+      end
+
+      def nlink
+        FileSystem.find(@file).links.size
+      end
+    end
+
+    attr_reader :path
+
+    def initialize(path, mode = READ_ONLY, perm = nil)
+      @path = path
+      @mode = mode
+      @file = FileSystem.find(path)
+
+      check_modes!
+
+      file_creation_mode? ? create_missing_file : check_file_existence!
+
+      super(@file.content, mode)
+    end
+
+    def exists?
+      true
+    end
+
+    alias_method :tell=, :pos=
+
+    undef_method :closed_read?
+    undef_method :closed_write?
+    undef_method :length
+    undef_method :size
+    undef_method :string
+    undef_method :string=
+
+    def ioctl(integer_cmd, arg)
+      raise NotImplementedError
+    end
+
+    def read_nonblock(maxlen, outbuf = nil)
+      raise NotImplementedError
+    end
+
+    def stat
+      raise NotImplementedError
+    end
+
+    def sysseek(offset, whence = SEEK_SET)
+      raise NotImplementedError
+    end
+
+    alias_method :to_i, :fileno
+
+    def to_io
+      self
+    end
+
+    def write_nonblock(string)
+      raise NotImplementedError
+    end
+
+    def readpartial(maxlen, outbuf = nil)
+      raise NotImplementedError
+    end
+
+    def atime
+      raise NotImplementedError
+    end
+
+    def chmod(mode_int)
+      raise NotImplementedError
+    end
+
+    def chown(owner_int, group_int)
+      raise NotImplementedError
+    end
+
+    def ctime
+      raise NotImplementedError
+    end
+
+    def flock(locking_constant)
+      raise NotImplementedError
+    end
+
+    def lstat
+      raise NotImplementedError
+    end
+
+    def mtime
+      raise NotImplementedError
+    end
+
+    if RUBY_VERSION.to_f >= 1.9
+      def binmode?
+        raise NotImplementedError
+      end
+
+      def close_on_exec=(bool)
+        raise NotImplementedError
+      end
+
+      def close_on_exec?
+        raise NotImplementedError
+      end
+
+      def to_path
+        raise NotImplementedError
+      end
+    end
+
+  private
+
+    def check_modes!
+      StringIO.new("", @mode)
+    end
+
+    def check_file_existence!
+      unless @file
+        raise Errno::ENOENT, "No such file or directory - #{@file}"
+      end
+    end
+
+    def file_creation_mode?
+      mode_in?(FILE_CREATION_MODES) || mode_in_bitmask?(FILE_CREATION_BITMASK)
+    end
+
+    def mode_in?(list)
+      list.any? { |element| @mode.include?(element) } if @mode.respond_to?(:include?)
+    end
+
+    def mode_in_bitmask?(mask)
+      (@mode & mask) != 0 if @mode.is_a?(Integer)
+    end
+
+    def create_missing_file
+      if !File.exists?(@path)
+        @file = FileSystem.add(path, FakeFile.new)
+      end
+    end
+  end
+end

data/vendor/fakefs/lib/fakefs/file_system.rb

@@ -0,0 +1,136 @@
+module FakeFS
+  module FileSystem
+    extend self
+
+    def dir_levels
+      @dir_levels ||= []
+    end
+
+    def fs
+      @fs ||= FakeDir.new('.')
+    end
+
+    def clear
+      @dir_levels = nil
+      @fs = nil
+    end
+
+    def files
+      fs.values
+    end
+
+    def find(path)
+      parts = path_parts(normalize_path(path))
+      return fs if parts.empty? # '/'
+
+      entries = find_recurser(fs, parts).flatten
+
+      case entries.length
+      when 0 then nil
+      when 1 then entries.first
+      else entries
+      end
+    end
+
+    def add(path, object=FakeDir.new)
+      parts = path_parts(normalize_path(path))
+
+      d = parts[0...-1].inject(fs) do |dir, part|
+        dir[part] ||= FakeDir.new(part, dir)
+      end
+
+      object.name = parts.last
+      object.parent = d
+      d[parts.last] ||= object
+    end
+
+    # copies directories and files from the real filesystem
+    # into our fake one
+    def clone(path)
+      path    = File.expand_path(path)
+      pattern = File.join(path, '**', '*')
+      files   = RealFile.file?(path) ? [path] : [path] + RealDir.glob(pattern, RealFile::FNM_DOTMATCH)
+
+      files.each do |f|
+        if RealFile.file?(f)
+          FileUtils.mkdir_p(File.dirname(f))
+          File.open(f, File::WRITE_ONLY) do |g|
+            g.print RealFile.open(f){|h| h.read }
+          end
+        elsif RealFile.directory?(f)
+          FileUtils.mkdir_p(f)
+        elsif RealFile.symlink?(f)
+          FileUtils.ln_s()
+        end
+      end
+    end
+
+    def delete(path)
+      if node = FileSystem.find(path)
+        node.delete
+      end
+    end
+
+    def chdir(dir, &blk)
+      new_dir = find(dir)
+      dir_levels.push dir if blk
+
+      raise Errno::ENOENT, dir unless new_dir
+
+      dir_levels.push dir if !blk
+      blk.call if blk
+    ensure
+      dir_levels.pop if blk
+    end
+
+    def path_parts(path)
+      path.split(File::PATH_SEPARATOR).reject { |part| part.empty? }
+    end
+
+    def normalize_path(path)
+      if Pathname.new(path).absolute?
+        File.expand_path(path)
+      else
+        parts = dir_levels + [path]
+        File.expand_path(File.join(*parts))
+      end
+    end
+
+    def current_dir
+      find(normalize_path('.'))
+    end
+
+    private
+
+    def find_recurser(dir, parts)
+      return [] unless dir.respond_to? :[]
+
+      pattern , *parts = parts
+      matches = case pattern
+      when '**'
+        case parts
+        when ['*'], []
+          parts = [] # end recursion
+          directories_under(dir).map do |d|
+            d.values.select{|f| f.is_a? FakeFile }
+          end.flatten.uniq
+        else
+          directories_under(dir)
+        end
+      else
+        dir.reject {|k,v| /\A#{pattern.gsub('?','.').gsub('*', '.*')}\Z/ !~ k }.values
+      end
+
+      if parts.empty? # we're done recursing
+        matches
+      else
+        matches.map{|entry| find_recurser(entry, parts) }
+      end
+    end
+
+    def directories_under(dir)
+      children = dir.values.select{|f| f.is_a? FakeDir}
+      ([dir] + children + children.map{|c| directories_under(c)}).flatten.uniq
+    end
+  end
+end

data/vendor/fakefs/lib/fakefs/fileutils.rb

@@ -0,0 +1,129 @@
+module FakeFS
+  module FileUtils
+    extend self
+
+    def mkdir_p(path)
+      FileSystem.add(path, FakeDir.new)
+    end
+    alias_method :mkpath, :mkdir_p
+
+    def rmdir(list, options = {})
+      list = [ list ] unless list.is_a?(Array)
+      list.each do |l|
+        parent = l.split('/')
+        parent.pop
+        raise Errno::ENOENT, "No such file or directory - #{l}" unless parent.join == "" || FileSystem.find(parent.join('/'))
+        raise Errno::ENOENT, l unless FileSystem.find(l)
+        raise Errno::ENOTEMPTY, l unless FileSystem.find(l).values.empty?
+        rm(l)
+      end
+    end
+
+    def rm(path)
+      FileSystem.delete(path)
+    end
+
+    alias_method :rm_rf, :rm
+    alias_method :rm_r, :rm
+    alias_method :rm_f, :rm
+
+    def ln_s(target, path, options = {})
+      options = { :force => false }.merge(options)
+      (FileSystem.find(path) and !options[:force]) ? raise(Errno::EEXIST, path) : FileSystem.delete(path)
+      FileSystem.add(path, FakeSymlink.new(target))
+    end
+    def ln_sf(target, path)
+      ln_s(target, path, { :force => true })
+    end
+
+
+
+    def cp(src, dest)
+      dst_file = FileSystem.find(dest)
+      src_file = FileSystem.find(src)
+
+      if !src_file
+        raise Errno::ENOENT, src
+      end
+
+      if File.directory? src_file
+        raise Errno::EISDIR, src
+      end
+
+      if dst_file && File.directory?(dst_file)
+        FileSystem.add(File.join(dest, src), src_file.entry.clone(dst_file))
+      else
+        FileSystem.delete(dest)
+        FileSystem.add(dest, src_file.entry.clone)
+      end
+    end
+
+    def cp_r(src, dest)
+      # This error sucks, but it conforms to the original Ruby
+      # method.
+      raise "unknown file type: #{src}" unless dir = FileSystem.find(src)
+
+      new_dir = FileSystem.find(dest)
+
+      if new_dir && !File.directory?(dest)
+        raise Errno::EEXIST, dest
+      end
+
+      if !new_dir && !FileSystem.find(dest+'/../')
+        raise Errno::ENOENT, dest
+      end
+
+      # This last bit is a total abuse and should be thought hard
+      # about and cleaned up.
+      if new_dir
+        if src[-2..-1] == '/.'
+          dir.values.each{|f| new_dir[f.name] = f.clone(new_dir) }
+        else
+          new_dir[dir.name] = dir.entry.clone(new_dir)
+        end
+      else
+        FileSystem.add(dest, dir.entry.clone)
+      end
+    end
+
+    def mv(src, dest)
+      if target = FileSystem.find(src)
+        FileSystem.add(dest, target.entry.clone)
+        FileSystem.delete(src)
+      else
+        raise Errno::ENOENT, src
+      end
+    end
+
+    def chown(user, group, list, options={})
+      list = Array(list)
+      list.each do |f|
+        unless File.exists?(f)
+          raise Errno::ENOENT, f
+        end
+      end
+      list
+    end
+
+    def chown_R(user, group, list, options={})
+      chown(user, group, list, options={})
+    end
+
+    def touch(list, options={})
+      Array(list).each do |f|
+        directory = File.dirname(f)
+        # FIXME this explicit check for '.' shouldn't need to happen
+        if File.exists?(directory) || directory == '.'
+          FileSystem.add(f, FakeFile.new)
+        else
+          raise Errno::ENOENT, f
+        end
+      end
+    end
+
+    def cd(dir)
+      FileSystem.chdir(dir)
+    end
+    alias_method :chdir, :cd
+  end
+end

data/vendor/fakefs/lib/fakefs/safe.rb

@@ -0,0 +1,11 @@
+require 'fileutils'
+require 'pathname'
+require 'fakefs/base'
+require 'fakefs/fake/file'
+require 'fakefs/fake/dir'
+require 'fakefs/fake/symlink'
+require 'fakefs/file_system'
+require 'fakefs/fileutils'
+require 'fakefs/file'
+require 'fakefs/dir'
+

data/vendor/fakefs/lib/fakefs/spec_helpers.rb

@@ -0,0 +1,46 @@
+# FakeFS::SpecHelpers provides a simple macro for RSpec example groups to turn FakeFS on and off.
+# To use it simply require 'fakefs/spec_helpers', then include FakeFS::SpecHelpers into any
+# example groups that you wish to use FakeFS in. For example:
+#
+#   require 'fakefs/spec_helpers'
+#
+#   describe "Some specs that deal with files" do
+#     include FakeFS::SpecHelpers
+#     ...
+#   end
+#
+# Alternatively, you can include FakeFS::SpecHelpers in all your example groups using RSpec's
+# configuration block in your spec helper:
+#
+#   require 'fakefs/spec_helpers'
+#
+#   Spec::Runner.configure do |config|
+#     config.include FakeFS::SpecHelpers
+#   end
+#
+# If you do the above then use_fakefs will be available in all of your example groups.
+#
+require 'fakefs/safe'
+
+module FakeFS
+  module SpecHelpers
+    def self.extended(example_group)
+      example_group.use_fakefs(example_group)
+    end
+
+    def self.included(example_group)
+      example_group.extend self
+    end
+
+    def use_fakefs(describe_block)
+      describe_block.before :each do
+        FakeFS.activate!
+      end
+
+      describe_block.after :each do
+        FakeFS.deactivate!
+        FakeFS::FileSystem.clear
+      end
+    end
+  end
+end

data/vendor/fakefs/lib/fakefs/version.rb

@@ -0,0 +1,9 @@
+module FakeFS
+  module Version
+    VERSION = "0.2.1"
+
+    def self.to_s
+      VERSION
+    end
+  end
+end

data/vendor/fakefs/lib/fakefs.rb

@@ -0,0 +1,3 @@
+require 'fakefs/safe'
+
+FakeFS.activate!

data/vendor/fakefs/spec/fakefs/spec_helpers_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module FakeFS
+  describe SpecHelpers do
+    before do
+      @rspec_example_group = Class.new do
+        def self.before(sym = :each)
+          yield if block_given?
+        end
+
+        def self.after(sym = :each)
+          yield if block_given?
+        end
+      end
+    end
+
+    describe "when extending" do
+      context "before each" do
+        it "should call it" do
+          @rspec_example_group.should_receive(:before).with(:each)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should call FakeFS.activate!" do
+          FakeFS.should_receive(:activate!)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+      end
+
+      context "after each" do
+        it "should call it" do
+          @rspec_example_group.should_receive(:after).with(:each)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should deactivate fakefs" do
+          FakeFS.should_receive(:deactivate!)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should clear the fakefs filesystem for the next run" do
+          FakeFS::FileSystem.should_receive(:clear)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+      end
+    end
+
+    describe "when including" do
+      it "should call before :each" do
+        @rspec_example_group.should_receive(:before)
+        @rspec_example_group.class_eval do
+          include FakeFS::SpecHelpers
+        end
+      end
+    end
+  end
+end