nake 0.0.7 → 0.0.8.pre

data/lib/nake/args.rb

@@ -2,8 +2,17 @@
 
 require "nake/dsl"
 
-argument("-H", "--help") do
-  Kernel.abort "Use #{$0} -T for list of all available tasks or -i for interactive session"
+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|
@@ -48,8 +57,9 @@ argument("-i", "--interactive") do |task = nil|
   end
 
   IRB.start
-  exit!
+  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["--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/lib/nake/colors.rb

@@ -8,6 +8,15 @@ end
 
 String.send(:include, Term::ANSIColor) # just for now, I know it's a mess
 
-# show colors just if you run nake directly from command line,
-# but not if are using nake in a script or so
-Term::ANSIColor.coloring = STDIN.tty?
+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/lib/nake/dsl.rb

@@ -4,52 +4,67 @@ require "nake"
 require "nake/task"
 require "nake/file_task"
 
-class Object
-  include Nake
-  def argument(*names, &block)
-    Nake.args[*names] = block
-  end
+module Nake
+  module DSL
+    include Nake
+    def argument(*names, &block)
+      Nake.args[*names] = block
+    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)
+    # 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
-  end
 
-  def file(path, *dependencies, &block)
-    if block.nil?
-      FileTask.new(path, *dependencies)
-    else
-      FileTask.new(path, *dependencies) do |task|
-        task.define(&block)
+    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
-  end
 
-  # rule "*.o", "*.c"
-  # rule "**/*.o", "**/.c"
-  def rule(glob, dependency, &block)
-    Dir.glob(glob).each do |path|
-      FileTask.new(path) do |task|
-        task.description = "Generate #{path}"
-        task.define(&block)
+    # 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
-  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 }
+    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/lib/nake/file_task.rb

@@ -1,19 +1,11 @@
 # encoding: utf-8
 
-require "nake/task"
+require "nake/abstract_task"
 
 module Nake
-  class FileTask < Task
+  class FileTask < AbstractTask
     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?

data/lib/nake/rake.rb

@@ -0,0 +1,38 @@
+module Rake
+  def self.method_missing
+    raise NotImplementedError
+  end
+
+  def self.const_missing(constant)
+    raise NotImplementedError, "Nake doesn't support Rake::#{constant}, please use normal Rake"
+  end
+end
+
+# lazy-loading FTW!
+def Object.const_missing(constant)
+  if constant.eql?(:FileList)
+    begin
+      require "filelist"
+      FileList
+    rescue LoadError
+      raise LoadError, "You have to install filelist gem!"
+    end
+  end
+end
+
+module Nake
+  module RakeDSL
+    def task
+    end
+
+    def file
+    end
+
+    def rule
+    end
+
+    def multitask
+      raise NotImplementedError, "Multitask method won't be supported"
+    end
+  end
+end

data/lib/nake/rule.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require "nake/abstract_task"
+
+module Nake
+  class Rule < AbstractTask
+    undef_method :hidden, :hidden=
+    class << self
+      undef_method :tasks
+    end
+
+    def self.rules
+      @@rules ||= Hash.new
+    end
+
+    # Rule["test.o"]
+    # # => rule with pattern ".o"
+    def self.[](file)
+      self.rules.find { |rule| rule.match?(file.to_s) }
+    end
+
+    def self.[]=(pattern, rule)
+      self.rules[pattern.to_s] = rule
+    end
+
+    alias_method :pattern, :name
+    def match?(file)
+      #
+    end
+  end
+
+  # Somewhat like method_missing:
+  # If you can't find a task, try to look for a rule
+  AbstractTask.tasks.default_proc = lambda { |hash, name| Rule[name] }
+end

data/lib/nake/struct_hash.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+# options.extend(HashStructMixin)
+# options.name
+# options.force?
+module Nake
+  module HashStructMixin
+    def method_missing(name, *args, &block)
+      if args.empty? && block.nil?
+        # options.name
+        if value = self[name]
+          return value
+        # options.force?
+        elsif name.to_s.match(/^(.*)\?$/) && value = self[$1.to_sym]
+          return value
+        end
+      end
+
+      super(name, *args, &block)
+    end
+  end
+end

data/lib/nake/task.rb

@@ -1,147 +1,6 @@
-# encoding: utf-8
-
-require "nake/colors"
-require "nake/argv"
+require "nake/abstract_task"
 
 module Nake
-  TaskNotFound ||= Class.new(StandardError)
-  ConfigurationError ||= Class.new(StandardError)
-
-  class Task
-    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, :description, :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
-
-    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 }
-          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
-      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
+  class Task < AbstractTask
   end
 end

data/lib/nake/template.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Nake
+  module TaskHelpers
+    def template(source, target, context = Hash.new)
+      template = Template.new(source)
+      File.open(target, "w") do |file|
+        file.puts(template.render(context))
+      end
+    end
+
+    def erb(source, target, context = Hash.new)
+      template = ErbTemplate.new(source)
+      File.open(target, "w") do |file|
+        file.puts(template.render(context))
+      end
+    end
+  end
+
+  class Template
+    def initialize(path)
+      @path = path
+    end
+
+    def render(context = Hash.new)
+      File.read(@path) % context
+    end
+  end
+
+  class ErbTemplate
+    def initialize(path)
+      require "erb"
+      @path = path
+    end
+
+    def set_locals(context)
+      context.inject("") do |source, pair|
+        source += "#{pair.first} = context[:#{pair.first}]\n"
+      end
+    end
+
+    def source(context)
+      ["<% #{self.set_locals(context)} %>", File.read(@path)].join("")
+    end
+
+    def render(context = Hash.new)
+      template = ERB.new(self.source(context))
+      template.result(binding)
+    end
+  end
+end