nake 0.0.3 → 0.0.5

data/README.textile

@@ -2,9 +2,9 @@ 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.
+You might be wondering why to write yet another fucking task manager when we have Rake, Thor and others. Well, because all of them suck. 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.
+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 so I hope he will remove this awful bug, but hey, it's pretty bad anyway.
 
 h1. Features
 
@@ -20,6 +20,38 @@ 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. Documentation
+
+h2. Tasks
+
+h3. Options parsing
+
+h2. File Tasks
+
+h2. Task Helpers
+
+h2. Available Tasks
+
+h3. Built-in Tasks
+
+- @-T@
+- @-H@
+- @-i@
+
+h3. File @nake/tasks/bundle@
+
+This file contains only @bundle@ task which will load bundler @--no-cached@
+
+h3. File @nake/tasks/clean@
+
+h3. File @nake/tasks/gem@
+
+h3. File @nake/tasks/release@
+
+h3. File @nake/tasks/rip@
+
+h3. File @nake/tasks/spec@
+
 h1. Links
 
 * "RDoc.info API Docs":http://rdoc.info/projects/botanicus/nake

data/TODO.txt

@@ -1,7 +1,9 @@
+- task#setup (see Desktop/nake-setup.rb)
+- yardoc
+- specs
 - 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)
+- maybe some of: fileutils extensions, multitask, rule (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

@@ -3,13 +3,71 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
 
 require "nake"
+require "nake/args"
+require "nake/helpers"
 
+# TODO: what if I want to run:
+# ./bin/nake -T
+# ./bin/nake --verbose -T
+# ./examples/flags.rb --verbose
+
+# First file in arguments is separator between args for nake and for task
+# If there is no file in the arguments
+# co kdyz omezim tasky na list etc a nebudou moct mit --task etc?
+# nake --verbose list arg1 arg2 --with-something
+# => zmizi potreba aliasu
+# => potreba API pro mapovani na -T etc
+# Nake.args["-T"] = Nake::Task[:tasks]
+
+# !!!!!! --verbose neni runable task to jen switchuje naky shity, takze -T by melo fungovat tak, ze naplni Nake.parse[:task] s taskem co se ma runnout
 # First argument has to be path to file with your tasks
-load ARGV.first
 
-# Parse arguments and run tasks
+# parse arguments
+begin
+  Nake.parse
+rescue Exception => exception
+  puts "~ Arguments parsed into #{Nake.parse.inspect.green}"
+  puts "Exception occured during parsing arguments"
+  print_exception_with_backtrace_and_abort(exception)
+else
+  if Nake.parse[:nake].include?("--debug") # Nake.debug isn't initialized yet
+    puts "~ Arguments parsed into #{Nake.parse.inspect.green}"
+  end
+end
+
+# load task file
+if Nake.parse[:file]
+  begin
+    load Nake.parse[:file]
+  rescue Exception => exception
+    print_exception_with_backtrace_and_abort(exception)
+  end
+else
+  abort "You have to specify a file with tasks"
+end
+
+# run arguments
+# yes, arguments has to run after the task file is loaded
+begin
+  original_args = Nake.parse.dup
+  Nake.run_args
+rescue SystemExit => exception
+  exit exception.status
+rescue Exception => exception
+  puts "~ Arguments parsed into #{Nake.parse.inspect.green}"
+  puts "Exception occured setting nake flags"
+  print_exception_with_backtrace_and_abort(exception)
+else
+  if Nake.debug && Nake.parse != original_args
+    puts "~ Arguments changed into #{Nake.parse.inspect.green}"
+  end
+end
+
+# run tasks
 begin
-  Nake.run(ARGV[1..-1])
-rescue TaskNotFound, ConfigurationError => exception
-  abort "[#{"ERROR".red}] #{exception.message}"
+  Nake.run_task
+rescue SystemExit => exception
+  exit exception.status
+rescue Exception => exception
+  print_exception_with_backtrace_and_abort(exception)
 end

data/examples/arguments.rb

@@ -0,0 +1,12 @@
+#!./bin/nake
+
+# Arguments might be considered as a light-weight variant to tasks
+# There are two ways how you can use tasks:
+# 1) as a filter, just set a variable --debug
+# 2) add your own functionality and then use exit
+# 3) just set the task which will run afterwards
+Nake.args["-H", "--help"] = lambda { Kernel.abort("This is my customized help!") }
+Nake.args["-T", "--tasks"] = lambda { Nake.parse[:task].clear.push("tasks") }
+Nake.args["--debug", "--no-debug"] = lambda { |key, value| Nake.debug = value }
+
+# TODO: execution order, argument helper + args passing to the proc

data/examples/file.rb

@@ -0,0 +1,18 @@
+#!./bin/nake
+
+begin
+  require "recho"
+rescue LoadError
+  raise LoadError, "This task require recho gem!"
+end
+
+directory "tmp"
+directory "tmp/www"
+
+file("tmp/restart.txt", "tmp") do |path|
+  touch path
+end
+
+file "tmp/www/index.html", "tmp/www" do |path|
+  echo("<html>Hello World!</html>") > path
+end

data/examples/flags.rb

@@ -0,0 +1,15 @@
+#!./bin/nake --verbose
+
+# This example document how you can change different flags
+# - specify these flags in shebang
+# - use API directly
+# - ./examples/flags --verbose
+Nake.verbose = false
+
+task(:setup) do
+  puts "Setting environment ..."
+end
+
+task(:build, :setup) do
+  puts "Building ..."
+end

data/lib/nake.rb

@@ -1,27 +1,99 @@
 # encoding: utf-8
 
-require "nake/argv"
 require "nake/task"
 
 module Nake
-  VERSION ||= "0.0.3"
-  TaskNotFound ||= Class.new(StandardError)
-  ConfigurationError ||= Class.new(StandardError)
+  VERSION ||= "0.0.5"
+  def self.verbose
+    @@verbose
+  rescue NameError
+    @@verbose = true
+  end
+
+  def self.verbose=(boolean)
+    @@verbose = boolean
+  end
+
+  def self.debug
+    @@debug
+  rescue NameError
+    @@debug = true
+  end
 
-  def self.run(args = ARGV)
-    name = args.shift
+  def self.debug=(boolean)
+    @@debug = boolean
+  end
+
+  # I was drunk so you might found this code not very clear. But it's clear for me and it works.
+  def self.args
+    @@args ||= begin
+      Hash.new.tap do |hash|
+        hash.define_singleton_method(:[]) do |name|
+          names, value = self.find { |names, block| names.include?(name) }
+          return value
+        end
+
+        hash.define_singleton_method(:[]=) do |*names, proc|
+          super(names, proc)
+        end
+      end
+    end
+  end
+
+  def self.parse(args = ARGV)
+    @result ||= begin
+      args.inject(Hash.new) do |hash, argument|
+        hash[:nake] ||= Array.new
+        hash[:task] ||= Array.new
+        hash[:file] ||= "tasks.rb" if File.exist?("tasks.rb")
+        if argument.match(/^-/) && hash[:task].empty?
+          hash[:nake].push(argument)
+        elsif File.exist?(argument)
+          hash[:file] = argument
+        else
+          hash[:task].push(argument)
+        end
+        hash
+      end
+    end
+  end
+
+  def self.run_args
+    # TODO: proceed --debug and --verbose first! ... to by slo tak, ze by se iterovalo pres Nake.args a pokud je to pritomno tak proved
+    Nake.parse[:nake].each do |argument|
+      unless self.args[argument]
+        abort "Unrecognized argument: #{argument}"
+      end
+      name, value = ArgvParser.parse(argument)
+      if name
+        info "Invoking argument #{argument} with #{name} = #{value}"
+        self.args[argument].call(name, value)
+      else
+        info "Invoking argument #{argument} without any arguments"
+        self.args[argument].call
+      end
+    end
+  end
+
+  # Run first task
+  #
+  # @raise [TaskNotFound]
+  # @example
+  #   Nake.run(["release"])
+  # @since 0.0.1
+  # @author Jakub Stastny
+  def self.run_task
+    name, *args = Nake.parse[:task]
     task = Task[name]
-    if name && task.nil?
-      raise TaskNotFound, "Task with name #{name} doesn't exist"
-    elsif name.nil? && task.nil?
+    if name.nil?
       raise TaskNotFound, "You have to specify a task you want to run!"
+    elsif task.nil?
+      raise TaskNotFound, "Task with name #{name} doesn't exist"
+    else
+      task.run(args)
     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/args.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require "nake/dsl"
+
+argument("-H", "--help") do
+  Kernel.abort "Use #{$0} -T for list of all available tasks or -i for interactive session"
+end
+
+argument("-T", "--tasks") do |pattern = nil|
+  tasks, options = Task.tasks.select { |name, task| not task.hidden? }.sort.partition { |key, value| not key.match(/^-/) }
+  arguments = Nake.args.sort
+
+  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 arguments".magenta} #{"===".yellow}"
+  if arguments.empty?
+    puts "No arguments defined"
+  else
+    arguments.each do |names, proc|
+      puts "#{names.join(" or ").green}" # TODO: description
+    end
+  end
+  exit
+end
+
+argument("-i", "--interactive") do |task = nil|
+  ARGV.clear # otherwise IRB will parse it
+
+  require "irb"
+  begin
+    require "irb/readline"
+  rescue LoadError
+    warn "Code completion via readline isn't available"
+  end
+
+  if task
+    Task[task].tap { |task| task.call(*args, options) }
+  end
+
+  IRB.start
+  exit!
+end
+
+Nake.args["--verbose", "--no-verbose"] = lambda { |key, value| Nake.verbose = value }
+Nake.args["--debug", "--no-debug"]     = lambda { |key, value| Nake.debug = value }

data/lib/nake/argv.rb

@@ -1,29 +1,47 @@
 # 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
+  module ArgvParser
+    def self.extract!(args)
+      args.dup.inject(Hash.new) do |options, argument|
+        key, value = self.parse(argument)
+        if key
+          options[key] = value
+          args.delete(argument)
         end
         options
       end
     end
+
+    def self.extract(args)
+      args.inject(Hash.new) do |options, argument|
+        key, value = self.parse(argument)
+        if key
+          options[key] = value
+        end
+        options
+      end
+    end
+
+    def self.parse!(argument)
+      self.parse(argument) || raise("Argument #{argument} can't be parsed!")
+    end
+
+    def self.parse(argument)
+      case argument
+      when /^--no-([^=]+)$/ # --no-git-repository
+        return [$1.gsub("-", "_").to_sym, false]
+      when /^--([^=]+)$/    # --git-repository
+        return [$1.gsub("-", "_").to_sym, true]
+      when /^--([^=]+)=([^,]+)$/ # --controller=post
+        key, value = $1, $2
+        return [key.gsub("-", "_").to_sym, value.dup]
+      when /^--([^=]+)=(.+)$/    # --controllers=posts,comments
+        key, value = $1, $2
+        return [key.gsub("-", "_").to_sym, value.split(",")]
+      else
+        return false
+      end
+    end
   end
 end

data/lib/nake/dsl.rb

@@ -1,9 +1,15 @@
 # encoding: utf-8
 
+require "nake"
 require "nake/task"
+require "nake/file_task"
 
 class Object
   include Nake
+  def argument(*names, &block)
+    Nake.args[*names] = block
+  end
+
   # Rake-style task definition
   # task(:release, :build) do |task|
   #   # task definition
@@ -17,4 +23,24 @@ class Object
       end
     end
   end
+
+  def file(path, *dependencies, &block)
+    if block.nil?
+      FileTask.new(path, *dependencies)
+    else
+      FileTask.new(path, *dependencies) do |task|
+        task.define(&block)
+      end
+    end
+  end
+
+  def directory(path)
+    FileTask.new(path) do |task|
+      task.hidden = true # do not show in list
+      task.description = "Create directory #{path}"
+      task.define do
+        mkdir_p path
+      end
+    end
+  end
 end

data/lib/nake/file_task.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require "nake/task"
+
+module Nake
+  class FileTask < Task
+    alias_method :path, :name
+    # FileTask can depend on tasks, other file tasks or just files.
+    # If a file task depends on a task, this task isn't supposed to change anything what ...
+    # ... if it's changing something, make sure the changing task is actually called before the file tasks are executed
+    # If the task is changing something so the file will be generated in all cases, you should rather to use normal task
+    # If there are some dependencies on files
+    # FileTask.new("www/index.html") do |task|
+    #   task.file_dependencies.push(*FileList["images/**/*"])
+    #   task.dependencies.push("www") # www task exist
+    # end
+    def call(args = Array.new, options = Hash.new)
+      will_run = true
+      unless self.dependencies.empty?
+        info "Invoking file task #{name}"
+        will_run = self.invoke_dependencies(*args, options)
+      end
+      if will_run && ! self.blocks.empty?
+        note "Executing file task #{name} with arguments #{args.inspect} and options #{options.inspect}"
+        debug "Config #{self.config.inspect}"
+        self.blocks.each do |block|
+          block.call(self.path, *args, options)
+        end
+      else
+        warn "File task #{name} won't be executed"
+      end
+    end
+
+    protected
+    # task will be executed just if
+    def will_run?
+      file_tasks = self.dependencies.select { |name| self.class[name] }
+      file_tasks.any? do |path|
+
+      end
+    end
+
+    def task_will_run?(path)
+      File.exist?(path) || File.mtime(path) < File.mtime(self.name)
+    end
+
+    # return true if the task need to be executed, false otherwise
+    def invoke_dependencies(*args, options)
+      self.dependencies.each do |name|
+        if task = self.class[name] # first try if there is a task with given name
+          task.call(*args, options) # TODO: what about arguments?
+        elsif File.exist?(name) # if not, then fallback to file
+          task_will_run?(name)
+        else
+          raise TaskNotFound, "Task with name #{name} doesn't exist"
+        end
+      end
+    end
+  end
+end

data/lib/nake/helpers.rb

@@ -1,21 +1,65 @@
 # encoding: utf-8
 
 require "fileutils"
+require "nake/colors"
 
 module Nake
   module TaskHelpers
     include FileUtils
-    alias_method :run, :`
+    def run(*parts)
+      puts parts.join(" ").cyan
+      system(*parts)
+    end
 
     # return true if process suceeded, false otherwise
     # sh "ls -a"
     # sh "ls", "-a"
     def sh(*parts)
       puts "#{"$".magenta} #{parts.join(" ").cyan}"
-      run "#{parts.shift} #{parts.join(" ")}"
-      $?.success?
+      system("sh", "-c", *parts)
+    end
+
+    # zsh "ls .*(.)"
+    def zsh(*parts)
+      puts "#{"%".magenta} #{parts.join(" ").cyan}"
+      system("zsh", "-c", *parts)
+    end
+  end
+
+  module PrintHelpers
+    def info(message)
+      puts "~ #{message}".cyan if Nake.verbose
+    end
+
+    def note(message)
+      puts "~ #{message}".green if Nake.verbose
+    end
+
+    def warn(message)
+      Kernel.warn("~ #{message.yellow}") if Nake.debug
+    end
+
+    def debug(message)
+      STDERR.puts("~ #{message.yellow}") if Nake.debug
+    end
+
+    def error(message)
+      STDERR.puts "~ #{message}".red
+    end
+
+    def abort(message)
+      Kernel.abort "[#{"ERROR".red}] #{message}"
+    end
+
+    def print_exception_and_abort(exception)
+      abort exception.message
+    end
+
+    def print_exception_with_backtrace_and_abort(exception)
+      abort [exception.message, exception.backtrace.join("\n- ")].join("\n")
     end
   end
 end
 
 Object.send(:include, Nake::TaskHelpers)
+Object.send(:include, Nake::PrintHelpers)

data/lib/nake/task.rb

@@ -1,8 +1,12 @@
 # encoding: utf-8
 
 require "nake/colors"
+require "nake/argv"
 
 module Nake
+  TaskNotFound ||= Class.new(StandardError)
+  ConfigurationError ||= Class.new(StandardError)
+
   class Task
     def self.[](name)
       name = name.to_s
@@ -30,7 +34,7 @@ module Nake
       task && task.setup(*dependencies, &block) || super(name, *dependencies, &block)
     end
 
-    attr_accessor :name, :description, :dependencies, :hidden
+    attr_accessor :name, :description, :dependencies, :hidden, :original_args
     attr_reader :blocks, :aliases
     def initialize(name, *dependencies, &block)
       @aliases, @hidden = Array.new, false
@@ -48,8 +52,14 @@ module Nake
     end
 
     def config
-      @config ||= Hash.new do |hash, key|
-        raise ConfigurationError, "Configuration key #{key} in task #{name} doesn't exist"
+      @config ||= begin
+        Hash.new do |hash, key|
+          raise ConfigurationError, "Configuration key #{key} in task #{name} doesn't exist"
+        end.tap do |hash|
+          hash.define_singleton_method(:declare) do |*keys|
+            keys.each { |key| self[key] = nil }
+          end
+        end
       end
     end
 
@@ -67,18 +77,33 @@ module Nake
       @hidden
     end
 
+    def run(args)
+      self.original_args = args
+      options = ArgvParser.extract!(args)
+      self.call(args, options)
+    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 self.dependencies.empty?
-        puts "~ Invoking task #{name}".cyan
+        info "Invoking task #{name}"
         self.invoke_dependencies(*args, options)
       end
       unless self.blocks.empty?
-        puts "~ Executing task #{name} with arguments #{args.inspect} and options #{options.inspect}".green
+        note "Executing task #{name} with arguments #{args.inspect} and options #{options.inspect}"
+        debug "Config #{self.config.inspect}"
         self.blocks.each do |block|
-          if block.arity.eql?(0)
+          # we can't use arity, because it returns 0 for lambda { |options = Hash.new| }.arity
+          # if we define method with one optional argument, it will returns -1
+
+          if RUBY_VERSION >= "1.9.2"
+            raise ArgumentError, "Task can't take block arguments" if args.length + 1 > block.parameters.select { |type, name| type.eql?(:req) || type.eql?(:opt) }.length
+            raise ArgumentError, "Task can't take block arguments" if block.parameters.any? { |type, name| type.eql?(:block) }
+          end
+
+          if RUBY_VERSION >= "1.9.2" && block.parameters.empty?
             block.call
           else
             block.call(*args, options)
@@ -87,6 +112,12 @@ module Nake
       end
     end
 
+    def reset!
+      self.dependencies.clear
+      self.blocks.clear
+      self.aliases.clear
+    end
+
     protected
     def invoke_dependencies(*args, options)
       self.dependencies.each do |name|

data/lib/nake/tasks/bundle.rb

@@ -1,9 +1,18 @@
 # encoding: utf-8
 
+require "nake/task"
+
 # NOTE: if you have bundler bundled locally, just
 # add bundler/lib into $: and this task will work
-Task.new(:bundle) do |task|
+Nake::Task.new(:bundle) do |task|
   task.description = "Install your gems locally from gems/cache via bundler"
+
+  # define bundler method, so we can test it
+  task.define_singleton_method(:bundler) do
+    @bundler ||= Gem::Commands::BundleCommand.new
+  end
+
+  # task definition
   task.define do |*args, options|
     require 'rubygems'
     require 'rubygems/command'
@@ -15,7 +24,7 @@ Task.new(:bundle) do |task|
       abort "You have to have bundler installed!"
     end
 
-    args.push("--cached")
-    Gem::Commands::BundleCommand.new.invoke(*args)
+    args.push("--cached") unless options.delete[:cached]
+    self.bundler.invoke(*task.original_args)
   end
 end

data/lib/nake/tasks/gem.rb

@@ -6,6 +6,12 @@ require "nake/tasks/clean"
 # register gem files for cleaning
 Task[:clean].config[:files].push(*Dir["*.gem"])
 
+module Nake::PackageMixin
+  def gem_name
+    "#{Task[:release].config[:name]}-#{Task[:release].config[:version]}.gem"
+  end
+end
+
 # require "nake/tasks/gem"
 # Task[:build].config[:gemspec] = Dir["*.gemspec"]
 Task.new(:build) do |task|
@@ -13,3 +19,11 @@ Task.new(:build) do |task|
     sh "gem build #{task.config[:gemspec]}"
   end
 end
+
+Task.new(:install, :build) do |task|
+  task.extend(PackageMixin)
+  task.description = "Install"
+  task.define do
+    sh "gem install #{self.gem_name}"
+  end
+end

data/lib/nake/tasks/release.rb

@@ -35,9 +35,9 @@ end
 Task.new("release:gemcutter") do |task|
   task.description  = "Push gem to Gemcutter"
   task.dependencies = [:clean, :build]
+  task.extend(PackageMixin)
   task.define do
-    task.config[:gem] = "#{Task[:release].config[:name]}-#{Task[:release].config[:version]}.gem"
     puts "Pushing to Gemcutter ..."
-    sh "gem push #{task.config[:gem]}"
+    sh "gem push #{self.gem_name}"
   end
 end

data/lib/nake/tasks/rip.rb

@@ -1,25 +1,33 @@
 # encoding: utf-8
 
-dependencies = FileList["vendor/*/.git"].sub(/\/\.git$/, "")
-
-desc "Regenerate deps.rip"
-file "deps.rip" => dependencies do
-  commits = Hash.new
-  commits = dependencies.inject(Hash.new) do |hash, path|
-    Dir.chdir(path) do
-      revision = %x(git show | head -1).chomp.sub("commit ", "")
-      hash[File.basename(path)] = revision
-      hash
-    end
-  end
-  template = File.read("deps.rip.rbe")
-  deps_rip = eval("%Q{#{template}}")
-  File.open("deps.rip", "w") do |file|
-    file.puts(deps_rip)
-  end
-  sh "chmod +x deps.rip"
-  sh "git commit deps.rip -m 'Updated deps.rip'"
+begin
+  require "recho"
+rescue LoadError
+  raise LoadError, "This task require recho gem!"
 end
 
+require "nake/file_task"
+
+# FileTask["deps.rip"].config[:versions] = {rack: "1.0.1", media_path: "SHA1"}
+
 # register task
-Task[:release].dependencies.unshift("deps.rip")
+#Task[:release].dependencies.unshift("deps.rip")
+
+# deps.rip.str:
+##!/usr/bin/env rip install
+#
+## Syntax:
+## repository [tag or commit to install]
+#git://github.com/botanicus/media-path.git %{media_path}
+#git://github.com/rack/rack.git %{rack}
+
+FileTask.new("deps.rip", "deps.rip.str") do |task|
+  task.config[:versions] = Hash.new
+  task.description = "Regenerate deps.rip"
+  task.define do
+    data = File.read("deps.rip.str")
+    dependencies = "%Q{#{data}}" % task.config[:versions]
+    FileUtils.echo("deps.str") > dependencies
+    sh "chmod +x deps.rip"
+  end
+end

data/spec/nake/tasks/bundle_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require_relative "../../spec_helper"
+require "nake/tasks/bundle"
+
+describe "Task bundle" do
+  before(:each) do
+    @task = Nake::Task[:bundle]
+    @bundler = Object.new.define_singleton_method(:invoke) { |*args| args }
+    @task.define_singleton_method(:bundler) { @bundler }
+  end
+
+  it "should invoke bundler with --cached by default" do
+    @task.call.should include("--cached")
+  end
+
+  it "should invoke bundler without --cached if --no-cached argument is provided" do
+    @task.call(cached: false).should_not include("--cached")
+  end
+
+  it "should not pass --no-cached argument to bundler" do
+    @task.call(cached: false).should_not include("--no-cached")
+  end
+
+  it "should pass all other arguments to bundler" do
+    @task.call("--only", "development").should eql(["--only", "development"])
+  end
+end

data/tasks.rb

@@ -5,7 +5,18 @@ require "nake/tasks/gem"
 require "nake/tasks/spec"
 require "nake/tasks/release"
 
+begin
+  load "code-cleaner.nake"
+rescue LoadError
+  warn "If you want to contribute to nake, you have to install code-cleaner gem and then run ./tasks.rb hooks:whitespace:install to get Git pre-commit hook for removing trailing whitespace and improving code quality in general."
+end
+
 Task[:build].config[:gemspec] = "nake.gemspec"
 Task[:prerelease].config[:gemspec] = "nake.pre.gemspec"
 Task[:release].config[:name] = "nake"
 Task[:release].config[:version] = Nake::VERSION
+
+Nake::Task["hooks:whitespace:install"].tap do |task|
+  task.config[:encoding] = "utf-8"
+  task.config[:whitelist] = '(bin/[^/]+|.+\.(rb|rake|nake|thor|task))$'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: nake
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.5
 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
+date: 2009-12-29 00:00:00 +01:00
 default_executable: nake
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -33,19 +33,24 @@ files:
 - bin/nake
 - CHANGELOG
 - examples/args.rb
+- examples/arguments.rb
 - examples/basic.rb
 - examples/complex.rb
 - examples/configuration.rb
 - examples/default.rb
 - examples/default_proc.rb
 - examples/dependencies.rb
+- examples/file.rb
+- examples/flags.rb
 - examples/helpers.rb
 - examples/invoking.rb
 - examples/options.rb
 - examples/script.rb
+- lib/nake/args.rb
 - lib/nake/argv.rb
 - lib/nake/colors.rb
 - lib/nake/dsl.rb
+- lib/nake/file_task.rb
 - lib/nake/helpers.rb
 - lib/nake/task.rb
 - lib/nake/tasks/bundle.rb
@@ -54,7 +59,6 @@ files:
 - lib/nake/tasks/release.rb
 - lib/nake/tasks/rip.rb
 - lib/nake/tasks/spec.rb
-- lib/nake/tasks.rb
 - lib/nake.rb
 - LICENSE
 - nake.gemspec
@@ -64,13 +68,16 @@ files:
 - spec/nake/argv_spec.rb
 - spec/nake/colors_spec.rb
 - spec/nake/dsl_spec.rb
+- spec/nake/file_task_spec.rb
 - spec/nake/helpers_spec.rb
 - spec/nake/task_spec.rb
+- spec/nake/tasks/bundle_spec.rb
 - spec/nake/tasks_spec.rb
 - spec/nake_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - tasks.rb
+- tmp/restart.txt
 - TODO.txt
 has_rdoc: true
 homepage: http://github.com/botanicus/nake

data/lib/nake/tasks.rb

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