rkh-monk 0.0.5 → 0.0.6

data/Rakefile

@@ -6,6 +6,6 @@ task :default => :test
 
 namespace :test do
   task :integration do
-    system "cd test && mkdir -p tmp && ruby integration_test.rb"
+    system "cd test && ruby integration_test.rb"
   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/lib/monk.rb

@@ -1,109 +1,140 @@
 #! /usr/bin/env ruby
 
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
 require "thor"
 require "yaml"
-require "fileutils"
+
+require "monk/skeleton"
 
 class Monk < Thor
   include Thor::Actions
   
-  class << self    
-    private
-    
-    # options every git aware task takes
-    def git_options
-      method_option :branch, :type => :string, :alias => "-b"
-      method_option :keep_remote, :type => :boolean
-      method_option :remote_name, :type => :string
-    end
+  class_options[:skip].aliases.delete "-s"
+  
+  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
-
-  desc "init", "Initialize a Monk application"
-  method_option :skeleton, :type => :string, :aliases => "-s"
-  git_options     
+  
+  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 = ".")
-    clone(source(options[:skeleton] || "default"), target) ?
-      cleanup(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)
-    if monk_config.include? name
-      say_status name, *source(name).values_at(:url, :branch)
-    else
-      say_status name, "repository not found"
-    end
+    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 do |key|
-      show(key)
-    end
+    monk_config.keys.sort.each { |key| show(key) }
   end
 
   desc "add NAME REPOSITORY_URL", "Add the repository to the configuration file"
-  git_options
   def add(name, repository_url)
-    monk_config[name] = { :url => repository_url }
-    monk_config[name].merge! options
+    monk_config[name] = Skeleton.new(repository_url)
+    monk_config[name].merge! git_options
+    monk_config[name].update_mirror
     write_monk_config_file
-  end
+    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
   
-  desc "change NAME", "Modifies options for a repository without having to repeat the url."
-  git_options
-  def change(name)
-    if monk_config.include? name
-      monk_config[name].merge! options
-      write_monk_config_file
-    else
-      say_status name, "repository not found"
-    end
-  end
-
-  desc "rm NAME", "Remove the repository from the configuration file"
-  def rm(name)
-    monk_config.delete(name)
-    write_monk_config_file
-  end
-  
-  desc "copy FROM TO", "Creates a copy of an existing skeleton."
-  git_options
-  def copy(from, to)
-    return unless monk_config.include? from
-    monk_config[to] = monk_config[from].merge options
-    write_monk_config_file 
-  end
 
 private
 
-  def clone(src, target)
-    if Dir["#{target}/*"].empty?
-      FileUtils.mkdir_p target
-      Dir.chdir(target) do
-        say_status :fetching, src[:url]
-        branch = src[:branch] || "master"
-        remote = src[:remote_name] || "skeleton"
-        system <<-EOS
-          git init &&
-          git remote add -t #{branch} -f #{remote} #{src[:url]} &&
-          git checkout -t #{remote}/#{branch}
-        EOS
-      end
-    end
-  end
-
-  def cleanup(target)
-    inside(target) { remove_file ".git" } unless options.keep_remote?
-    say_status :initialized, target
-  end
-
-  def source(name)
-    monk_config[name]
+  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")
@@ -113,20 +144,19 @@ private
     @monk_config ||= begin
       write_monk_config_file unless File.exists? monk_config_file
       YAML.load_file(monk_config_file).inject({}) do |config, (key, value)|
-        # fixing old monk config files
-        config.merge key => value.respond_to?(:keys) ? value : {:url => value}
+        config.merge key => Skeleton.new(value)
       end
     end
   end
 
   def write_monk_config_file
-    remove_file monk_config_file
-    create_file monk_config_file do
-      config = @monk_config || { "default" => {:url => "git://github.com/monkrb/skeleton.git"} }
+    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
@@ -137,6 +167,6 @@ private
   end
 
   def monk_home
-    ENV["MONK_HOME"] || File.join(Thor::Util.user_home)
+    self.class.monk_home
   end
-end
+end

data/monk.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name              = "monk"
-  s.version           = "0.0.5"
+  s.version           = "0.0.6"
   s.summary           = "Monk, the glue framework"
   s.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 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           = ["Damian Janowski", "Michel Martens"]
@@ -12,8 +12,8 @@ Gem::Specification.new do |s|
   s.executables << "monk"
 
   s.add_dependency("thor", "~> 0.11")
-  s.add_dependency("dependencies", ">= 0.0.6")
+  s.add_dependency("dependencies", ">= 0.0.7")
   s.requirements << "git"
 
-  s.files = ["LICENSE", "README.markdown", "Rakefile", "bin/monk", "lib/monk.rb", "monk.gemspec", "test/commands.rb", "test/integration_test.rb", "test/monk_test.rb"]
+  s.files = ["LICENSE", "README.markdown", "Rakefile", "bin/monk", "lib/monk/skeleton.rb", "lib/monk.rb", "monk.gemspec", "test/commands.rb", "test/integration_test.rb", "test/monk_test.rb", "test/test_helper.rb"]
 end

data/test/integration_test.rb

@@ -69,6 +69,9 @@ class TestMonk < Test::Unit::TestCase
           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

data/test/monk_test.rb

@@ -3,12 +3,12 @@ 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
-      Dir.chdir(root("test", "tmp")) do
-        FileUtils.rm_rf("monk-test")
-        FileUtils.mkdir("monk-test")
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
 
-        Dir.chdir("monk-test") do
-          FileUtils.touch("foobar")
+        chdir("monk-test") do
+          touch("foobar")
         end
 
         out, err = monk("init monk-test")
@@ -17,24 +17,125 @@ class TestMonk < Test::Unit::TestCase
     end
 
     should "create a skeleton app in the target directory" do
-      Dir.chdir(root("test", "tmp")) do
-        FileUtils.rm_rf("monk-test")
+      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
-      Dir.chdir(root("test", "tmp")) do
-        FileUtils.rm_rf("monk-test")
-        FileUtils.mkdir("monk-test")
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
 
 
-        Dir.chdir("monk-test") do
-          FileUtils.touch("foobar")
+        chdir("monk-test") do
+          touch("foobar")
           out, err = monk("init")
           assert_match /error/, out
         end
@@ -42,36 +143,103 @@ class TestMonk < Test::Unit::TestCase
     end
 
     should "create a skeleton app in the working directory" do
-      Dir.chdir(root("test", "tmp")) do
-        FileUtils.rm_rf("monk-test")
-        FileUtils.mkdir("monk-test")
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
 
-        Dir.chdir("monk-test") do
+        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
-      Dir.chdir(root("test", "tmp")) do
-        FileUtils.rm_rf("monk-test")
-        FileUtils.mkdir("monk-test")
+      chdir tmp_path do
+        rm_rf("monk-test")
+        mkdir("monk-test")
 
-        monk("add foobar git://github.com/monkrb/skeleton.git")
+        create_template "foobar"
 
-        Dir.chdir("monk-test") do
+        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["git://github.com/monkrb/skeleton.git"]
+      assert out[template_path "default"]
     end
 
     should "display nothing if NAME is not set" do
@@ -84,7 +252,7 @@ class TestMonk < Test::Unit::TestCase
     should "display the configured repositories" do
       out, err = monk("list")
       assert out["default"]
-      assert out["git://github.com/monkrb/skeleton.git"]
+      assert out[template_path "default"]
     end
   end
 
@@ -98,30 +266,85 @@ class TestMonk < Test::Unit::TestCase
     end
 
     should "allow to fetch from the added repository when using the skeleton parameter" do
-      monk("add glue git://github.com/monkrb/glue.git")
+      path = create_template "foo"
 
-      Dir.chdir(root("test", "tmp")) do
-        FileUtils.rm_rf("monk-test")
-        FileUtils.mkdir("monk-test")
+      chdir(tmp_path) do
+        rm_rf("monk-test")
+        mkdir("monk-test")
 
-        out, err = monk("init monk-test --skeleton glue")
+        out, err = monk("init monk-test --skeleton foo")
         assert_match /initialized/, out
-        assert_match /glue.git/, 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
-      monk("add glue git://github.com/monkrb/glue.git")
+      path = create_template "foo"
 
-      Dir.chdir(root("test", "tmp")) do
-        FileUtils.rm_rf("monk-test")
-        FileUtils.mkdir("monk-test")
+      chdir(tmp_path) do
+        rm_rf("monk-test")
+        mkdir("monk-test")
 
-        out, err = monk("init monk-test -s glue")
+        out, err = monk("init monk-test -s foo")
         assert_match /initialized/, out
-        assert_match /glue.git/, 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
@@ -132,4 +355,28 @@ class TestMonk < Test::Unit::TestCase
       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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rkh-monk
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Damian Janowski
@@ -31,7 +31,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.6
+        version: 0.0.7
     version: 
 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 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: 
@@ -48,14 +48,15 @@ files:
 - README.markdown
 - Rakefile
 - bin/monk
+- lib/monk/skeleton.rb
 - lib/monk.rb
 - monk.gemspec
 - test/commands.rb
 - test/integration_test.rb
 - test/monk_test.rb
+- test/test_helper.rb
 has_rdoc: false
 homepage: http://monkrb.com
-licenses: 
 post_install_message: 
 rdoc_options: []
 
@@ -76,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - git
 rubyforge_project: monk
-rubygems_version: 1.3.5
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Monk, the glue framework