Sutto-perennial 1.0.0.0 → 1.0.0.1

data/test/proxy_test.rb

@@ -1,30 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-class ProxyTest < Test::Unit::TestCase
-  
-  context 'basic proxies' do
-    
-    setup do
-      @proxy = Perennial::Proxy.new
-      @proxy.__proxy_target__ = :awesome
-    end    
-    should 'pass through the correct class' do
-      assert_equal Symbol, @proxy.class
-      assert_kind_of Symbol, @proxy
-    end
-    
-    should 'not interfere with equals' do
-      assert @proxy  == :awesome
-    end
-    
-    should 'pass through to_s' do
-      assert_equal "awesome", @proxy.to_s
-    end
-    
-    should 'let you send to an object' do
-      assert_equal "awesome", @proxy.send(:to_s)
-    end
-    
-  end
-  
-end

data/test/settings_test.rb

@@ -1,103 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-class SettingsTest < Test::Unit::TestCase
-  
-  context 'default settings' do
-    
-    setup do
-      Perennial::Settings.setup!
-    end
-    
-    should "default the application root to the parent folder of perennial" do
-      assert_equal __FILE__.to_pathname.dirname.join("..").expand_path,
-                   Perennial::Settings.root.to_pathname
-      Perennial::Settings.root = "/awesome/sauce"
-      assert_equal "/awesome/sauce", Perennial::Settings.root
-    end
-    
-    should "default daemonized to false" do
-      assert !Perennial::Settings.daemon?
-      Perennial::Settings.daemon = true
-      assert Perennial::Settings.daemon?
-      Perennial::Settings.daemon = false
-      assert !Perennial::Settings.daemon?
-    end
-    
-    should "default the log level to :info" do
-      assert_equal :info, Perennial::Settings.log_level
-      Perennial::Settings.log_level = :debug
-      assert_equal :debug, Perennial::Settings.log_level
-    end
-    
-    should "default verbose to false" do
-      assert !Perennial::Settings.verbose?
-      Perennial::Settings.verbose = true
-      assert Perennial::Settings.verbose?
-      Perennial::Settings.verbose = false
-      assert !Perennial::Settings.verbose?
-    end
-    
-  end
-  
-  context 'loading settings' do
-    
-    setup do
-      config_folder = Perennial::Settings.root / "config"
-      @default_settings = {
-        "default" => {
-          "introduction" => true,
-          "description"  => "Ninjas are Totally Awesome",
-          "channel"      => "#offrails",
-          "users"        => ["Sutto", "njero", "zapnap"]
-        }
-      }
-      FileUtils.mkdir_p(config_folder)
-      File.open(config_folder / "settings.yml", "w+") do |file|
-        file.write(@default_settings.to_yaml)
-      end
-      Perennial::Settings.setup!
-    end
-    
-    should 'load settings from the file' do
-      assert Perennial::Settings.setup?
-      assert_equal @default_settings["default"].symbolize_keys, Perennial::Settings.to_hash
-    end
-    
-    should 'define readers for the settings' do
-      instance = Perennial::Settings.new
-      @default_settings["default"].each_pair do |key, value|
-        assert Perennial::Settings.respond_to?(key.to_sym)
-        assert_equal value, Perennial::Settings.send(key)
-        assert instance.respond_to?(key.to_sym)
-        assert_equal value, instance.send(key)
-      end
-    end
-    
-    should 'let you access settings via hash-style accessors' do
-      @default_settings["default"].each_pair do |key, value|
-        assert_equal value, Perennial::Settings[key]
-        Perennial::Settings[key] = "a-new-value from #{value.inspect}"
-        assert_equal "a-new-value from #{value.inspect}", Perennial::Settings[key]
-      end
-    end
-    
-    should 'define writers for the settings' do
-      instance = Perennial::Settings.new
-      @default_settings["default"].each_pair do |key, value|
-        setter = :"#{key}="
-        assert Perennial::Settings.respond_to?(setter)
-        Perennial::Settings.send(setter, "value #{value.inspect} on class")
-        assert_equal "value #{value.inspect} on class", Perennial::Settings.send(key)
-        assert instance.respond_to?(setter)
-        instance.send(setter, "value #{value.inspect} on instance")
-        assert_equal "value #{value.inspect} on instance", instance.send(key)
-      end
-    end
-    
-    should 'let you configure the lookup key path'
-    
-    should 'let you configure the file settings are loaded from'
-    
-  end
-  
-end

data/test/test_helper.rb

@@ -1,38 +0,0 @@
-require 'rubygems'
-
-# Testing dependencies
-require 'test/unit'
-require 'shoulda'
-require 'rr'
-# RedGreen doesn't seem to be needed under 1.9
-require 'redgreen' if RUBY_VERSION < "1.9"
-
-require 'pathname'
-root_directory = Pathname.new(__FILE__).dirname.join("..").expand_path
-require root_directory.join("lib", "perennial")
-require root_directory.join("vendor", "fakefs", "lib", "fakefs")
-
-class Test::Unit::TestCase
-  include RR::Adapters::TestUnit
-  
-  protected
-  
-  # Short hand for creating a class with
-  # a given class_eval block.
-  def class_via(*args, &blk)
-    klass = Class.new(*args)
-    klass.class_eval(&blk) unless blk.blank?
-    return klass
-  end
-  
-  # Short hand for creating a test class
-  # for a set of mixins - give it the modules
-  # and it will include them all.
-  def test_class_for(*mods, &blk)
-    klass = Class.new
-    klass.class_eval { include(*mods) }
-    klass.class_eval(&blk) unless blk.blank?
-    return klass
-  end
-  
-end

data/vendor/fakefs/LICENSE

@@ -1,20 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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.
-
-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.
-
-Authors
--------
-
-Chris Wanstrath [chris@ozmm.org]

data/vendor/fakefs/Rakefile

@@ -1,3 +0,0 @@
-task :default do
-  exec "ruby test/fakefs_test.rb"
-end

data/vendor/fakefs/lib/fakefs.rb

@@ -1,448 +0,0 @@
-require 'fileutils'
-require 'pathname'
-
-RealFile = File
-RealFileUtils = FileUtils
-RealDir = Dir
-RealFileUtils::Dir = RealDir
-RealFileUtils::File = RealFile
-
-module FakeFS
-  module FileUtils
-    extend self
-
-    def mkdir_p(path)
-      FileSystem.add(path, MockDir.new)
-    end
-
-    def rm(path)
-      FileSystem.delete(path)
-    end
-    alias_method :rm_rf, :rm
-
-    def ln_s(target, path)
-      raise Errno::EEXIST, path if FileSystem.find(path)
-      FileSystem.add(path, MockSymlink.new(target))
-    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 and 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, MockFile.new)
-        else
-          raise Errno::ENOENT, f
-        end
-      end
-    end
-  end
-
-  class File
-    PATH_SEPARATOR = '/'
-
-    def self.join(*parts)
-      parts * PATH_SEPARATOR
-    end
-
-    def self.exist?(path)
-      FileSystem.find(path) || false
-    end
-
-    class << self
-      alias_method :exists?, :exist?
-    end
-
-    def self.directory?(path)
-      if path.respond_to? :entry
-        path.entry.is_a? MockDir
-      else
-        result = FileSystem.find(path)
-        result ? result.entry.is_a?(MockDir) : false
-      end
-    end
-
-    def self.symlink?(path)
-      if path.respond_to? :entry
-        path.is_a? MockSymlink
-      else
-        FileSystem.find(path).is_a? MockSymlink
-      end
-    end
-
-    def self.file?(path)
-      if path.respond_to? :entry
-        path.entry.is_a? MockFile
-      else
-        result = FileSystem.find(path)
-        result ? result.entry.is_a?(MockFile) : 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.open(path, mode='r')
-      if block_given?
-        yield new(path, mode)
-      else
-        new(path, mode)
-      end
-    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
-
-    attr_reader :path
-    def initialize(path, mode = nil)
-      @path = path
-      @mode = mode
-      @file = FileSystem.find(path)
-      @open = true
-    end
-
-    def close
-      @open = false
-    end
-
-    def read
-      raise IOError.new('closed stream') unless @open
-      @file.content
-    end
-
-    def exists?
-      @file
-    end
-
-    def puts(content)
-      write(content + "\n")
-    end
-
-    def write(content)
-      raise IOError.new('closed stream') unless @open
-
-      if !File.exists?(@path)
-        @file = FileSystem.add(path, MockFile.new)
-      end
-
-      @file.content += content
-    end
-    alias_method :print, :write
-    alias_method :<<, :write
-
-    def flush; self; end
-  end
-
-  class Dir
-    def self.glob(pattern)
-      if pattern[-1,1] == '*'
-        blk = proc { |entry| entry.to_s }
-      else
-        blk = proc { |entry| entry[1].parent.to_s }
-      end
-      (FileSystem.find(pattern) || []).map(&blk).uniq.sort
-    end
-
-    def self.[](pattern)
-      glob(pattern)
-    end
-
-    def self.chdir(dir, &blk)
-      FileSystem.chdir(dir, &blk)
-    end
-  end
-
-  module FileSystem
-    extend self
-
-    def dir_levels
-      @dir_levels ||= []
-    end
-
-    def fs
-      @fs ||= MockDir.new('.')
-    end
-
-    def clear
-      @dir_levels = nil
-      @fs = nil
-    end
-
-    def files
-      fs.values
-    end
-
-    def find(path)
-      parts = path_parts(normalize_path(path))
-
-      target = parts[0...-1].inject(fs) do |dir, part|
-        dir[part] || {}
-      end
-
-      case parts.last
-      when '*'
-        target.values
-      else
-        target[parts.last]
-      end
-    end
-
-    def add(path, object=MockDir.new)
-      parts = path_parts(normalize_path(path))
-
-      d = parts[0...-1].inject(fs) do |dir, part|
-        dir[part] ||= MockDir.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, 'w') 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 dir = FileSystem.find(path)
-        dir.parent.delete(dir.name)
-      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
-  end
-
-  class MockFile
-    attr_accessor :name, :parent, :content
-
-    def initialize(name = nil, parent = nil)
-      @name = name
-      @parent = parent
-      @content = ''
-    end
-
-    def clone(parent = nil)
-      clone = super()
-      clone.parent = parent if parent
-      clone
-    end
-
-    def entry
-      self
-    end
-
-    def inspect
-      "(MockFile name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{content.size})"
-    end
-
-    def to_s
-      File.join(parent.to_s, name)
-    end
-  end
-
-  class MockDir < Hash
-    attr_accessor :name, :parent
-
-    def initialize(name = nil, parent = nil)
-      @name = name
-      @parent = parent
-    end
-
-    def entry
-      self
-    end
-
-    def inspect
-      "(MockDir 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
-  end
-
-  class MockSymlink
-    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 method_missing(*args, &block)
-      entry.send(*args, &block)
-    end
-  end
-end
-
-Object.class_eval do
-  remove_const(:Dir)
-  remove_const(:File)
-  remove_const(:FileUtils)
-end
-
-File = FakeFS::File
-FileUtils = FakeFS::FileUtils
-Dir = FakeFS::Dir