monk-shake 1.0.0.pre1

data/README.md

@@ -0,0 +1,59 @@
+Monk
+====
+
+A feature-complete rewrite of Monk that uses Shake instead of Thor.
+It is modeled after Monk 1.0 beta.
+
+See more info in [monkrb.com](http://www.morkrb.com).
+
+**NOTE:** This is NOT an official replacement for Monk, nor is it
+supported or endorsed by Citrusbyte.
+
+### What is it?
+
+ * Monk lets you start a Sinatra project painlessly with everything set
+   up for you.
+
+### Get started
+
+You may need to uninstall the original monk gem.
+
+   $ rvm @global             # TIP: Recommended for RVM users
+   $ gem uninstall monk
+   $ gem install monk-shake --pre
+   $ monk
+
+### Differences from the real Monk in general
+
+ * *No more Thor!* The new Monkfile has deprecated the old Thorfile.
+   This version uses Shake instead.
+
+ * *Faster* as a result of above.
+
+ * New help screens. They are actually very helpful.
+
+ * This stores your config in a new format (YAML) in `~/.monk.conf`.
+
+ * The default skeleton is [github.com/rstacruz/monk-plus](https://github.com/rstacruz/monk-plus),
+   the mere reason being it's the only one that takes advantage of new
+   features at the moment.
+
+### Changes from Monk 0.x
+
+ * This doesn't rely on the `dependencies` gem.
+
+ * `monk init` will cache skeleton files so it'll run faster next time.
+
+ * New `monk install` command installs gems from the `.gems` manifest file.
+
+ * The command `monk unpack` now uses the more reliable RVM.
+
+ * New `monk lock` command generates a `.gems` file for you.
+
+### Differences from Monk 1.0 beta
+
+ * This does not require RVM.
+
+ * `monk install` will first check if a gem is installed. It will not
+   try to reinstall gems you already have.
+

data/bin/monk

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'rubygems'  if RUBY_VERSION <= "1.9"
+require File.expand_path('../../vendor/shake/lib/shake', __FILE__)
+
+# Legacy Monk compatibility.
+# If there is a Thorfile (but no Monkfile), assume it's a Monk <1.0 project.
+# Defer to Thor for processing of that file.
+thor = Shake.find_in_project('Thorfile')
+if thor
+  monk = Shake.find_in_project('Monkfile')
+  if !monk
+    Dir.chdir File.dirname(thor)
+    require 'thor'
+    load 'Thorfile'
+    Monk.start
+    exit
+  end
+end
+
+require File.expand_path('../../lib/monk', __FILE__)
+
+Monk.load_monkfile
+Monk.run!

data/lib/monk.rb

@@ -0,0 +1,313 @@
+$:.push *Dir[File.expand_path('../../vendor/*/lib', __FILE__)]
+
+require 'fileutils'
+require 'shake'
+
+class Monk < Shake
+  VERSION = "1.0.0.pre1"
+  PREFIX  = File.expand_path('../monk', __FILE__)
+
+  autoload :Helpers,      "#{PREFIX}/helpers"
+  autoload :InitHelpers,  "#{PREFIX}/init_helpers"
+  autoload :Config,       "#{PREFIX}/config"
+
+  extend Helpers
+  extend InitHelpers
+
+  task(:init) do
+    name   = params.extract('-s') || 'default'
+    wrong_usage  if params.size != 1
+
+    target = params.shift
+
+    unless config.skeletons[name]
+      pass "No such skeleton: #{name}\n" +
+           "Type `#{executable} list` for a list of known skeletons."
+    end
+
+    if File.exists?(target)
+      pass "Error: the target directory already exists."
+    end
+
+    skeleton_files = cache_skeleton(name)
+    pass "Error: can't retrieve the skeleton files."  unless skeleton_files
+    cp_r skeleton_files, target
+
+    in_path (target) {
+      rm_rf '.git'
+      touch 'Monkfile'
+      system_q "rvm #{RUBY_VERSION}@#{target} --rvmrc --create"  if rvm?
+      system_q "rvm rvmrc trust"  if rvm?
+    }
+
+    puts 
+    puts "Success! You've created a new project."
+    puts "Get started now:"
+    puts
+    puts "  $ cd #{target}"
+    puts "  $ #{executable} start"
+    puts
+
+    if rvm?
+      puts "An RVM gemset @#{target} has been created for you."
+      puts
+    end
+  end
+
+  task(:install) do
+    manifest = '.gems'
+
+    pass "This project does not have a .gems manifest."  unless File.exists?(manifest)
+
+    gems = File.read(manifest).split("\n")
+
+    gems.reject! { |name| name =~ /^\s*(#|$)/ }
+    pass "The .gems manifest is empty."  unless gems.any?
+
+    gems.reject! { |name| has_gem? name }
+    pass "All good! You have all needed gems installed."  unless gems.any?
+
+    unless rvm?
+      err "Tip: RVM is a great way to manage gems across multiple projects."
+      err "See http://rvm.beginrescueend.com for more info."
+      err
+    end
+
+    gems.each { |name| system "gem install #{name}" }
+  end
+
+  task(:unpack) do
+    ensure_rvm or pass
+    system "rvm rvmrc load"
+    system "rvm gemset unpack vendor"
+  end
+
+  task(:lock) do
+    ensure_rvm or pass
+    system "rvm rvmrc load"
+    system "rvm gemset export .gems"
+  end
+
+  task(:add) do
+    wrong_usage  unless params.size == 2
+    name, repo = params
+
+    existed = !!config.skeletons[name]
+
+    config.skeletons[name] = repo
+    config.save!
+
+    if existed
+      err "Updated skeleton #{name}."
+    else
+      err "Added skeleton #{name}."
+    end
+    err "Create a new project from this skeleton by typing: #{executable} init NAME -s #{name}"
+  end
+
+  task (:rm) do
+    wrong_usage  if params.size != 1
+    name = params.first
+
+    if name == 'default'
+      pass "You can't delete the default skeleton."
+    elsif config.skeletons[name]
+      config.skeletons.delete name.to_s
+      config.save!
+
+      err "Removed #{name}."
+    else
+      err "No such skeleton."
+      err "See `#{executable} list` for a list of skeletons."
+    end
+  end
+
+  task(:purge) do
+    rm_rf cache_path  if File.directory?(cache_path)
+    err "Monk cache clear."
+  end
+
+  task(:list) do
+    wrong_usage  if params.any?
+
+    puts "Available skeletons:"
+    puts
+    config.skeletons.each do |name, repo|
+      puts "  %-20s %s" % [ name, repo ]
+    end
+    puts
+    puts "Create a new project by typing `#{executable} init NAME -s SKELETON`."
+  end
+
+  task(:help) do
+    show_help_for(params.first) and pass  if params.any?
+
+    show_task = Proc.new { |name, t| err "  %-20s %s" % [ t.usage || name, t.description ] }
+
+    err "Usage: #{executable} <command>"
+    err
+
+    if project?
+      err "Dependency commands:"
+      tasks_for(:dependency).each &show_task
+      err
+      if other_tasks.any?
+        err "Project commands:"
+        other_tasks.each &show_task
+        err
+      end
+    else
+      err "Commands:"
+      tasks_for(:init).each &show_task
+      err
+      err "Skeleton commands:"
+      tasks_for(:skeleton).each &show_task
+      err
+    end
+
+    err "Other commands:"
+    tasks_for(:help).each &show_task
+
+    unless project?
+      err
+      err "Get started by typing:"
+      err "  $ #{executable} init my_project"
+      err
+      err "Type `#{executable} help COMMAND` for additional help on a command."
+      err "See http://www.monkrb.com for more information."
+    end
+  end
+
+  task(:version) do
+    puts "Monk-shake version #{VERSION}"
+  end
+
+  invalid do
+    task = task(command)
+    if task
+      err "Invalid usage."
+      err "Try: #{executable} #{task.usage}"
+      err
+      err "Type `#{executable} help` for more info."
+    else
+      err "Invalid command: #{command}"
+      err "Type `#{executable} help` for more info."
+    end
+  end
+
+  # Task metadata
+  default :help
+
+  task(:init).tap do |t|
+    t.category    = :init
+    t.usage       = "init NAME"
+    t.description = "Starts a Monk project"
+    t.help = %{
+      Usage:
+      
+          #{executable} init NAME [-s SKELETON]
+      
+      Initializes a Monk application of a given name.
+      
+      You may use a different skeleton by specifying `-s SKELETON` where
+      SKELETON refers to the name or URL of the skeleton. If this isn't specified,
+      the default skeleton is used.
+      
+      Examples
+      --------
+      
+      This creates a new Monk/Sinatra application in the directory `myapp`.
+      
+          #{executable} init myapp
+      
+      This creates a new application based on the skeleton in the given Git repo.
+      
+          #{executable} add myskeleton https://github.com/rstacruz/myskeleton.git
+          #{executable} init myapp -s myskeleton
+    }.gsub(/^ {6}/,'').strip.split("\n")
+  end
+
+  task(:add).tap do |t|
+    t.category    = :skeleton
+    t.usage       = "add NAME URL"
+    t.description = "Adds a skeleton"
+  end
+
+  task(:rm).tap do |t|
+    t.category    = :skeleton
+    t.usage       = "rm NAME"
+    t.description = "Removes a skeleton"
+  end
+
+  task(:list).tap do |t|
+    t.category    = :skeleton
+    t.description = "Lists known skeletons"
+  end
+
+  task(:purge).tap do |t|
+    t.category    = :skeleton
+    t.description = "Clears the skeleton cache"
+  end
+
+  task(:help).tap do |t|
+    t.category    = :help
+    t.description = "Shows a list of commands"
+  end
+
+  task(:version).tap do |t|
+    t.category    = :help
+    t.description = "Shows the Monk version"
+  end
+
+  task(:install).tap do |t|
+    t.category    = :dependency
+    t.description = "Install gems in the .gems manifest file"
+    t.help = %{
+      Usage:
+
+          #{executable} install
+          
+      Loads the given gemset name of your project, and installs the gems
+      needed by your project.
+
+      Gems are specified in the `.gems` file. This is created using
+      `#{executable} lock`.
+
+      The gemset name is then specified in `.rvmrc`, which is created upon
+      creating your project with `#{executable} init`.
+    }.gsub(/^ {6}/,'').strip.split("\n")
+  end
+
+  task(:unpack).tap do |t|
+    t.category    = :dependency
+    t.description = "Freeze gem dependencies into vendor/"
+    t.help = %{
+      Usage:
+
+          #{executable} unpack
+
+      Freezes the current gem dependencies of your project into the `vendor/`
+      path of your project.
+
+      This allows you to commit the gem contents into your project's repository.
+      This way, deploying your project elsewhere would not need `monk install`
+      or `gem install` to set up the dependencies.
+    }.gsub(/^ {6}/,'').strip.split("\n")
+  end
+
+  task(:lock).tap do |t|
+    t.category    = :dependency
+    t.description = "Lock gem dependencies into a .gems manifest file"
+    t.help = %{
+      Usage:
+
+          #{executable} lock
+          
+      Locks the current gem version dependencies of your project into the gem
+      manifest file.
+
+      This creates the `.gems` file for your project, which is then used by
+      `#{executable} install`.
+    }.gsub(/^ {6}/,'').strip.split("\n")
+  end
+end

data/lib/monk/config.rb

@@ -0,0 +1,27 @@
+require 'ostruct'
+require 'yaml'
+
+class Monk::Config < OpenStruct
+  def self.filename
+    File.expand_path(File.join(%w(~ .monk.conf)))
+  end
+
+  def self.load
+    if File.file?(filename)
+      self.new YAML::load_file(filename)
+    else
+      self.new
+    end
+  end
+
+  def initialize(*a)
+    super
+    self.skeletons ||= Hash.new
+    # At the time of writing, this is the only monk-shake compatible skeleton
+    self.skeletons['default'] ||= 'git://github.com/rstacruz/monk-plus.git'
+  end
+
+  def save!
+    File.open(self.class.filename, 'w') { |f| f.write YAML::dump(@table) }
+  end
+end

data/lib/monk/helpers.rb

@@ -0,0 +1,129 @@
+# All these functions are available as Monk.xxxx.
+# (eg, Monk.tasks_for)
+#
+module Monk::Helpers
+  def config
+    @config ||= Monk::Config.load
+  end
+
+  def tasks_for(category)
+    tasks.select { |name, t| t.category == category }
+  end
+
+  def other_tasks
+    tasks.select { |name, t| t.category.nil? }
+  end
+
+  def rvm?
+    @has_rvm = (!! `rvm` rescue false)  if @has_rvm.nil?
+    @has_rvm
+  end
+
+  def ensure_rvm
+    return true  if rvm?
+    err "You need RVM installed for this command."
+    err "See http://rvm.beginrescueend.com for more info."
+  end
+
+  # Checks if a certain gem is installed.
+  # The format is the same as that found in the .gems file.
+  #
+  # @example
+  #   has_gem?('nest -v1.1.0')
+  #
+  def has_gem?(str)
+    _, name, version = str.match(/^([A-Za-z_\-]+) -v(.*)$/).to_a
+    name    ||= str
+    version ||= ">=0"
+
+    begin
+      gem(name, version)
+      true
+    rescue Gem::LoadError
+      false
+    end
+  end
+
+  # Performs a given block in the given path.
+  def in_path(path, &blk)
+    old = Dir.pwd
+    Dir.chdir path
+    say_status :cd, path
+    yield
+    Dir.chdir old
+  end
+
+  # Loads the monkfile. Used by bin/monk.
+  def load_monkfile
+    file = find_in_project("Monkfile")
+
+    if file
+      load file
+      @project = File.dirname(file)
+      Dir.chdir @project
+    end
+  end
+
+  def show_help_for(task)
+    name = params.first
+    task = task(name)
+    pass "No such command. Try: #{executable} help"  unless task
+
+    help = task.help
+    if help
+      help.each { |line| err line }
+      err
+    else
+      err "Usage: #{executable} #{task.usage || name}"
+      err "#{task.description}."  if task.description
+    end
+  end
+
+  # Checks if there is a loaded project or not.
+  def project?
+    ! @project.nil?
+  end
+
+  # File expand: fx('~/.cache/monk')
+  def fx(*paths)
+    File.expand_path File.join(*paths.join('/').split('/'))
+  end
+
+  def system(cmd)
+    say_status :run, cmd
+    super
+  end
+
+  def system_q(cmd)
+    say_status :run, cmd
+    `#{cmd}`
+  end
+
+  def say_status(what, cmd)
+    c1 = "\033[0;33m"
+    c0 = "\033[0;m"
+    puts "#{c1}%10s#{c0}  %s" % [ what, cmd ]
+  end
+
+  # File helpers
+  def touch(target)
+    say_status :touch, target
+    FileUtils.touch target
+  end
+
+  def mkdir_p(target)
+    return  if File.directory?(target)
+    say_status :mkdir, target
+    FileUtils.mkdir_p target
+  end
+
+  def cp_r(from, target)
+    say_status :copy, "#{from} -> #{target}"
+    FileUtils.cp_r from, target
+  end
+
+  def rm_rf(target)
+    say_status :delete, target
+    FileUtils.rm_rf target
+  end
+end

data/lib/monk/init_helpers.rb

@@ -0,0 +1,34 @@
+module Monk::InitHelpers
+  def cache_path(name=nil)
+    fx "~/.cache/monk", name
+  end
+
+  def directory_with_files?(path)
+    File.directory?(path) and Dir[File.join(path, '{.*,*}')].any?
+  end
+
+  # Cache skeleton files into ~/.cache/monk/default
+  def cache_skeleton(name)
+    repo = config.skeletons[name]  or return
+
+    path = cache_path(name)
+    return path  if directory_with_files?(path)
+
+    mkdir_p fx(path, '..')
+
+    git_clone repo, path
+
+    if $?.to_i != 0
+      rm_rf path
+      return nil
+    end
+
+    rm_rf File.join(path, '.git')
+
+    path
+  end
+
+  def git_clone(repo, path)
+    system "git clone --depth 1 #{repo} #{path}"
+  end
+end

data/test/add_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../test_helper', __FILE__)
+
+scope do
+  test 'add fail' do
+    monk 'add'
+    assert_invalid
+  end
+
+  test 'add fail 2' do
+    monk 'add x y z'
+    assert_invalid
+  end
+
+  test 'add success' do
+    monk 'add foobar git://github.com/y'
+    assert cerr.include?('Added skeleton')
+
+    monk 'list'
+    assert cout =~ /foobar +git:\/\/github.com\/y/
+  end
+
+  test 'update' do
+    monk 'add foobar git://github.com/y'
+    assert cerr.include?('Added skeleton')
+
+    monk 'add foobar git://github.com/z'
+    assert cerr.include?('Updated skeleton')
+
+    monk 'list'
+    assert cout =~ /foobar +git:\/\/github.com\/z/
+  end
+
+  test 'add remove add' do
+    monk 'add foobar git://github.com/y'
+    assert cerr.include?('Added skeleton')
+
+    monk 'rm foobar'
+    assert cerr.include?('Removed')
+
+    monk 'add foobar git://github.com/y'
+    assert cerr.include?('Added skeleton')
+  end
+
+  test 'remove' do
+    monk 'rm foobar'
+    assert cerr.include?('No such skeleton')
+  end
+end

data/test/help_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../test_helper', __FILE__)
+
+scope do
+  test 'invalid command' do
+    monk 'shivers'
+    assert cout.empty?
+    assert cerr.include?('Invalid command')
+  end
+
+  test 'monk no args' do
+    monk 'help'
+    err = cerr
+
+    monk ''
+    assert err == cerr
+  end
+
+  test 'help' do
+    monk 'help'
+
+    assert cerr.include?('Usage:')
+    assert cerr.include?('www.monkrb.com')
+
+    %w(help version).each { |c| assert cerr.match(/^  #{c}/) }
+    %w(init add rm purge list).each { |c| assert cerr.match(/^  #{c}/) }
+    %w(unpack lock install).each { |c| assert !cerr.match(/^  #{c}/) }
+  end
+
+  test 'help in project' do
+    FileUtils.touch 'Monkfile'
+    monk 'help'
+
+    assert cerr.include?('Usage:')
+
+    %w(help version).each { |c| assert cerr.match(/^  #{c}/) }
+    %w(init add rm purge list).each { |c| assert !cerr.match(/^  #{c}/) }
+    %w(unpack lock install).each { |c| assert cerr.match(/^  #{c}/) }
+  end
+end

data/test/init_test.rb

@@ -0,0 +1,63 @@
+require File.expand_path('../test_helper', __FILE__)
+
+scope do
+  def mock_cache(name)
+    path = File.join(Monk.cache_path, name)
+    Monk.git_clone 'git://github.com/x/y', path
+  end
+
+  setup do
+    Dir[File.join(Monk.cache_path, '*')].each { |path| FileUtils.rm_rf path }
+  end
+
+  test 'init fail' do
+    monk 'init'
+    assert_invalid
+  end
+
+  test 'init fail 2' do
+    monk 'init x y z'
+    assert_invalid
+  end
+
+  test 'init git' do
+    monk 'init x'
+    assert_successful_init 'x'
+  end
+
+  test 'init cached' do
+    mock_cache 'default'
+
+    monk 'init x'
+    assert_successful_init 'x'
+
+    monk 'init x'
+    assert cerr.include?('exists')
+  end
+
+  test 'init caching' do
+    monk 'init x'
+    assert_successful_init 'x'
+    assert cout.include?('git clone')
+
+    assert File.directory?(Monk.cache_path('default'))
+
+    monk 'init x'
+    assert !cout.include?('git clone')
+  end
+
+  test 'custom skeleton' do
+    monk 'add shivers git://github.com/a/b'
+    monk 'init x -s shivers'
+
+    assert_successful_init 'x'
+    assert cout.include?('git://github.com/a/b')
+  end
+
+  test 'invalid skeleton' do
+    monk 'init x -s scabs'
+    assert cerr.include?('No such skeleton')
+  end
+
+  # TODO: git fail test
+end

data/test/mock.rb

@@ -0,0 +1,36 @@
+# Silly mocking
+
+# Capture output and input
+class << Monk
+  def puts(what=nil)
+    $out << "#{what}\n"
+  end
+
+  def err(what=nil)
+    $err << "#{what}\n"
+  end
+end
+
+# Caching will always happen in a temp folder
+module Monk::InitHelpers
+  def cache_path(name=nil)
+    File.expand_path("../tmp/#{name}", __FILE__)
+  end
+
+  def git_clone(repo, path)
+    FileUtils.mkdir_p path
+    FileUtils.touch File.join(path, 'Monkfile')
+    FileUtils.touch File.join(path, 'init.rb')
+    say_status :run, "git clone --depth 1 #{repo} #{path}"
+  end
+end
+
+# Config will never load the config file
+class Monk::Config
+  def self.load
+    self.new
+  end
+
+  def save!
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,48 @@
+$:.push *Dir[File.expand_path('../../lib', __FILE__)]
+
+require 'cutest'
+require 'shellwords'
+require 'fileutils'
+require 'monk'
+
+require File.expand_path('../mock', __FILE__)
+
+def monk(cmd)
+  $out = ''
+  $err = ''
+
+  Monk.load_monkfile
+  Monk.run *Shellwords.shellsplit(cmd)
+end
+
+def cout
+  $out
+end
+
+def cerr
+  $err
+end
+
+def assert_invalid
+  assert cout.empty?
+  assert cerr.include?('Invalid usage')
+end
+
+def assert_successful_init(path)
+  assert cout.include?("Success! You've created a new project")
+  assert cerr.empty?
+  assert File.directory?(path)
+  assert File.file?(File.join(path, 'Monkfile'))
+  assert File.file?(File.join(path, 'init.rb'))
+  assert !File.exists?(File.join(path, '.git'))
+end
+
+tmp_path = File.expand_path('../tmp', __FILE__)
+FileUtils.mkdir_p tmp_path
+
+prepare do
+  # Clear config
+  Dir.chdir tmp_path
+  Monk.instance_variable_set :@config, nil
+  FileUtils.rm_rf 'Monkfile'
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: monk-shake
+version: !ruby/object:Gem::Version 
+  prerelease: 6
+  version: 1.0.0.pre1
+platform: ruby
+authors: 
+- Rico Sta. Cruz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-15 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id001
+description: Monk lets you build Sinatra applications quickly and painlessly by letting it set up the directory structure for you. Monk-shake is a rewritten version of Monk that uses the Shake gem.
+email: 
+- rico@sinefunc.com
+executables: 
+- monk
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/monk
+- lib/monk/config.rb
+- lib/monk/helpers.rb
+- lib/monk/init_helpers.rb
+- lib/monk.rb
+- test/add_test.rb
+- test/help_test.rb
+- test/init_test.rb
+- test/mock.rb
+- test/test_helper.rb
+- README.md
+has_rdoc: true
+homepage: http://www.github.com/rstacruz/monk-shake
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Monk the Sinatra glue framework -- reloaded
+test_files: []
+