nake 0.0.1

data/CHANGELOG

@@ -0,0 +1,9 @@
+= Version 0.0.1
+  * bin/nake executable
+  * sh helper (nake/helpers)
+  * task helper (nake/dsl)
+  * Task with description, dependencies and blocks
+  * Hidden tasks
+  * Each task can has multiple aliases
+  * Command line arguments parsing. Arguments will be passed as an arguments for blocks of the given task and options will be extracted into a hash, parsed into Ruby data types and passed as the last argument for the blocks.
+  * Default tasks for help (-H, --help), list of available tasks (-T, --tasks) and interactive session (-i, --interactive)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 – 2010 Jakub Šťastný aka Botanicus
+
+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.textile

@@ -0,0 +1,24 @@
+h1. About
+
+Nake is light-weight and highly flexible Rake replacement with much better arguments parsing.
+
+You might be wondering why to write yet another fucking task manager when we have Rake, Thor and others. Well, because all of them sucks. For example Rake, anyone is actually using its CLI arguments, because it sucks so much, that everyone rather write @ENV=test VERSION=10 rake db:migrate@. It has not just shitty API for defining CLI arguments, but also it is using very weird and totally non-unix syntax like @rake db:migrate[test,10]@. This syntax isn't just non-standard, but also some shells has @[]@ as special characters, so you actually has to escape it.
+
+Sounds terrible? Well and it's not all! Let's take a look at this "example":http://gist.github.com/263325, as you can see if you have argument path and you let it empty, than it takes environment variable @$PATH@! I contact Jim Weirich about this issue and he never replied, so he probably thinks it's fine. Fair enough, but I won't work with such tool.
+
+h1. Features
+
+- Tasks can have a *name*, *description*, *dependencies*, *aliases* and *blocks* which will be executed when the task is called. Task can be also hidden if you don't want to list it in the list of available tasks.
+- You can use `nake` in *shebang*, so you can use your file with tasks as a runner.
+- *Arguments parsing*, everything what start with @--@ will be passed into options hash and everything other will be treated as an arguments. Both arguments and options will be passed as a block arguments for task, so you don't have to learn any new API, just use normal Ruby expressions as you are used to. Options are parsed into Ruby data types, so if you have @--without-mysql@, you'll get @{mysql: false}@, if you have @--name=botanicus@, you'll get @{name: "botanicus"}@ etc.
+- *Arbitrary names of tasks* is one of the key features of Nake. This way you can *namespace* your tasks (like @nake build:prerelease@) or you can define tasks like @-T@.
+- Two level of API for defining tasks. @task@ helper is useful for defining simple tasks and if you need something more complicated, you can use @Task.new@
+- *Interactive session* if you run @nake -i@ or @nake -i task@ you get an interactive nake session.
+
+h1. Usage
+
+First of all there is a bunch of "examples":github.com/botanicus/nake/tree/master/examples, so you can try them. All these scripts are executable, so just run @./executable/basic.rb -T@ and that's it!
+
+h1. Links
+
+- http://github.com/botanicus/filelist

data/TODO.txt

@@ -0,0 +1,7 @@
+- fix interactive task, it doesn't work so far
+- better argv parsing maybe, task(:spec) do |*paths, options| is fine, but task(:spec) do |path, options| will fail if no path specified ... but actually task(:spec) do |path = "spec", options| might be fine, try it ... BTW task(["-i", "--interactive"]) do |task, *args, options| doesn't work ... putting options as a first argument should solve everything, but it's not very intuitive :/
+- it might be worthy to steal filelist from Rake
+- how to solve args inheriting (like if we have task release which depends on task build which takes a gemspec as an argument)
+- benchmarks against rake
+- maybe some of: fileutils extensions, multitask, rule, file, directory (from rake, see http://rake.rubyforge.org/files/doc/rakefile_rdoc.html)
+- some default tasks like nake/tasks/package, nake/tasks/clean, nake/tasks/yardoc, nake/tasks/spec, nake/tasks/bundle

data/bin/nake

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "nake"
+
+# First argument has to be path to file with your tasks
+load ARGV.first
+
+# Parse arguments and run tasks
+begin
+  Nake.run(ARGV[1..-1])
+rescue TaskNotFound => exception
+  abort "[#{"ERROR".red}] #{exception.message}"
+end

data/examples/args.rb

@@ -0,0 +1,5 @@
+#!./bin/nake
+
+task(:greet2) do |user = ENV["USER"]|
+  puts "Hi #{user}!"
+end

data/examples/basic.rb

@@ -0,0 +1,7 @@
+#!./bin/nake
+
+# simple
+task(:greet1) do
+  puts "Hi #{ENV["USER"]}!"
+end
+

data/examples/complex.rb

@@ -0,0 +1,9 @@
+#!./bin/nake
+
+Task.new(:release) do |task|
+  task.description = "Just release it"
+  task.dependencies.clear # redefine
+  task.block do |*args|
+
+  end
+end

data/examples/default.rb

@@ -0,0 +1,10 @@
+#!./bin/nake
+
+# When you run rake without arguments, it will try to run task called default.
+# Since I don't believe in any stupid convention, I don't support anything similar,
+# because you can do it just using standard Ruby methods like Hash#default=(value)
+# Of course the task which you are assigning as a default have to already exist,
+# so you have to put this to the end of your file or you might want to use
+# Hash#default_proc=(proc) as described in examples/default_proc.rb like:
+# Task.tasks.default_proc = lambda { |*| Task[:build] }
+Task.tasks.default = Task["-T"]

data/examples/default_proc.rb

@@ -0,0 +1,11 @@
+#!./bin/nake
+
+# Default value returned from Task["not_existing_task"] don't have to be even a task,
+# it just have to respond to #call, so you can use Hash#default_proc=(proc) as well
+# Just make sure you are wrap the callable object in lambda, because the callable
+# object has to be returned as a result from the finding on the hash, but the
+# default proc is what is actually called if nothing is found.
+# You might i. e. customize error message or you might detect desired task in runtime.
+Task.tasks.default_proc = lambda do |tasks, name|
+  lambda { |*args| abort("Task #{name} executed with args: #{args.inspect}") }
+end

data/examples/dependencies.rb

@@ -0,0 +1,4 @@
+#!./bin/nake
+
+task = task(:greet3, :greet1, :greet2)
+task.description = "Run greet1 & greet2"

data/examples/helpers.rb

@@ -0,0 +1,3 @@
+#!./bin/nake
+
+task(:ls) { sh "ls" }.description = "List available files"

data/examples/invoking.rb

@@ -0,0 +1,5 @@
+#!./bin/nake
+
+task(:foo) do
+  Task[:bar].call
+end

data/examples/options.rb

@@ -0,0 +1,6 @@
+#!./bin/nake
+
+# ./examples/options.rb greet2 --name=botanicus
+task(:greet2) do |options|
+  puts "Hi #{options[:name]}!"
+end

data/examples/script.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby --disable-gems
+
+# This file shows how to run Nake from API. In most of cases you don't
+# need this and you might want to use just shebang with env, but this
+# might come handy if you need to pass some arguments for Ruby.
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "nake"
+
+# task definitions
+task("greet:all") do
+  puts "Hey guys!"
+end
+
+# run nake
+begin
+  Nake.run(ARGV)
+rescue TaskNotFound => exception
+  abort "[#{"ERROR".red}] #{exception.message}"
+end

data/lib/nake.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require "nake/argv"
+require "nake/task"
+
+module Nake
+  VERSION ||= "0.0.1"
+  TaskNotFound ||= Class.new(StandardError)
+
+  def self.run(args = ARGV)
+    name = args.shift
+    task = Task[name]
+    if name && task.nil?
+      raise TaskNotFound, "Task with name #{name} doesn't exist"
+    elsif name.nil? && task.nil?
+      raise TaskNotFound, "You have to specify a task you want to run!"
+    end
+    opts = args.extend(ArgvParsingMixin).extract!
+    task.call(args, opts)
+  end
+end
+
+require "nake/dsl"
+require "nake/helpers"
+require "nake/tasks"
+require "nake/colors"

data/lib/nake/argv.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Nake
+  module ArgvParsingMixin
+    def extract!
+      self.inject(Hash.new) do |options, argument|
+        case argument
+        when /^--no-([^=]+)$/ # --no-git-repository
+          options[$1.gsub("-", "_").to_sym] = false
+          self.delete(argument)
+        when /^--([^=]+)$/    # --git-repository
+          options[$1.gsub("-", "_").to_sym] = true
+          self.delete(argument)
+        when /^--([^=]+)=([^,]+)$/ # --controller=post
+          key, value = $1, $2
+          options[key.gsub("-", "_").to_sym] = value.dup
+          self.delete(argument)
+        when /^--([^=]+)=(.+)$/    # --controllers=posts,comments
+          key, value = $1, $2
+          options[key.gsub("-", "_").to_sym] = value.split(",")
+          self.delete(argument)
+        else
+          # just extract options and ignore others
+        end
+        options
+      end
+    end
+  end
+end

data/lib/nake/colors.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+begin
+  require "term/ansicolor"
+rescue LoadError
+  raise LoadError, "You have to install term-ansicolor gem!"
+end
+
+String.send(:include, Term::ANSIColor) # just for now, I know it's a mess

data/lib/nake/dsl.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require "nake/task"
+
+class Object
+  include Nake
+  # Rake-style task definition
+  # task(:release, :build) do |task|
+  #   # task definition
+  # end
+  def task(name, *dependencies, &block)
+    if block.nil?
+      Task.new(name, *dependencies)
+    else
+      Task.new(name, *dependencies) do |task|
+        task.define(&block)
+      end
+    end
+  end
+end

data/lib/nake/helpers.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require "fileutils"
+require "open3"
+
+module Nake
+  module TaskHelpers
+    include FileUtils
+    def sh(command)
+      puts "#{"$".magenta} #{command.cyan}"
+      Open3.popen3("sh", "-c", command) do |stdin, stdout, stderr|
+        puts stdout.readlines.map { |line| "  #{line}" }
+        puts stderr.readlines.map { |line| "  #{line.red}" }
+      end
+    end
+  end
+end
+
+Object.send(:include, Nake::TaskHelpers)

data/lib/nake/task.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require "nake/colors"
+
+module Nake
+  class Task
+    def self.[](name)
+      name = name.to_s
+      self.tasks[name] || self.find_in_aliases(name)
+    end
+
+    # @private
+    def self.find_in_aliases(name)
+      _, task = self.tasks.find { |_, task| task.aliases.include?(name) }
+      return task
+    end
+
+    def self.[]=(name, task)
+      self.tasks[name.to_s] = task
+    end
+
+    # @protected use Task[name] resp. Task[name] = task
+    def self.tasks
+      @@tasks ||= Hash.new
+    end
+
+    # return existing task if task with given name already exist
+    def self.new(name, *dependencies, &block)
+      task = self[name]
+      task && task.setup(*dependencies, &block) || super(name, *dependencies, &block)
+    end
+
+    attr_accessor :name, :description, :dependencies, :hidden, :options
+    attr_reader :blocks, :aliases
+    def initialize(name, *dependencies, &block)
+      @aliases, @hidden = Array.new, false
+      # This is a bit weird, but it's best solution
+      # when we want to keep API simple and keep it
+      # as one object even if it has more names
+      if name.respond_to?(:join) # array
+        name, *aliases = name
+        self.aliases.push(*aliases)
+      end
+      @name, @blocks = name.to_sym, Array.new
+      @dependencies  = Array.new
+      self.register
+      self.setup(*dependencies, &block)
+    end
+
+    def setup(*dependencies, &block)
+      self.dependencies.push(*dependencies)
+      self.instance_exec(self, &block) if block
+      return self
+    end
+
+    def define(&block)
+      @blocks.push(block)
+    end
+
+    def hidden?
+      @hidden
+    end
+
+    # NOTE: the reason why we don't have splat for args is that when we have Task["-T"]
+    # which doesn't have any args and options, we wall just call it without any arguments,
+    # but when we use splat, then we will have to call it at least with Hash.new for options
+    def call(args = Array.new, options = Hash.new)
+      unless @dependencies.empty?
+        puts "~ Invoking task #{name}".cyan
+        self.invoke_dependencies(*args, options)
+      end
+      unless @blocks.empty?
+        puts "~ Executing task #{name} with arguments #{args.inspect} and options #{options.inspect}".green
+        @blocks.each do |block|
+          if block.arity.eql?(0)
+            block.call
+          else
+            block.call(*args, options)
+          end
+        end
+      end
+    end
+
+    protected
+    def invoke_dependencies(*args, options)
+      self.dependencies.each do |name|
+        task = self.class[name]
+        raise TaskNotFound, "Task with name #{name} doesn't exist" if task.nil?
+        task.call(*args, options) # TODO: what about arguments?
+      end
+    end
+
+    def register
+      self.class[self.name] = self
+    end
+  end
+end

data/lib/nake/tasks.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require "nake/dsl"
+
+task(["-H", "--help"]) do
+  abort "\nUse #{$0} -T for list of all available tasks or -i for interactive session"
+end
+
+task(["-T", "--tasks"]) do |pattern, options = Hash.new|
+  tasks, options = Task.tasks.select { |name, task| not task.hidden? }.sort.partition { |key, value| not key.match(/^-/) }
+
+  puts "\n#{"===".yellow} #{"Available tasks".magenta} #{"===".yellow}"
+  if tasks.empty?
+    puts "No tasks defined"
+  else
+    tasks.each do |name, task|
+      puts "#{name.green} #{task.dependencies.join(", ")} # #{task.description || "no description yet"}"
+    end
+  end
+
+  puts "\n#{"===".yellow} #{"Available options".magenta} #{"===".yellow}"
+  if options.empty?
+    puts "No options defined"
+  else
+    options.each do |name, task|
+      puts "#{name.green} #{task.dependencies.join(", ")} # #{task.description || "no description yet"}"
+    end
+  end
+end
+
+# TODO: this doesn't work so far
+task(["-i", "--interactive"]) do |*args, options|
+  require "irb"
+  begin
+    require "irb/readline"
+  rescue LoadError
+    warn "Code completion via readline isn't available"
+  end
+
+  unless args.empty?
+    task = Task[args.shift]
+    task.call(*args, options)
+  end
+
+  IRB.start
+end
+
+Task["-T"].hidden = true
+Task["-H"].hidden = true

data/nake.gemspec

@@ -0,0 +1,42 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+# NOTE: we can't use require_relative because when we run gem build, it use eval for executing this file
+$:.unshift(File.join(File.dirname(__FILE__), "lib"))
+require "nake"
+
+Gem::Specification.new do |s|
+  s.name = "nake"
+  s.version = Nake::VERSION
+  s.authors = ["Jakub Šťastný aka Botanicus"]
+  s.homepage = "http://github.com/botanicus/nake"
+  s.summary = "Nake is light-weight and highly flexible Rake replacement with much better arguments parsing"
+  s.description = "" # TODO: long description
+  s.cert_chain = nil
+  s.email = ["knava.bestvinensis", "gmail.com"].join("@")
+  s.has_rdoc = true
+
+  # files
+  s.files = Dir.glob("**/*")
+  s.executables = ["nake"]
+  s.default_executable = "nake"
+  s.require_paths = ["lib"]
+
+  # Ruby version
+  s.required_ruby_version = ::Gem::Requirement.new("~> 1.9")
+
+  # dependencies
+  s.add_dependency "term-ansicolor"
+
+  begin
+    require "changelog"
+  rescue LoadError
+    warn "You have to have changelog gem installed for post install message"
+  else
+    changelog = CHANGELOG.new(File.join(File.dirname(__FILE__), "CHANGELOG"))
+    s.post_install_message = "=== Changes in the last Nake ===\n  - #{changelog.last_version_changes.join("\n-  ")}"
+  end
+
+  # RubyForge
+  s.rubyforge_project = "nake"
+end

data/nake.pre.gemspec

@@ -0,0 +1,8 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+# You might think this is a terrible mess and guess what, you're
+# right mate! However say thanks to authors of RubyGems, not me.
+eval(File.read("nake.gemspec")).tap do |specification|
+  specification.version = "#{Nake::VERSION}.pre"
+end

data/spec/nake/argv_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require_relative "../spec_helper"
+require "nake/argv"
+
+describe Nake::ArgvParsingMixin do
+  def parse(*args)
+    args.extend(Nake::ArgvParsingMixin)
+    args.extract!
+  end
+
+  describe "#parse!" do
+    it "should returns Hash" do
+      parse.should be_kind_of(Hash)
+    end
+
+    it "should parse --git-repository to {git_repository: true}" do
+      options = parse("--git-repository")
+      options[:git_repository].should be_true
+    end
+
+    it "should parse --no-github to {github: false}" do
+      options = parse("--no-github")
+      options[:github].should be_false
+    end
+
+    it "should parse --controller=posts to {controller: 'posts'}" do
+      options = parse("--controller=posts")
+      options[:controller].should eql("posts")
+    end
+
+    it "should parse --models=post,comment to {models: ['post', 'comment']}" do
+      options = parse("--models=post,comment")
+      options[:models].should eql(["post", "comment"])
+    end
+
+    it "should remove argument from ARGV if the argument was successfuly mapped to an option" do
+      args = ["--user=botanicus"]
+      args.extend(Nake::ArgvParsingMixin)
+      args.extract!
+      args.should be_empty
+    end
+
+    it "should not remove argument from ARGV if the argument wasn't mapped to an option" do
+      args = ["one", "two", "three"]
+      args.extend(Nake::ArgvParsingMixin)
+      args.extract!
+      args.length.should eql(3)
+    end
+  end
+end

data/spec/nake/dsl_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require_relative "../spec_helper"
+require "nake/dsl"
+
+describe "Object#task" do
+  before(:each) do
+    Nake::Task.tasks.clear
+  end
+
+  it "should take name as a first argument" do
+    task(:name).name.should eql(:name)
+  end
+
+  it "should optinally take other arguments as a dependencies" do
+    task(:release, :build, :tag).dependencies.should eql([:build, :tag])
+  end
+
+  it "should optinally take a block as a task definition" do
+    task = task(:release) { "released!" }
+    task.should have(1).blocks
+  end
+
+  it "should be able to add a dependencies to the task definition" do
+    task(:release, :build)
+    task(:release, :tag)
+    task(:release).dependencies.should eql([:build, :tag])
+  end
+
+  it "should be able to add a block to the task definition" do
+    task = task(:release) { "first block" }
+    task(:release) { "second block" }
+    -> { task(:release) { "released!" } }.should change { task.blocks.length }.by(1)
+  end
+end

data/spec/nake/helpers_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require_relative "../spec_helper"
+require "nake/helpers"
+
+describe Nake::TaskHelpers do
+  include Nake::TaskHelpers
+  describe "#sh" do
+    it "should be able to execute external commands"
+    it "should show which command runs"
+    it "should show STDOUT of the command"
+    it "should show STDERR of the command"
+  end
+end

data/spec/nake/task_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require_relative "../spec_helper"
+require "nake/task"
+
+describe Nake::Task do
+  before(:each) do
+    Nake::Task.tasks.clear
+  end
+
+  describe "[]" do
+    it "should find task with given name if the name is a symbol"
+    it "should find task with given name if the name is a string"
+    it "should find task with given alias if the alias is a symbol"
+    it "should find task with given alias if the alias is a string"
+  end
+
+  describe "[]=" do
+    it "should add the task into the Task.tasks hash with stringified key"
+  end
+
+  describe ".tasks" do
+  end
+
+  describe ".new" do
+    it "should returns already existing task object if this object exists" do
+      task = Task.new(:release)
+      Task.new(:release).object_id.should eql(task.object_id)
+    end
+  end
+
+  it "should take name as a first argument" do
+    Task.new("name").name.should eql(:name)
+  end
+
+  it "should take name as a first argument" do
+    Task.new(:name).name.should eql(:name)
+  end
+
+  describe "#define" do
+    it "should puts block into the task.blocks collection" do
+      task = Task.new(:name)
+      -> { task.define { "a block" } }.should change { task.blocks.length }.by(1)
+    end
+  end
+
+  describe "#hidden?" do
+    it "should not be hidden by default" do
+      task = Task.new(:name)
+      task.should_not be_hidden
+    end
+
+    it "should be true if the task is hidden" do
+      Task.new(:name).tap do |task|
+        task.hidden = true
+        task.should be_hidden
+      end
+    end
+
+    it "should be false if the task isn't hidden" do
+      Task.new(:name).tap do |task|
+        task.hidden = false
+        task.should_not be_hidden
+      end
+    end
+  end
+
+  describe "#call" do
+    it "should call all dependencies"
+    it "should call all blocks of the given task"
+  end
+end

data/spec/nake/tasks_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require_relative "../spec_helper"
+
+load "nake/tasks.rb"
+@result = STDOUT.capture { Task["-T"].call }
+
+describe "Default tasks" do
+  describe "-H" do
+    before(:each) do
+      load "nake/tasks.rb"
+    end
+
+    it "should be available as a -H or --help" do
+      Task["-H"].should eql(Task["--help"])
+    end
+
+    it "should print a message about using -T and exit" do
+      -> { Task["-H"].call }.should raise_error(SystemExit, /-T/)
+    end
+  end
+
+  describe "-T" do
+    before(:each) do
+      load "nake/tasks.rb"
+      task(:release, :build, :tag)
+      @result = STDOUT.capture { Task["-T"].call }
+    end
+
+    it "should list all available tasks" do
+      @result.should match("release")
+    end
+
+    it "should show description if there is any"
+
+    it "should list dependencies if some are available"
+
+    it "should list aliases"
+
+    it "should not show hidden tasks" do
+      @result.should_not match("-H")
+    end
+  end
+
+  describe "-i" do
+    # TODO
+  end
+end

data/spec/nake_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require_relative "spec_helper"
+require "nake"
+
+describe Nake do
+  describe ".run" do
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format
+progress
+--loadby
+mtime

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+begin
+  require "spec"
+rescue LoadError
+  abort "You have to install rspec gem!"
+end
+
+require "stringio"
+
+def STDOUT.capture(&block)
+  before = self
+  $stdout = StringIO.new
+  block.call
+  $stdout.rewind
+  output = $stdout.read
+  $stdout = before
+  output
+end

data/tasks.rb

@@ -0,0 +1,12 @@
+#!./bin/nake
+# encoding: utf-8
+
+task(:build) do
+  sh "gem build nake.gemspec"
+end
+
+# ./tasks.rb spec/nake/argv_spec.rb spec/nake/task_spec.rb
+task(:spec) do |*paths, options|
+  paths.push("spec") if paths.empty?
+  exec "spec #{paths.join(" ")}"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: nake
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Jakub \xC5\xA0\xC5\xA5astn\xC3\xBD aka Botanicus"
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2009-12-26 00:00:00 +00:00
+default_executable: nake
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: ""
+email: knava.bestvinensis@gmail.com
+executables: 
+- nake
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/nake
+- CHANGELOG
+- examples/args.rb
+- examples/basic.rb
+- examples/complex.rb
+- examples/default.rb
+- examples/default_proc.rb
+- examples/dependencies.rb
+- examples/helpers.rb
+- examples/invoking.rb
+- examples/options.rb
+- examples/script.rb
+- lib/nake/argv.rb
+- lib/nake/colors.rb
+- lib/nake/dsl.rb
+- lib/nake/helpers.rb
+- lib/nake/task.rb
+- lib/nake/tasks.rb
+- lib/nake.rb
+- LICENSE
+- nake-0.0.1.gem
+- nake.gemspec
+- nake.pre.gemspec
+- README.textile
+- spec/nake/argv_spec.rb
+- spec/nake/colors_spec.rb
+- spec/nake/dsl_spec.rb
+- spec/nake/helpers_spec.rb
+- spec/nake/task_spec.rb
+- spec/nake/tasks_spec.rb
+- spec/nake_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks.rb
+- TODO.txt
+has_rdoc: true
+homepage: http://github.com/botanicus/nake
+licenses: []
+
+post_install_message: |-
+  === Changes in the last Nake ===
+    - bin/nake executable
+  -  sh helper (nake/helpers)
+  -  task helper (nake/dsl)
+  -  Task with description, dependencies and blocks
+  -  Hidden tasks
+  -  Each task can has multiple aliases
+  -  Command line arguments parsing. Arguments will be passed as an arguments for blocks of the given task and options will be extracted into a hash, parsed into Ruby data types and passed as the last argument for the blocks.
+  -  Default tasks for help (-H, --help), list of available tasks (-T, --tasks) and interactive session (-i, --interactive)
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      version: "1.9"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: nake
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Nake is light-weight and highly flexible Rake replacement with much better arguments parsing
+test_files: []
+