do_riak 0.10.1.pre

data/gems/gems/nake-0.0.8/lib/nake/abstract_task.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+require "nake/colors"
+require "nake/argv"
+
+module Nake
+  TaskNotFound ||= Class.new(StandardError)
+  ConfigurationError ||= Class.new(StandardError)
+
+  class AbstractTask
+    def self.[](name)
+      self.tasks[name.to_s]
+    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
+
+    def self.boot
+      self.tasks.each do |name, task|
+        task.boot!
+      end
+    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, :dependencies, :hidden, :original_args
+    attr_reader :blocks
+    def initialize(name, *dependencies, &block)
+      @hidden = false
+      @name, @blocks = name.to_sym, Array.new
+      @dependencies  = Array.new
+      self.register
+      self.setup(*dependencies, &block)
+    end
+
+    attr_writer :description
+    def description
+      if @description.respond_to?(:call)
+        # task.description = lambda { "Edit #{self.config[:task_file]}" }
+        @description.call
+      elsif @description
+        # task.description = "Edit %{task_file}"
+        @description % self.config
+      else
+        nil
+      end
+    end
+
+    attr_writer :config # don't use this if you don't have to!
+    def config
+      @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 unless self.has_key?(key) }
+          end
+        end
+      end
+    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
+
+    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?
+        info "Invoking task #{name}"
+        self.invoke_dependencies(*args, options)
+      end
+      unless self.blocks.empty?
+        note "Executing task #{name} with arguments #{args.inspect} and options #{options.inspect}"
+        debug "Config #{self.config.inspect}"
+        self.blocks.each do |block|
+          block.call(*args, options)
+        end
+        ## 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
+        #
+        ## 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 :/
+        #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)
+        #end
+      end
+    end
+
+    def bootloaders
+      @bootloaders ||= Array.new
+    end
+
+    def boot_dependencies
+      @boot_dependencies ||= Array.new
+    end
+
+    def boot(*dependencies, &block)
+      self.boot_dependencies.push(*dependencies)
+      self.bootloaders.push(block)
+    end
+
+    def boot!
+      unless self.boot_dependencies.empty? && self.bootloaders.empty?
+        note "Booting #{self.name}"
+      end
+      while dependency = self.boot_dependencies.shift
+        self.class[dependency].tap do |task|
+          if task.nil?
+            raise TaskNotFound, "Task #{dependency} doesn't exist!"
+          end
+          task.boot!
+        end
+      end
+      while block = self.bootloaders.shift
+        block.call
+      end
+    end
+
+    def booted?
+      self.bootloaders.empty? && self.boot_dependencies.empty?
+    end
+
+    def reset!
+      self.dependencies.clear
+      self.blocks.clear
+    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/gems/gems/nake-0.0.8/lib/nake/args.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require "nake/dsl"
+
+argument("-H", "--help") do |task_name = nil|
+  if task_name
+    task = Task[task_name]
+    if task
+      p task # TODO
+    else
+      abort "Task #{task_name} doesn't exist"
+    end
+  else
+    Kernel.abort "Use #{$0} -T for list of all available tasks or -i for interactive session"
+  end
+end
+
+argument("-T", "--tasks") do |pattern = nil|
+  Task.boot
+
+  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|
+  Task.boot
+  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! # TODO: can we do it without exit? The usecase is ./tasks.rb -i mytask, so we can set env and then run the task
+end
+
+Nake.args["--verbose",  "--no-verbose"]  = lambda { |key, value| Nake.verbose = value }
+Nake.args["--debug",    "--no-debug"]    = lambda { |key, value| Nake.debug = value }
+Nake.args["--coloring", "--no-coloring"] = lambda { |key, value| Nake.coloring = value }

data/gems/gems/nake-0.0.8/lib/nake/argv.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Nake
+  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/gems/gems/nake-0.0.8/lib/nake/colors.rb

@@ -0,0 +1,22 @@
+# 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
+
+module Term::ANSIColor
+  def self.coloring?
+    if @coloring.respond_to?(:call)
+      @coloring.call
+    else
+      @coloring
+    end
+  end
+end
+
+
+Term::ANSIColor.coloring = lambda { Nake.coloring }

data/gems/gems/nake-0.0.8/lib/nake/dsl.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+require "nake"
+require "nake/task"
+require "nake/file_task"
+
+module Nake
+  module DSL
+    include Nake
+    def argument(*names, &block)
+      Nake.args[*names] = block
+    end
+
+    # desc :release, "Create a new release"
+    # task(:release) do
+    #   # ...
+    # end
+    def desc(task, description)
+      Task.new(task).description = description
+    end
+
+    # 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
+
+    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
+
+    # rule "*.o", "*.c"
+    # rule "**/*.o", "**/.c"
+    def rule(pattern, *dependencies, &block)
+      if block.nil?
+        Rule.new(pattern, *dependencies)
+      else
+        Rule.new(pattern, *dependencies) do |rule|
+          rule.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 { mkdir_p path }
+      end
+    end
+  end
+end
+
+class Object
+  include Nake::DSL
+end

data/gems/gems/nake-0.0.8/lib/nake/file_task.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require "nake/abstract_task"
+
+module Nake
+  class FileTask < AbstractTask
+    # TODO: default description na Generate #name
+    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