Sutto-perennial 0.1.0

data/test/logger_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class LoggerTest < Test::Unit::TestCase
+  context 'logger tests' do
+    
+    setup do
+      @root_path = Perennial::Settings.root / "log"
+      Perennial::Logger.log_name = "example.log"
+      FileUtils.mkdir_p @root_path
+    end
+  
+    context 'setting up a logger' do
+    
+      setup { Perennial::Logger.setup! }
+    
+      should 'create the log file file after writing' do
+        Perennial::Logger.fatal "Blergh."
+        assert File.exist?(@root_path / "example.log")
+      end
+    
+      Perennial::Logger::LEVELS.each_key do |level_name|
+        should "define a method for the #{level_name} log level" do
+          assert Perennial::Logger.respond_to?(level_name)
+          assert Perennial::Logger.logger.respond_to?(level_name)
+          assert_equal 1, Perennial::Logger.logger.method(level_name).arity
+        end
+      end
+    
+      should 'have a log exception method' do
+        assert Perennial::Logger.respond_to?(:log_exception)
+        assert Perennial::Logger.logger.respond_to?(:log_exception)
+      end
+    
+    end
+  
+    context 'writing to the log' do
+      
+      Perennial::Logger::LEVELS.each_key do |level_name|
+        should "let you write to the #{level_name} log level" do
+          Perennial::Logger.verbose = false
+          Perennial::Logger.level = level_name
+          assert_nothing_raised do
+            Perennial::Logger.logger.send(level_name, "An Example Message No. 1")
+          end
+        end
+      end
+      
+    end
+  
+    teardown do
+      log_path = @root_path / "example.log"
+      FileUtils.rm_rf(log_path) if File.exist?(log_path)
+    end
+    
+  end
+  
+end

data/test/settings_test.rb

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

data/test/test_helper.rb

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

@@ -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,37 @@
+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

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

data/vendor/fakefs/lib/fakefs.rb

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