priest 0.0.7

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Michel Martens, Damian Janowski and Konstantin Haase
+
+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/README.markdown

@@ -0,0 +1,74 @@
+Monk
+====
+
+The glue framework for web development.
+
+Description
+-----------
+
+Monk is a glue framework for web development. It means that instead of
+installing all the tools you need for your projects, you can rely on a
+git repository and a list of dependencies, and Monk takes care of the
+rest. By default, it ships with a Sinatra application that includes
+Contest, Stories, Webrat, Ohm and some other niceties, along with a
+structure and helpful documentation to get your hands wet in no time.
+
+But Monk also respects your tastes, and you are invited to create your
+own versions of the skeleton app and your own list of dependencies. You
+can add many different templates (different git repositories) and Monk
+will help you manage them all.
+
+Priest is an extended monk commandline tool with functionallity not being
+accepted into mainline monk. It is however compatible with mainline glue
+and skeletons.
+
+Usage
+-----
+
+Install the monk gem and create your project:
+
+    $ sudo gem install rkh-priest
+    $ priest init myapp
+    $ cd myapp
+    $ rake
+
+If the tests pass, it means that you can start hacking right away. If
+they don't, just follow the instructions. As the default skeleton
+is very opinionated, you will probably need to install and run
+[Redis](http://code.google.com/p/redis/), a key-value database.
+
+Check the `dependencies` file in the root of your project to see what
+else is there. Monk works with git almost exclusively, but your project
+can also depend on gems. Check the dependencies file to see what options
+you have, and run the `dep` command line tool to verify it.
+
+Installation
+------------
+
+    $ sudo gem install rkh-monk
+
+License
+-------
+
+Copyright (c) 2009 Michel Martens, Damian Janowski and Konstantin Haase
+
+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/Rakefile

@@ -0,0 +1,11 @@
+task :test do
+  system "cd test && mkdir -p tmp && ruby monk_test.rb"
+end
+
+task :default => :test
+
+namespace :test do
+  task :integration do
+    system "cd test && ruby integration_test.rb"
+  end
+end

data/bin/priest

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby -rubygems
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require "monk"
+
+# A way to extend Monk is to write tasks in a Monkfile in the project's root directory.
+# Monk loads the Monkfile if there is one, and all the tasks that are declared in the
+# class Monk become available.
+Dir.glob("{Thor,Monk}file") { |f| load f }
+
+# Start the monk tasks.
+Monk.start

data/lib/monk.rb

@@ -0,0 +1,170 @@
+#! /usr/bin/env ruby
+
+require "thor"
+require "yaml"
+
+require "monk/skeleton"
+
+class Monk < Thor
+  include Thor::Actions
+  
+  class_options[:skip].aliases.delete "-s" if class_options.include? :skip
+  
+  def self.git_option(name, options = {})
+    class_option name, options.merge(:group => :git)
+    git_options << name.to_s
+  end
+    
+  def self.git_options
+    @git_options ||= ["mirror_path"]
+  end
+  
+  def self.monk_home
+    ENV["MONK_HOME"] || File.join(Thor::Util.user_home)
+  end
+  
+  def self.monk_mirrors
+    File.join(monk_home, ".monk_mirrors")
+  end
+  
+  git_option :branch, :type => :string, :aliases => "-b",
+             :desc => "Specify skeleton branch to use."
+  git_option :keep_remote, :type => :boolean, :aliases => "-k",
+             :desc => "Do not remove .git folder and keep skeleton as remote"
+  git_option :remote_name, :type => :string, :aliases => "-r",
+             :desc => "Remote name to use for the skeleton. Default is skeleton"
+  git_option :mirror, :type => :boolean, :aliases => "-m",
+             :desc => "Keep local mirror of the skeleton. For offline use and frequent project creation"
+  
+  desc "init", "Initialize a Monk application. Will try to update mirror for given skeleton."
+  method_option :skeleton, :type => :string, :aliases => "-s"     
+  def init(target = ".")
+    say_status :fetching, skeleton.url
+    skeleton.create(target) ?
+      say_status(:initialized, target) :
+      say_status(:error, clone_error(target))
+  end
+  
+  desc "show NAME", "Display the repository address for NAME"
+  def show(name)
+    say_status name, monk_config[name] ? skeleton(name).description : "repository not found"
+  end
+
+  desc "list", "Lists the configured repositories"
+  def list
+    monk_config.keys.sort.each { |key| show(key) }
+  end
+
+  desc "add NAME REPOSITORY_URL", "Add the repository to the configuration file"
+  def add(name, repository_url)
+    monk_config[name] = Skeleton.new(repository_url)
+    monk_config[name].merge! git_options
+    monk_config[name].update_mirror
+    write_monk_config_file
+    say_status :added, name
+  end
+
+   desc "change NAME", "Modifies options for a repository without having to repeat the url"
+   def change(name)
+     if monk_config.include? name
+       monk_config[name].merge! git_options
+       if options.include? "mirror" and not options.mirror?
+         path = monk_config[name].delete "mirror_path"
+        system "rm -R #{path}" if path
+       end
+       write_monk_config_file
+       say_status :modified, name
+     else
+       say_status name, "repository not found"
+     end
+   end
+
+   desc "rm NAME", "Remove the repository from the configuration file"
+   def rm(name)
+     skel = monk_config.delete(name)
+     write_monk_config_file
+     system "rm -R #{skel.mirror_path}" if skel.mirror_path?
+     say_status :deleted, name
+   end
+
+   desc "copy FROM TO", "Creates a copy of an existing skeleton"
+   def copy(from, to)
+     return unless monk_config.include? from
+     monk_config[to] = skeleton(from)
+     monk_config[to].delete "mirror_path"
+     write_monk_config_file
+     say_status :added, to
+   end
+   
+   desc "cleanup", "Removes mirrors no longer used (or all mirrors with --all)"
+   method_option :all, :type => :boolean, :aliases => "-a"
+   def cleanup
+     say_status "scanning", "mirrors"
+     mirrors = Dir.glob File.join(Monk.monk_mirrors, "*")
+     monk_config.each_value do |skel|
+       mirrors.delete skel.mirror_path if skel.mirror_path?
+     end unless options["all"]
+     say_status "cleanup", "mirrors"
+     system "rm -R #{mirrors.join " "}"
+   end
+   
+   desc "update", "Updates all mirrors or mirrors for given skeleton."
+   def update(name = nil)
+     name ||= options[:skeleton]
+     return monk_config.each_key { |s| update(s) } unless name
+     skel = skeleton(name)
+     if skel.mirror?
+       say_status "update", name
+       skel.update_mirror
+     end
+   end
+  
+
+private
+
+  def skeleton(name = nil)
+    name ||= options[:skeleton] || "default"
+    (monk_config[name] || Skeleton.new(name)).merge git_options
+  end
+  
+  def git_options
+    self.class.git_options.inject({}) do |opts, key|
+       opts.merge! key => options[key] if options.include? key
+       opts
+    end
+  end
+
+  def monk_config_file
+    @monk_config_file ||= File.join(monk_home, ".monk")
+  end
+
+  def monk_config
+    @monk_config ||= begin
+      write_monk_config_file unless File.exists? monk_config_file
+      YAML.load_file(monk_config_file).inject({}) do |config, (key, value)|
+        config.merge key => Skeleton.new(value)
+      end
+    end
+  end
+
+  def write_monk_config_file
+    remove_file monk_config_file, :verbose => false
+    create_file(monk_config_file, nil, :verbose => false) do
+      config = @monk_config || { "default" => Skeleton.new("git://github.com/monkrb/skeleton.git") }
+      config.to_yaml
+    end
+  end
+  
+  def self.source_root
+    "."
+  end
+
+  def clone_error(target)
+    "Couldn't clone repository into target directory '#{target}'. " +
+    "You must have git installed and the target directory must be empty."
+  end
+
+  def monk_home
+    self.class.monk_home
+  end
+end

data/lib/monk/skeleton.rb

@@ -0,0 +1,111 @@
+require 'thor/core_ext/hash_with_indifferent_access'
+require 'fileutils'
+require 'monk'
+
+class Monk < Thor
+  class Skeleton
+    
+    include Thor::CoreExt
+    include FileUtils
+    attr_accessor :options, :target
+    
+    DEFAULTS = { "remote_name" => "skeleton", "branch" => "master" }
+    
+    def initialize(url = nil, opts = {})     
+      opts, url = opts.merge(url), nil if url.respond_to? :merge
+      self.options = HashWithIndifferentAccess.new opts
+      options[:url] ||= url
+      raise ArgumentError, "no url given" unless options.url?
+    end
+    
+    def mirror_path
+      return unless mirror?
+      options[:mirror_path] ||= begin
+        require 'digest/md5'
+        File.join(Monk.monk_mirrors, Digest::MD5.hexdigest(options[:url]))
+      end
+    end
+    
+    def update_mirror
+      return unless mirror?
+      if File.exist? mirror_path
+        chdir(mirror_path) { system "git pull origin -q >/dev/null 2>&1"}
+      else
+        mkdir_p Monk.monk_mirrors
+        system "git clone -q #{url} #{mirror_path}"
+      end
+    end
+    
+    def create(directory)
+      update_mirror
+      if Dir["#{directory}/*"].empty?
+        self.target = directory
+        return false unless clone_command
+        clean_up unless keep_remote?
+        true
+      end
+    end
+    
+    def advanced_clone?
+      branch? or keep_remote?
+    end
+    
+    def clone_command
+      advanced_clone? ? advanced_clone : fast_clone
+    end
+    
+    def mirror_url
+      mirror? ? mirror_path : url
+    end
+    
+    def fast_clone
+      system "git clone -q --depth 1 #{mirror_url} #{target}"
+    end
+    
+    def advanced_clone
+      mkdir_p target
+      Dir.chdir target do
+        system "(git init -q &&
+                 git remote add -t #{branch} -f #{remote_name} #{mirror_url} &&
+                 git checkout -t #{remote_name}/#{branch} -q) >/dev/null 2>&1"
+      end
+    end
+    
+    def clean_up
+      Dir.chdir(target) { system "rm -Rf .git" }
+    end
+    
+    def config
+      options.keys == ["url"] ? options["url"] : Hash.new.replace(options)
+    end
+    
+    def to_yaml(opts = {})
+      config.to_yaml(opts)
+    end
+    
+    def description
+      parameters = options.map do |key, value|
+        case key
+        when "url", "mirror_path" then nil
+        when "mirror", "keep_remote"
+          "#{"no-" unless value}#{key.gsub("_", "-")}"
+        else
+          "#{key}: #{value.inspect}"
+        end
+      end.compact.join ", "
+      parameters = "(#{parameters})" unless parameters.empty?
+      "#{url} #{parameters}"
+    end 
+    
+    def method_missing(name, *args, &block)
+      name = name.to_s
+      return options[name] || DEFAULTS[name] if Monk.git_options.include? name
+      result = options.send(name, *args, &block)
+      if result.equal? options then self
+      elsif result.is_a? Hash then Skeleton.new result
+      else result
+      end 
+    end
+    
+  end
+end

data/priest.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name              = "priest"
+  s.version           = "0.0.7"
+  s.summary           = "Priest, the command line tool for monk."
+  s.description       = "Priest is a more advanced replacement for the monk command line tool. Monk is a glue framework for web development. It means that instead of installing all the tools you need for your projects, you can rely on a git repository and a list of dependencies, and Monk will care of the rest. By default, it ships with a Sinatra application that includes Contest, Stories, Webrat, Ohm and some other niceties, along with a structure and helpful documentation to get your hands wet in no time."
+  s.authors           = ["Konstantin Haase"]
+  s.email             = ["konstantin.mailinglists@googlemail.com"]
+  s.homepage          = "http://github.com/rkh/priest"
+
+#  s.rubyforge_project = "monk"
+
+  s.executables << "priest"
+
+  s.add_dependency("thor", "~> 0.11")
+  s.add_dependency("dependencies", ">= 0.0.7")
+  s.requirements << "git"
+
+  s.files = ["LICENSE", "README.markdown", "Rakefile", "bin/priest", "lib/monk/skeleton.rb", "lib/monk.rb", "priest.gemspec", "test/commands.rb", "test/integration_test.rb", "test/monk_test.rb", "test/test_helper.rb"]
+end

data/test/commands.rb

@@ -0,0 +1,72 @@
+require "open3"
+require "socket"
+
+module Test::Commands
+  def sh(cmd)
+    out, err = nil
+
+    Open3.popen3(cmd) do |_in, _out, _err|
+      out = _out.read
+      err = _err.read
+    end
+
+    [out, err]
+  end
+
+  # Runs a command in the background, silencing all output.
+  # For debugging purposes, set the environment variable VERBOSE.
+  def sh_bg(cmd)
+    if ENV["VERBOSE"]
+      streams_to_silence = []
+    else
+      streams_to_silence = [$stdout, $stderr]
+      cmd = "#{cmd} 2>&1>/dev/null"
+    end
+
+    silence_stream(*streams_to_silence) do
+      (pid = fork) ? Process.detach(pid) : exec(cmd)
+    end
+  end
+
+  def listening?(host, port)
+    begin
+      socket = TCPSocket.new(host, port)
+      socket.close unless socket.nil?
+      true
+    rescue Errno::ECONNREFUSED,
+      Errno::EBADF,           # Windows
+      Errno::EADDRNOTAVAIL    # Windows
+      false
+    end
+  end
+
+  def wait_for_service(host, port, timeout = 3)
+    start_time = Time.now
+
+    until listening?(host, port)
+      if timeout && (Time.now > (start_time + timeout))
+        raise SocketError.new("Socket #{host}:#{port} did not open within #{timeout} seconds")
+      end
+    end
+
+    true
+  end
+
+  def suspects(port)
+    list = sh("lsof -i :#{port}").first.split("\n")[1..-1] || []
+    list.map {|s| s[/^.+? (\d+)/, 1] }
+  end
+
+  def silence_stream(*streams) #:yeild:
+    on_hold = streams.collect{ |stream| stream.dup }
+    streams.each do |stream|
+      stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+      stream.sync = true
+    end
+    yield
+  ensure
+    streams.each_with_index do |stream, i|
+      stream.reopen(on_hold[i])
+    end
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,115 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestMonk < Test::Unit::TestCase
+  context "monk init NAME" do
+    setup do
+      @ports_to_close = []
+    end
+
+    def assert_url(url)
+      assert_match /200 OK/, sh("curl -I 0.0.0.0:4567#{url}").first.split("\n").first
+    end
+
+    def try_server(cmd, port)
+      binary = cmd[/^(.+?)( |$)/, 1]
+
+      flunk "Can't find `#{binary}`." unless system("which #{binary} > /dev/null")
+
+      kill_suspects(port)
+      sh_bg(cmd)
+
+      # Mark the port for closing on teardown, just in case the build fails.
+      @ports_to_close << port if wait_for_service("0.0.0.0", port)
+
+      doc = Hpricot(sh("curl 0.0.0.0:#{port}").first)
+
+      assert_match /Hello, world/, doc.at("body").inner_text
+
+      # Make sure all referenced URLs in the layout respond correctly.
+      doc.search("//*[@href]").each do |node|
+        assert_url node.attributes["href"]
+      end
+
+      doc.search("//*[@src]").each do |node|
+        assert_url node.attributes["src"]
+      end
+    end
+
+    should "create a skeleton app with all tests passing" do
+      flunk "There is another server running on 0.0.0.0:4567. Suspect PIDs: #{suspects(4567).join(", ")}" if listening?("0.0.0.0", 4567)
+      flunk "There is another server running on 0.0.0.0:9292. Suspect PIDs: #{suspects(9292).join(", ")}" if listening?("0.0.0.0", 9292)
+
+      Dir.chdir(root("test", "tmp")) do
+        FileUtils.rm_rf("monk-test")
+
+        out, err = monk("init monk-test")
+        assert_match /initialized.* monk-test/, out
+
+        Dir.chdir("monk-test") do
+          assert !File.directory?(".git")
+
+          FileUtils.cp("config/settings.example.yml", "config/settings.yml")
+          FileUtils.cp("config/redis/development.example.conf", "config/redis/development.conf")
+          FileUtils.cp("config/redis/test.example.conf", "config/redis/test.conf")
+
+          # Load Redis.
+          sh "redis-server config/redis/test.conf"
+          wait_for_service("0.0.0.0", 6380)
+
+          sh "redis-server config/redis/development.conf"
+          wait_for_service("0.0.0.0", 6379)
+
+          assert system("rake >/dev/null"), "the build didn't pass"
+          assert system("rake1.9 >/dev/null"), "the build didn't pass (1.9)"
+
+          try_server "ruby init.rb", 4567
+          try_reloading
+          try_server "rackup", 9292
+
+          try_server "ruby1.9 init.rb", 4567
+          try_reloading
+          try_server "rackup1.9", 9292
+
+          try_server "jruby init.rb", 4567
+          try_reloading
+        end
+      end
+    end
+
+    def try_reloading
+      gsub_file("app/routes/home.rb", "haml :home", "'Goodbye'") do
+        sleep 0.2
+        assert_match /Goodbye/, sh("curl 0.0.0.0:4567").first
+      end
+
+      gsub_file("init.rb", "Main.run!", %Q(Main.get "/test" { 'test' }\n Main.run!)) do
+        sleep 0.2
+        assert_match /test/, sh("curl 0.0.0.0:4567/test").first
+      end
+    end
+
+    def gsub_file(file, *args)
+      old = File.read(file)
+
+      begin
+        new = old.gsub(*args)
+        File.open(file, "w") {|f| f.write(new) }
+        yield
+      ensure
+        File.open(file, "w") {|f| f.write(old) }
+      end
+    end
+
+    def kill_suspects(port)
+      list = suspects(port)
+
+      sh "kill -9 #{list.join(" ")}" unless list.empty?
+    end
+
+    teardown do
+      @ports_to_close.each do |port|
+        kill_suspects port
+      end
+    end
+  end
+end

data/test/monk_test.rb

@@ -0,0 +1,382 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestMonk < Test::Unit::TestCase
+  context "monk init NAME" do
+    should "fail if the target working directory is not empty" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+
+        chdir("monk-test") do
+          touch("foobar")
+        end
+
+        out, err = monk("init monk-test")
+        assert_match /error/, out
+      end
+    end
+
+    should "create a skeleton app in the target directory" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+
+        out, err = monk("init monk-test")
+        assert_match /initialized.* monk-test/, out
+        assert is_template?("monk-test", "default")
+      end
+    end
+    
+    should "not remove .git if keep-remote option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+
+        out, err = monk("init monk-test --keep-remote")
+        assert_match /initialized.* monk-test/, out
+        assert File.exist?(tmp_path("monk-test", ".git"))
+      end
+    end
+    
+    should "remove .git if no-keep-remote option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+
+        out, err = monk("init monk-test --no-keep-remote")
+        assert_match /initialized.* monk-test/, out
+        assert !File.exist?(tmp_path("monk-test", ".git"))
+      end
+    end
+
+    should "not remove .git if k option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+
+        out, err = monk("init monk-test -k")
+        assert_match /initialized.* monk-test/, out
+        assert File.exist?(tmp_path("monk-test", ".git"))
+      end
+    end
+    
+    should "name remote after remote-name parameter" do
+      chdir tmp_path do
+        rm_rf "monk-test"
+        out, err = monk("init monk-test --keep-remote --remote-name foo")
+        assert_match /initialized.* monk-test/, out
+        chdir("monk-test") { assert %x[git remote show]["foo"] }
+      end
+    end
+    
+    should "be able to pull from skeletons with parameter mirror if original is not available" do
+      chdir tmp_path do
+        rm_rf "monk-test"
+        rm_rf create_template("foo", "--mirror")
+        out, err = monk("init monk-test --skeleton foo")
+        assert_match /initialized.* monk-test/, out
+        assert is_template?("monk-test", "foo")
+      end
+    end
+
+    should "be able to pull from skeletons with parameter m if original is not available" do
+      chdir tmp_path do
+        rm_rf "monk-test"
+        rm_rf create_template("foo", "-m")
+        out, err = monk("init monk-test --skeleton foo")
+        assert_match /initialized.* monk-test/, out
+        assert is_template?("monk-test", "foo")
+      end
+    end
+    
+    should "be able to pull from a url instead of a known skeleton" do
+      chdir tmp_path do
+        rm_rf "monk-test"
+        path = create_template("foo")
+        out, err = monk("init monk-test --skeleton #{path}")
+        assert_match /initialized.* monk-test/, out
+        assert is_template?("monk-test", "foo")
+      end
+    end
+    
+    should "respect the branch parameter" do
+      chdir tmp_path do
+        in_template "foobar" do
+          system "git checkout -b foo 1>/dev/null 2>&1 || git checkout foo -q"
+          File.open("only_in_branch", "w").close
+          system "(git add only_in_branch && git commit -a -m 'added') 1>/dev/null 2>&1"
+        end 
+        rm_rf "monk-test"
+        out, err = monk("init monk-test --skeleton foobar --branch foo")
+        assert_match /initialized.* monk-test/, out
+        assert is_template?("monk-test", "foobar")
+        assert File.exist?(File.join("monk-test", "only_in_branch"))
+      end
+    end
+    
+    should "respect the b parameter" do
+      chdir tmp_path do
+        in_template "foobar" do
+          system "git checkout -b foo 1>/dev/null 2>&1 || git checkout foo -q"
+          File.open("only_in_branch", "w").close
+          system "(git add only_in_branch && git commit -a -m 'added') 1>/dev/null 2>&1"
+        end 
+        rm_rf "monk-test"
+        out, err = monk("init monk-test --skeleton foobar -b foo")
+        assert_match /initialized.* monk-test/, out
+        assert is_template?("monk-test", "foobar")
+        assert File.exist?(File.join("monk-test", "only_in_branch"))
+      end
+    end
+    
+  end
+
+  context "monk init" do
+    should "fail if the current working directory is not empty" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+
+
+        chdir("monk-test") do
+          touch("foobar")
+          out, err = monk("init")
+          assert_match /error/, out
+        end
+      end
+    end
+
+    should "create a skeleton app in the working directory" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+
+        chdir("monk-test") do
+          out, err = monk("init")
+          assert_match /initialized/, out
+          assert is_template?(".", "default") 
+        end
+      end
+    end
+
+    should "use an alternative skeleton if the option is provided" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+
+        create_template "foobar"
+
+        chdir("monk-test") do
+          out, err = monk("init -s foobar")
+          assert_match /initialized/, out
+          assert is_template?(".", "foobar") 
+        end
+      end
+    end
+    
+    should "not remove .git if keep-remote option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+        
+        chdir("monk-test") do
+          out, err = monk("init --keep-remote")
+          assert_match /initialized/, out
+          assert File.exist?(".git")
+        end
+      end
+    end
+    
+    should "remove .git if no-keep-remote option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+        
+        chdir("monk-test") do
+          out, err = monk("init --no-keep-remote")
+          assert_match /initialized/, out
+          assert !File.exist?(".git")
+        end
+      end
+    end
+      
+    should "not remove .git if k option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+
+        chdir("monk-test") do
+          out, err = monk("init -k")
+          assert_match /initialized/, out
+          assert File.exist?(".git")
+        end
+      end
+    end
+    
+    should "name remote after remote-name parameter" do
+      chdir tmp_path do
+        rm_rf "monk-test"
+        mkdir "monk-test"
+        chdir "monk-test" do
+          out, err = monk("init --keep-remote --remote-name foo")
+          assert_match /initialized/, out
+          assert %x[git remote show]["foo"]
+        end
+      end
+    end    
+    
+    should "be able to pull from a url instead of a known skeleton" do
+      chdir tmp_path do
+        rm_rf "monk-test"
+        mkdir "monk-test"
+        path = create_template("foo")
+        chdir "monk-test" do
+          out, err = monk("init --skeleton #{path}")
+          assert_match /initialized/, out
+          assert is_template?(".", "foo")
+        end
+      end
+    end
+    
+  end
+
+  context "monk show NAME" do
+    should "display the repository for NAME" do
+      out, err = monk("show default")
+      assert out[template_path "default"]
+    end
+
+    should "display nothing if NAME is not set" do
+      out, err = monk("show foobar")
+      assert out["repository not found"]
+    end
+  end
+
+  context "monk list" do
+    should "display the configured repositories" do
+      out, err = monk("list")
+      assert out["default"]
+      assert out[template_path "default"]
+    end
+  end
+
+  context "monk add NAME REPOSITORY" do
+    should "add the named repository to the configuration" do
+      monk("add foobar git://github.com/monkrb/foo.git")
+      out, err = monk("show foobar")
+      assert out["foobar"]
+      assert out["git://github.com/monkrb/foo.git"]
+      monk("rm foobar")
+    end
+
+    should "allow to fetch from the added repository when using the skeleton parameter" do
+      path = create_template "foo"
+
+      chdir(tmp_path) do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+
+        out, err = monk("init monk-test --skeleton foo")
+        assert_match /initialized/, out
+        assert_match /#{path}/, out
+        assert is_template?("monk-test", "foo") 
+      end
+    end
+
+    should "allow to fetch from the added repository when using the s parameter" do
+      path = create_template "foo"
+
+      chdir(tmp_path) do
+        rm_rf("monk-test")
+        mkdir("monk-test")
+
+        out, err = monk("init monk-test -s foo")
+        assert_match /initialized/, out
+        assert_match /#{path}/, out
+        assert is_template?("monk-test", "foo") 
+      end
+    end
+    
+    should "not remove .git if keep-remote option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")        
+        create_template "foo", "--keep-remote"
+        
+        chdir("monk-test") do
+          out, err = monk("init --skeleton foo")
+          assert_match /initialized/, out
+          assert File.exist?(".git")
+        end
+      end
+    end
+    
+    should "remove .git if no-keep-remote option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")        
+        create_template "foo", "--no-keep-remote"
+        
+        chdir("monk-test") do
+          out, err = monk("init --skeleton foo")
+          assert_match /initialized/, out
+          assert !File.exist?(".git")
+        end
+      end
+    end
+      
+    should "not remove .git if k option is passed" do
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")        
+        create_template "foo", "-k"
+        
+        chdir("monk-test") do
+          out, err = monk("init --skeleton foo")
+          assert_match /initialized/, out
+          assert File.exist?(".git")
+        end
+      end
+    end
+    
+    should "name remote after remote-name parameter" do
+      chdir tmp_path do
+        rm_rf "monk-test"
+        create_template "foo", "--keep-remote --remote-name foo"
+        out, err = monk("init monk-test --skeleton foo")
+        assert_match /initialized.* monk-test/, out
+        chdir("monk-test") { assert %x[git remote show]["foo"] }
+      end
+    end
+    
+  end
+
+  context "monk rm NAME" do
+    should "remove the named repository from the configuration" do
+      monk("add foobar git://github.com/monkrb/foo.git")
+      monk("rm foobar")
+      out, err = monk("show foobar")
+      assert out["repository not found"]
+    end
+  end
+  
+  context "monk copy FROM TO" do
+    should "copy a template" do 
+      chdir tmp_path do
+        rm_rf "monk-test"
+        monk "copy default foo"
+        monk "init monk-test -s foo"
+        assert is_template?("monk-test", "default")
+      end
+    end
+  end
+  
+  context "monk change NAME" do
+    should "remove the named repository from the configuration" do
+      monk("add foobar git://github.com/monkrb/foo.git --keep-remote")
+      out, err = monk("show foobar")
+      assert out["keep-remote"]
+      assert !out["no-keep-remote"]
+      monk("change foobar --no-keep-remote")
+      out, err = monk("show foobar")
+      assert out["no-keep-remote"]
+    end
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,63 @@
+#require "rubygems"
+require "contest"
+require "hpricot"
+require "fileutils"
+
+ROOT = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+$:.unshift ROOT
+
+require "test/commands"
+
+class Test::Unit::TestCase
+  include Test::Commands
+  include FileUtils
+
+  def root(*args)
+    File.expand_path File.join(ROOT, *args)
+  end
+  
+  def tmp_path(*args)
+    root("test", "tmp", *args)
+  end
+
+  def setup
+    mkdir_p tmp_path
+    rm_f tmp_path(".monk")
+    create_template "default"
+  end
+  
+  def template_path(name = default)
+    tmp_path("templates", name)
+  end
+  
+  def create_template(name, add = "")
+    dir = template_path(name)
+    mkdir_p dir
+    chdir(dir) do
+      unless File.exist? "name"
+        File.open("name", "w") { |f| f << name }
+        raise RuntimeError, "could not initialize git repo" unless system <<-EOS
+          git init -q  &&
+          git add name 2>/dev/null &&
+          git ci -m "created template" -q
+        EOS
+      end
+    end
+    monk("add #{name} #{dir} #{add}") if add
+    dir
+  end
+  
+  def in_template(name, &block)
+    chdir(create_template(name), &block)
+  end
+  
+  def is_template?(path, name)
+    file = File.join path, "name"
+    File.exist?(file) && File.read(file) == name
+  end
+
+  def monk(args = nil)
+    sh("env MONK_HOME=#{File.join(ROOT, "test", "tmp")} ruby -rubygems #{root "bin/monk"} #{args}")
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: priest
+version: !ruby/object:Gem::Version 
+  version: 0.0.7
+platform: ruby
+authors: 
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-14 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.11"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dependencies
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.7
+    version: 
+description: Priest is a more advanced replacement for the monk command line tool. Monk is a glue framework for web development. It means that instead of installing all the tools you need for your projects, you can rely on a git repository and a list of dependencies, and Monk will care of the rest. By default, it ships with a Sinatra application that includes Contest, Stories, Webrat, Ohm and some other niceties, along with a structure and helpful documentation to get your hands wet in no time.
+email: 
+- konstantin.mailinglists@googlemail.com
+executables: 
+- priest
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- bin/priest
+- lib/monk/skeleton.rb
+- lib/monk.rb
+- priest.gemspec
+- test/commands.rb
+- test/integration_test.rb
+- test/monk_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/rkh/priest
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- git
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Priest, the command line tool for monk.
+test_files: []
+