do_riak 0.10.1.pre

data/gems/gems/nake-0.0.8/TODO.txt

@@ -0,0 +1,23 @@
+=== 0.1 ===
+- README
+- update examples
+- features
+
+- task inheritance => sharing config via super
+- rework rule
+- check if everything works
+- specs
+- update benchmarks
+- yardoc
+- refactor bin/nake
+
+=== 0.2 ===
+Task.new(:test) do |task|
+  task.options[:optional] = [:force] # maybe {force: :boolean}
+  task.options[:required] = [:name]
+end
+=> better -T list + validations
+
+=== 0.3 ===
+- nrake & nake/rake for running rake tasks in nake
+- rake2nake

data/gems/gems/nake-0.0.8/bin/nake

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "nake"
+require "nake/args"
+require "nake/helpers"
+
+# 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] && 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
+elsif File.exist?("tasks.rb")
+  # default value, useful when running nake on systems without
+  # shebang support, so you are using nake -T instead of ./tasks.rb -T
+  Nake.parse[:file] = "tasks.rb"
+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_task
+rescue TaskNotFound => exception
+  abort exception.message
+rescue SystemExit => exception
+  exit exception.status
+rescue Exception => exception
+  print_exception_with_backtrace_and_abort(exception)
+end
+
+# exit with exit status of the last command
+exit $? ? $?.exitstatus : 0

data/gems/gems/nake-0.0.8/bin/nrake

@@ -0,0 +1,4 @@
+#!/usr/bin/env nake
+
+# Run rake tasks with nake
+require "nake/rake"

data/gems/gems/nake-0.0.8/bin/rake2nake

@@ -0,0 +1 @@
+#!/usr/bin/env ruby

data/gems/gems/nake-0.0.8/bin/snake

@@ -0,0 +1,41 @@
+#!/usr/bin/env nake
+
+# Snake is similar to sake http://www.rubyinside.com/sake-system-wide-rake-tasks-543.html
+
+# tasks
+
+# snake get db_tasks.rb
+# snake get http://gist.github.com/raw/266818/7239049c59b32d07a8af7e26f89190b61e0a7860/snake.rb
+Task.new(:get) do |task|
+  task.description = "Add tasks from given file or URL to your %{task_file}"
+
+  task.define do |path|
+    require "open-uri"
+    begin
+      open(path) do |stream|
+        File.open(self.config[:task_file], "a") do |file|
+          file.puts(stream.read, "")
+        end
+      end
+    rescue Exception => exception
+      abort exception.message
+    end
+  end
+end
+
+Task.new(:edit) do |task|
+  task.config = Task[:get].config
+  task.description = "Edit %{task_file} in your editor"
+
+  task.define do
+    exec((ENV["EDITOR"] || "vim"), task.config[:task_file])
+  end
+end
+
+# setup
+Task[:get].config[:task_file] = File.expand_path("~/.tasks.rb")
+
+# run
+if File.exist?(Task[:get].config[:task_file])
+  load Task[:get].config[:task_file]
+end

data/gems/gems/nake-0.0.8/bm/Rakefile

@@ -0,0 +1,28 @@
+desc "Simple task"
+task :simple do
+  puts "Hello World!"
+end
+
+desc "Namespaced task"
+task "a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z" do
+  # do nothing
+end
+
+desc "Task with arguments"
+task :arguments
+
+desc "Task with dependencies"
+task :dependencies
+
+directory "tmp/www"
+
+desc "Generate tmp/www/index.html"
+file "tmp/www/index.html" => "tmp/www" do |task|
+  File.open(task.name, "w") do |file|
+    file.puts("<html>Hello World!</html>")
+  end
+end
+
+rule ".o" => [".c"] do |task|
+  sh "gcc #{task.source} -c -o #{task.name}"
+end

data/gems/gems/nake-0.0.8/bm/bms.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = nil # shut up
+
+require "rbench"
+
+rake = `which rake`.chomp
+nake = "./bin/nake"
+
+abort "You have to install Rake!" if rake.empty?
+puts "Using nake from #{nake} and rake from #{rake}\n\n"
+
+def run(command)
+  system("#{command} &> /dev/null") || abort("Problem during running #{command}")
+end
+
+# Make sure you are running both Rake and Nake on the same Ruby version!
+RBench.run(10) do
+  column :rake
+  column :nake
+
+  report "list tasks" do
+    rake { run "#{rake} -T" }
+    nake { run "#{nake} -T" }
+  end
+
+  report "simple task" do
+    rake { run "#{rake} simple" }
+    nake { run "#{nake} simple" }
+  end
+
+  report "namespaced task" do
+    rake { run "#{rake} a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z" }
+    nake { run "#{nake} a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z" }
+  end
+
+  #report "task with arguments" do
+  #  rake { run "#{rake} arguments" }
+  #  nake { run "#{nake} arguments" }
+  #end
+  #
+  #report "task with dependencies" do
+  #  rake { run "#{rake} dependencies" }
+  #  nake { run "#{nake} dependencies" }
+  #end
+
+  report "file task" do
+    rake { run "#{rake} tmp/www/index.html" }
+    nake { run "#{nake} tmp/www/index.html" }
+  end
+
+  #report "rule" do
+  #  rake { run "#{rake} tmp/test.o" }
+  #  nake { run "#{nake} tmp/test.o" }
+  #end
+end

data/gems/gems/nake-0.0.8/bm/output.txt

@@ -0,0 +1,5 @@
+Using nake from ./bin/nake and rake from /Users/botanicus/.rvm/ruby-1.9.1-p376/bin/rake
+
+                      RAKE |    NAKE |
+--------------------------------------
+list tasks           2.676 |   0.580 |

data/gems/gems/nake-0.0.8/bm/tasks.rb

@@ -0,0 +1,21 @@
+#!../bin/nake
+
+task :simple do
+  puts "Hello World!"
+end
+
+task "a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z" do
+  # do nothing
+end
+
+directory "tmp/www"
+
+file "tmp/www/index.html", "tmp/www" do |path|
+  File.open(path, "w") do |file|
+    file.puts("<html>Hello World!</html>")
+  end
+end
+
+#rule ".o" => [".c"] do |task|
+#  sh "gcc #{task.source} -c -o #{task.name}"
+#end

data/gems/gems/nake-0.0.8/bm/tmp/test.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main() {
+  printf("Hello World!\n");
+  return 0;
+}

data/gems/gems/nake-0.0.8/bm/tmp/www/index.html

@@ -0,0 +1 @@
+<html>Hello World!</html>

data/gems/gems/nake-0.0.8/deps.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env rip install
+
+# Syntax:
+# repository [tag or commit to install]
+git://github.com/flori/term-ansicolor

data/gems/gems/nake-0.0.8/deps.rip

@@ -0,0 +1,5 @@
+#!/usr/bin/env rip install
+
+# Syntax:
+# repository [tag or commit to install]
+git://github.com/flori/term-ansicolor

data/gems/gems/nake-0.0.8/examples/arguments.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ./bin/nake --debug
+
+# This example document how you can change different flags
+# - specify these flags in shebang
+# - use API directly
+# - ./examples/flags --verbose
+Nake.verbose = false
+
+# 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!") }
+
+task(:tasks) { puts "Available tasks: #{Nake::Task.tasks.keys.join(", ")}" }
+Nake.args["-T", "--tasks"] = lambda { |*| Nake.parse[:task].clear.push("tasks") }
+
+argument("--debug", "--no-debug") do |key, value|
+  puts "~ Setting #{key} to #{value}"
+  Nake.debug = value
+end
+
+# ./examples/arguments.rb --report greet
+# ./examples/arguments.rb --report wait
+task(:greet) { puts "Hey mate!" }
+task(:wait)  { sleep(1) }
+
+argument("--report") do |*|
+  @before = Time.now
+  at_exit do
+    task = Nake.parse[:task].first
+    time = Time.now - @before
+    puts "Running task #{task} took #{time} seconds"
+  end
+end
+
+# TODO: execution order, argument helper + args passing to the proc

data/gems/gems/nake-0.0.8/examples/basic.rb

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

data/gems/gems/nake-0.0.8/examples/boot.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ./bin/nake
+
+# You might want to give more useful description, however you don't have access
+# to some variables so far ... at least with Rake. Nake provides boot method which
+# run after everything is loaded, and if you specify optional dependencies for the
+# boot method, it will run the boot block of specified tasks first. This might come
+# handy time to time, but usually it's enough to use it without arguments since you
+# usually need just to load the whole task file where is all the configuration.
+
+# Typical usecases:
+# - you want to provide concrete info in description
+# - you need to access configuration of a task on other place than in the define block
+
+Task.new(:build) do |task|
+  task.boot(:release) do
+    task.description = "Release version #{Task[:release].config[:version]}"
+  end
+end

data/gems/gems/nake-0.0.8/examples/complex.rb

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

data/gems/gems/nake-0.0.8/examples/configuration.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ./bin/nake
+
+# this will be probably in a library
+Task.new(:build) do |task|
+  task.define do
+    sh "gem build #{task.config[:gemspec]}"
+  end
+end
+
+# and this in your file with tasks
+Task[:build].config[:gemspec] = "nake.gemspec"
+
+# if the task isn't defined yet
+task(:mytask)
+Task[:mytask].config[:name] = "foo"

data/gems/gems/nake-0.0.8/examples/default.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ./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 = Nake.args["-T"] #Task["-T"]

data/gems/gems/nake-0.0.8/examples/default_proc.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ./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/gems/gems/nake-0.0.8/examples/dependencies.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ./bin/nake
+
+# You can do the same by adding Task[name].call in the define block, but please,
+# don't use this approach. Dependencies are readable and if someone wants to,
+# he can simply remove a dependency from the dependency array.
+task(:greet1)
+task(:greet2)
+
+task = task(:greet3, :greet1, :greet2)
+task.description = "Run greet1 & greet2"

data/gems/gems/nake-0.0.8/examples/description.rb

@@ -0,0 +1,33 @@
+desc :release, "Create a new release"
+task(:release) do
+  # ...
+end
+
+task = task(:release) do
+  # ...
+end
+task.description = "Create a new release"
+
+task(:release) do
+  # ...
+end
+Task[:release].description = "Create a new release"
+
+task = task(:release)
+task.description = "Create a new release"
+task.define do
+  # ...
+end
+
+task(:release)
+Task[:release].description = "Create a new release"
+task(:release) do
+  # ...
+end
+
+Task.new(:release) do |task|
+  task.description = "Create a new release"
+  task.define do
+    # ...
+  end
+end