simple-templater 0.0.1

data/vendor/erubis/test/test-users-guide.rb

@@ -0,0 +1,58 @@
+###
+### $Rev: 115 $
+### $Release: 2.6.2 $
+### copyright(c) 2006-2008 kuwata-lab.com all rights reserved.
+###
+
+require  "#{File.dirname(__FILE__)}/test.rb"
+
+
+class KwarkUsersGuideTest < Test::Unit::TestCase
+
+  DIR = File.expand_path(File.dirname(__FILE__) + '/data/users-guide')
+  CWD = Dir.pwd()
+
+
+  def setup
+    Dir.chdir DIR
+  end
+
+
+  def teardown
+    Dir.chdir CWD
+  end
+
+
+  def _test
+    @name = (caller()[0] =~ /`(.*?)'/) && $1
+    s = File.read(@filename)
+    s =~ /\A\$ (.*?)\n/
+    command = $1
+    expected = $'
+    result = `#{command}`
+    assert_text_equal(expected, result)
+  end
+
+
+  Dir.chdir DIR do
+    filenames = []
+    filenames += Dir.glob('*.result')
+    filenames += Dir.glob('*.source')
+    filenames.each do |filename|
+      name = filename.gsub(/[^\w]/, '_')
+      s = <<-END
+        def test_#{name}
+          # $stderr.puts "*** debug: test_#{name}"
+          @name = '#{name}'
+          @filename = '#{filename}'
+          _test()
+        end
+      END
+      eval s
+    end
+  end
+
+
+  self.post_definition()
+
+end

data/vendor/erubis/test/test.rb

@@ -0,0 +1,30 @@
+##
+## $Rev: 77 $
+## $Release: 2.6.2 $
+## copyright(c) 2006-2008 kuwata-lab.com all rights reserved.
+##
+
+
+unless defined?(TESTDIR)
+  TESTDIR = File.dirname(__FILE__)
+  LIBDIR  = TESTDIR == '.' ? '../lib' : File.dirname(TESTDIR) + '/lib'
+  $: << TESTDIR
+  $: << LIBDIR
+end
+
+
+require 'test/unit'
+#require 'test/unit/ui/console/testrunner'
+require 'assert-text-equal'
+require 'yaml'
+require 'testutil'
+require 'erubis'
+
+
+if $0 == __FILE__
+  require "#{TESTDIR}/test-erubis.rb"
+  require "#{TESTDIR}/test-engines.rb"
+  require "#{TESTDIR}/test-enhancers.rb"
+  require "#{TESTDIR}/test-main.rb"
+  require "#{TESTDIR}/test-users-guide.rb"
+end

data/vendor/erubis/test/testutil.rb

@@ -0,0 +1,101 @@
+###
+### $Rev: 116 $
+### $Release: 2.6.2 $
+### copyright(c) 2006-2008 kuwata-lab.com all rights reserved.
+###
+
+require 'yaml'
+
+require 'test/unit/testcase'
+
+
+
+def _ruby_ver_str  # :nodoc:
+  return /\d+\.\d+/.match(RUBY_VERSION)[0]
+end
+
+def ruby18?  # :nodoc:
+  _ruby_ver_str() == "1.8"
+end
+
+def ruby19?  # :nodoc:
+  _ruby_ver_str() > "1.8"
+end
+
+
+
+class Test::Unit::TestCase
+
+
+  def self.load_yaml_datafile(filename, options={}, &block)  # :nodoc:
+    # read datafile
+    s = File.read(filename)
+    if filename =~ /\.rb$/
+      s =~ /^__END__$/   or raise "*** error: __END__ is not found in '#{filename}'."
+      s = $'
+    end
+    # untabify
+    unless options[:tabify] == false
+      s = s.split(/^/).inject('') do |sb, line|
+        sb << line.gsub(/([^\t]{8})|([^\t]*)\t/n) { [$+].pack("A8") }
+      end
+    end
+    # load yaml document
+    testdata_list = []
+    YAML.load_documents(s) do |ydoc|
+      if ydoc.is_a?(Hash)
+        testdata_list << ydoc
+      elsif ydoc.is_a?(Array)
+        ydoc.each do |hash|
+          raise "testdata should be a mapping." unless hash.is_a?(Hash)
+          testdata_list << hash
+        end
+      else
+        raise "testdata should be a mapping."
+      end
+    end
+    # data check
+    identkey = options[:identkey] || 'name'
+    table = {}
+    testdata_list.each do |hash|
+      ident = hash[identkey]
+      ident          or  raise "*** key '#{identkey}' is required but not found."
+      table[ident]   and raise "*** #{identkey} '#{ident}' is duplicated."
+      table[ident] = hash
+      yield(hash) if block
+    end
+    #
+    return testdata_list
+  end
+
+
+  def self.define_testmethods(testdata_list, options={}, &block)
+    identkey   = options[:identkey]   || 'name'
+    testmethod = options[:testmethod] || '_test'
+    testdata_list.each do |hash|
+      yield(hash) if block
+      ident = hash[identkey]
+      s  =   "def test_#{ident}\n"
+      hash.each do |key, val|
+        s << "  @#{key} = #{val.inspect}\n"
+      end
+      s  <<  "  #{testmethod}\n"
+      s  <<  "end\n"
+      $stderr.puts "*** load_yaml_testdata(): eval_str=<<'END'\n#{s}END" if $DEBUG
+      self.module_eval s
+    end
+  end
+
+
+  def self.post_definition
+    if ENV['TEST']
+      target = "test_#{ENV['TEST']}"
+      self.instance_methods.each do |method_name|
+        m = method_name.to_s
+        private m if m =~ /\Atest_/ && m != target
+      end
+    end
+  end
+
+
+end

data/vendor/fakefs/CONTRIBUTORS

@@ -0,0 +1,17 @@
+* Chris Wanstrath
+* Scott Taylor
+* Jeff Hodges
+* Pat Nakajima
+* Myles Eftos
+* Matt Freels
+* Nick Quaranto
+* Tymon Tobolski
+* Ben Mabey
+* Jon Yurek
+* Scott Barron
+* dmathieu
+* Rob Sanheim
+* David Reese
+* msassak
+* Sam Goldstein
+* jameswilding

data/vendor/fakefs/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/fakefs/README.markdown

@@ -0,0 +1,101 @@
+FakeFS
+======
+
+Mocha is great. But when your library is all about manipulating the
+filesystem, you really want to test the behavior and not the implementation.
+
+If you're mocking and stubbing every call to FileUtils or File, you're
+tightly coupling your tests with the implementation.
+
+    def test_creates_directory
+      FileUtils.expects(:mkdir).with("directory").once
+      Library.add "directory"
+    end
+
+The above test will break if we decide to use `mkdir_p` in our code. Refactoring
+code shouldn't necessitate refactoring tests.
+
+With FakeFS:
+
+    def test_creates_directory
+      Library.add "directory"
+      assert File.directory?("directory")
+    end
+
+Woot.
+
+
+Usage
+-----
+
+    require 'fakefs'
+
+    # That's it.
+
+
+Don't Fake the FS Immediately
+-----------------------------
+
+    require 'fakefs/safe'
+
+    FakeFS.activate!
+    # your code
+    FakeFS.deactivate!
+
+    # or
+    FakeFS do
+      # your code
+    end
+
+
+RSpec
+-----------------------------
+The above approach works with RSpec as well. In addition to this you may use the
+'use_fakefs' macro to turn FakeFS on and off in a given example group.  See
+lib/spec_helpers for more details on it's usage.
+
+
+How is this different than MockFS?
+----------------------------------
+
+FakeFS provides a test suite and works with symlinks. It's also strictly a
+test-time dependency: your actual library does not need to use or know about
+FakeFS.
+
+
+Caveats
+-------
+
+FakeFS internally uses the `Pathname` and `FileUtils` constants. If you use
+these in your app, be certain you're properly requiring them and not counting
+on FakeFS' own require.
+
+
+Speed?
+------
+<http://gist.github.com/156091>
+
+
+Installation
+------------
+
+### [Gemcutter](http://gemcutter.org/)
+
+    $ gem install fakefs
+
+### [Rip](http://hellorip.com)
+
+    $ rip install git://github.com/defunkt/fakefs.git
+
+
+Meta
+----
+
+* Code: `git clone git://github.com/defunkt/fakefs.git`
+* Home: <http://github.com/defunkt/fakefs>
+* Docs: <http://defunkt.github.com/fakefs>
+* Bugs: <http://github.com/defunkt/fakefs/issues>
+* List: <http://groups.google.com/group/fakefs>
+* Test: <http://runcoderun.com/defunkt/fakefs>
+* Gems: <http://gemcutter.org/gems/fakefs>
+* Boss: Chris Wanstrath :: <http://github.com/defunkt>

data/vendor/fakefs/Rakefile

@@ -0,0 +1,47 @@
+desc "Run tests"
+task :test do
+  Dir['test/**/*_test.rb'].each { |file| require file }
+end
+
+task :default => :test
+
+begin
+  require 'jeweler'
+
+  $LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+  require 'fakefs/version'
+
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "fakefs"
+    gemspec.summary = "A fake filesystem. Use it in your tests."
+    gemspec.email = "chris@ozmm.org"
+    gemspec.homepage = "http://github.com/defunkt/fakefs"
+    gemspec.description = "A fake filesystem. Use it in your tests."
+    gemspec.authors = ["Chris Wanstrath"]
+    gemspec.has_rdoc = false
+    gemspec.version = FakeFS::Version.to_s
+  end
+rescue LoadError
+  puts "Jeweler not available."
+  puts "Install it with: gem install jeweler"
+end
+
+begin
+  require 'sdoc_helpers'
+rescue LoadError
+  puts "sdoc support not enabled. Please gem install sdoc-helpers."
+end
+
+desc "Build a gem"
+task :gem => [ :gemspec, :build ]
+
+desc "Push a new version to Gemcutter"
+task :publish => [ :gemspec, :build ] do
+  abort("Tests failed!") unless system("rake test")
+  system "git tag v#{FakeFS::Version}"
+  system "git push origin v#{FakeFS::Version}"
+  system "git push origin master"
+  system "gem push pkg/fakefs-#{FakeFS::Version}.gem"
+  system "git clean -fd"
+  exec "rake pages"
+end

data/vendor/fakefs/lib/fakefs/base.rb

@@ -0,0 +1,38 @@
+RealFile = File
+RealFileUtils = FileUtils
+RealDir = Dir
+RealFileUtils::Dir = RealDir
+RealFileUtils::File = RealFile
+
+module FakeFS
+  def self.activate!
+    Object.class_eval do
+      remove_const(:Dir)
+      remove_const(:File)
+      remove_const(:FileUtils)
+      const_set(:Dir, FakeFS::Dir)
+      const_set(:File, FakeFS::File)
+      const_set(:FileUtils, FakeFS::FileUtils)
+    end
+  end
+
+  def self.deactivate!
+    Object.class_eval do
+      remove_const(:Dir)
+      remove_const(:File)
+      remove_const(:FileUtils)
+      const_set(:Dir, RealDir)
+      const_set(:File, RealFile)
+      const_set(:FileUtils, RealFileUtils)
+    end
+  end
+end
+
+def FakeFS
+  return ::FakeFS unless block_given?
+  ::FakeFS.activate!
+  yield
+ensure
+::FakeFS.deactivate!
+end
+

data/vendor/fakefs/lib/fakefs/dir.rb

@@ -0,0 +1,114 @@
+module FakeFS
+  class Dir
+    include Enumerable
+
+    def initialize(string)
+      raise Errno::ENOENT, string unless FileSystem.find(string)
+      @path = string
+      @open = true
+      @pointer = 0
+      @contents = [ '.', '..', ] + FileSystem.find(@path).values
+    end
+
+    def close
+      @open = false
+      @pointer = nil
+      @contents = nil
+      nil
+    end
+
+    def each(&block)
+      while f = read
+        yield f
+      end
+    end
+
+    def path
+      @path
+    end
+
+    def pos
+      @pointer
+    end
+
+    def pos=(integer)
+      @pointer = integer
+    end
+
+    def read
+      raise IOError, "closed directory" if @pointer == nil
+      n = @contents[@pointer]
+      @pointer += 1
+      n.to_s.gsub(path + '/', '') if n
+    end
+
+    def rewind
+      @pointer = 0
+    end
+
+    def seek(integer)
+      raise IOError, "closed directory" if @pointer == nil
+      @pointer = integer
+      @contents[integer]
+    end
+
+    def self.[](pattern)
+      glob(pattern)
+    end
+
+    def self.chdir(dir, &blk)
+      FileSystem.chdir(dir, &blk)
+    end
+
+    def self.chroot(string)
+      # Not implemented yet
+    end
+
+    def self.delete(string)
+      raise SystemCallError, "No such file or directory - #{string}" unless FileSystem.find(string).values.empty?
+      FileSystem.delete(string)
+    end
+
+    def self.entries(dirname)
+      raise SystemCallError, dirname unless FileSystem.find(dirname)
+      Dir.new(dirname).map { |file| File.basename(file) }
+    end
+
+    def self.foreach(dirname, &block)
+      Dir.open(dirname) { |file| yield file }
+    end
+
+    def self.glob(pattern)
+      [FileSystem.find(pattern) || []].flatten.map{|e| e.to_s}.sort
+    end
+
+    def self.mkdir(string, integer = 0)
+      parent = string.split('/')
+      parent.pop
+      raise Errno::ENOENT, "No such file or directory - #{string}" unless parent.join == "" || FileSystem.find(parent.join('/'))
+      FileUtils.mkdir_p(string)
+    end
+
+    def self.open(string, &block)
+      if block_given?
+        Dir.new(string).each { |file| yield(file) }
+      else
+        Dir.new(string)
+      end
+    end
+
+    def self.tmpdir
+      '/tmp'
+    end
+
+    def self.pwd
+      FileSystem.current_dir.to_s
+    end
+
+    class << self
+      alias_method :getwd, :pwd
+      alias_method :rmdir, :delete
+      alias_method :unlink, :delete
+    end
+  end
+end

data/vendor/fakefs/lib/fakefs/fake/dir.rb

@@ -0,0 +1,45 @@
+module FakeFS
+  class FakeDir < Hash
+    attr_accessor :name, :parent
+
+    def initialize(name = nil, parent = nil)
+      @name = name
+      @parent = parent
+    end
+
+    def entry
+      self
+    end
+
+    def inspect
+      "(FakeDir name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{size})"
+    end
+
+    def clone(parent = nil)
+      clone = Marshal.load(Marshal.dump(self))
+      clone.each do |key, value|
+        value.parent = clone
+      end
+      clone.parent = parent if parent
+      clone
+    end
+
+    def to_s
+      if parent && parent.to_s != '.'
+        File.join(parent.to_s, name)
+      elsif parent && parent.to_s == '.'
+        "#{File::PATH_SEPARATOR}#{name}"
+      else
+        name
+      end
+    end
+
+    def delete(node = self)
+      if node == self
+        parent.delete(self)
+      else
+        super(node.name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module FakeFS
+  class FakeFile
+    attr_accessor :name, :parent, :content, :mtime
+
+    class Inode
+      def initialize(file_owner)
+        @content = ""
+        @links   = [file_owner]
+      end
+
+      attr_accessor :content
+      attr_accessor :links
+
+      def link(file)
+        links << file unless links.include?(file)
+        file.inode = self
+      end
+
+      def unlink(file)
+        links.delete(file)
+      end
+
+      def clone
+        clone = super
+        clone.content = content.dup
+        clone
+      end
+    end
+
+    def initialize(name = nil, parent = nil)
+      @name   = name
+      @parent = parent
+      @inode  = Inode.new(self)
+      @mtime  = Time.now
+    end
+
+    attr_accessor :inode
+
+    def content
+      @inode.content
+    end
+
+    def content=(str)
+      @inode.content = str
+    end
+
+    def links
+      @inode.links
+    end
+
+    def link(other_file)
+      @inode.link(other_file)
+    end
+
+    def clone(parent = nil)
+      clone = super()
+      clone.parent = parent if parent
+      clone.inode  = inode.clone
+      clone
+    end
+
+    def entry
+      self
+    end
+
+    def inspect
+      "(FakeFile name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{content.size})"
+    end
+
+    def to_s
+      File.join(parent.to_s, name)
+    end
+
+    def delete
+      inode.unlink(self)
+      parent.delete(self)
+    end
+  end
+end

data/vendor/fakefs/lib/fakefs/fake/symlink.rb

@@ -0,0 +1,32 @@
+module FakeFS
+  class FakeSymlink
+    attr_accessor :name, :target
+    alias_method  :to_s, :name
+
+    def initialize(target)
+      @target = target
+    end
+
+    def inspect
+      "symlink(#{target.split('/').last})"
+    end
+
+    def entry
+      FileSystem.find(target)
+    end
+
+    def delete
+      parent.delete(self)
+    end
+
+    def respond_to?(method)
+      entry.respond_to?(method)
+    end
+
+  private
+
+    def method_missing(*args, &block)
+      entry.send(*args, &block)
+    end
+  end
+end