do 0.0.3 → 0.1.0

data/lib/do/tasks.rb

@@ -0,0 +1,66 @@
+module DO
+  module Tasks
+    class NotFound < StandardError; end
+    extend self
+
+    def tasks
+      @_tasks ||= []
+    end
+
+    def desc(*args)
+      @_desc = args.shift
+    end
+
+    def namespace(text, &block)
+      namespace_was, @_namespace = @_namespace, text.to_s
+      @_namespace = '%s:%s' % [namespace_was, @_namespace] if namespace_was && namespace_was != ''
+      block.call
+    ensure
+      @_namespace = namespace_was
+    end
+
+    def task(name, options={},  &block)
+      name, deps = name.is_a?(Hash) ? [name.keys[0], Array(name.values[0])] : [name, []]
+      tasks << options.merge({
+        :name      => name.to_s,
+        :desc      => @_desc.to_s,
+        :deps      => deps,
+        :namespace => @_namespace.to_s,
+        :block     => block,
+        :in        => Array(options[:in])
+      })
+      tasks[-1]
+    ensure
+      @_desc = nil
+    end
+
+    def task_run(*args)
+      args_was = args.dup
+      task = task_find(args.shift)
+      opts = DO::Parser.new(*args)
+      task[:deps].each { |d| task_run(*args.unshift(d).push('--dependency')) }
+      if task[:in].empty?
+        task[:block].arity == 1 ? task[:block].call(opts) : task[:block].call if task[:block]
+      else
+        task[:in] = send(task[:in][0]) if task[:in].size == 1 && method_defined?(task[:in][0])
+        task[:in].each do |d|
+          parent = task_find(d)
+          case parent[:block].arity
+            when 1 then parent[:block].call(task[:block])
+            when 2 then parent[:block].call(opts, task[:block])
+            else parent[:block].call
+          end
+        end
+      end
+    rescue NotFound => e
+      method_defined?(args_was[0]) ? send(args_was.shift) : raise(e)
+    end
+    alias :run_task :task_run
+
+    def task_find(name)
+      spaces = name.to_s.split(":")
+      task   = spaces.pop
+      tasks.find { |t| t[:name] == task && t[:namespace] == spaces.join(":") } || raise(NotFound, 'Task with "%s" not found' % name)
+    end
+  end # Tasks
+end # DO

data/lib/do/utils.rb

@@ -10,12 +10,12 @@ module DO
     #   end
     #
     def wait
-      puts "\e[36mPress ENTER to continue...\e[0m"
-      STDIN.gets
+      log "\e[36mPress ENTER to continue...\e[0m"
+      $stdin.gets
     end
 
     ##
-    # Ask question to your STDIN.
+    # Ask question to your $stdin.
     # This command is useful in conjunction with a CLI
     #
     # ==== Example
@@ -23,13 +23,17 @@ module DO
     #   new_pwd = ask "Tell me the new password of mysql"
     #   run "mysqladmin -u root -p password '#{new_pwd}', :input => old_pwd
     #
-    def ask(question, allow_blank=false)
+    def ask(*args)
+      question = args[0]
+      options = args.last.is_a?(Hash) ? args.pop : {}
       result = ""
+      `stty -echo` if options[:silent]
       loop do
         log("\e[36m%s: \e[0m" % question, false)
-        result = STDIN.gets.chomp
-        break if allow_blank || result != ""
+        result = $stdin.gets.chomp
+        break if options[:allow_blank] || result != ""
       end
+      `stty echo` && log("\n", false) if options[:silent]
       result
     end
 
@@ -46,10 +50,29 @@ module DO
       question += "?" if question[-1] != ??
       loop do
         log("\e[36m%s (y/n): \e[0m" % question, false)
-        result = STDIN.gets.chomp
+        result = $stdin.gets.chomp
         break if result =~ /y|yes|n|no/i
       end
       return result =~ /y|yes/i
     end
+
+    ##
+    # Print the text into logger buffer, if you want to change
+    # the stream edit the constant DO_LOGGER
+    #
+    def log(text, new_line=false)
+      text += "\n" if new_line && text[-1] != ?\n
+      DO_LOGGER.print text
+    end
+
+    ##
+    # Execute a local command
+    #
+    def run(*cmds)
+      cmd = cmds.map(&:to_s).join(' ')
+      log DO_LOGGER_FORMAT % [:do, :local, cmd]
+      system cmd
+    end
+    alias :sh :run # keep old compatibility
   end # Utils
 end # DO

data/lib/do/version.rb

@@ -1,3 +1,3 @@
 module DO
-  VERSION = "0.0.3" unless defined?(DO::VERSION)
+  VERSION = "0.1.0" unless defined?(DO::VERSION)
 end

data/lib/do.rb

@@ -1,27 +1,13 @@
 DO_PATH = ENV['DO_PATH'] ||= File.expand_path("~/.do") unless defined?(DO_PATH)
+DO_LOGGER = $stdout unless defined?(DO_LOGGER)
+DO_LOGGER_FORMAT = "\e[36m%s\e[33m@\e[31m%s \e[33m~ \e[35m#\e[0m %s" unless defined?(DO_LOGGER_FORMAT)
 
 module DO
-
+  autoload :CLI,      'do/cli.rb'
   autoload :Server,   'do/server.rb'
   autoload :Utils,    'do/utils.rb'
+  autoload :Commands, 'do/commands.rb'
+  autoload :Tasks,    'do/tasks.rb'
+  autoload :Parser,   'do/parser.rb'
   autoload :VERSION,  'do/version.rb'
-
-  extend self
-
-  ##
-  # DO loads rakefiles in these locations:
-  #
-  #   ~/do/dorc
-  #   ~/do/*.rake
-  #   ./Do
-  #   ./Dofile
-  #
-  # DO_PATH, default is ~/do.
-  #
-  def recipes
-    @_recipes ||= (
-      %w[dorc *.rake].map { |f| Dir[File.join(DO_PATH, f)] }.flatten +
-      %w[./Do ./Dofile].map { |f| File.expand_path(f) }
-    ).reject { |f| !File.exist?(f) }
-  end
 end # DO

data/spec/cli_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe DO::CLI do
+
+  def cli; DO::CLI  end
+
+  it 'should show help if args are empty' do
+    DO::CLI.start
+    logger.should match(/Usage/)
+  end
+
+  it 'should show task list if task does not exist' do
+    DO::CLI.start
+    logger.should match(/list/)
+    logger.should match(/version/)
+  end
+
+  it 'should run task' do
+    DO::CLI.start(:version)
+    logger.should match(DO::VERSION)
+  end
+end

data/spec/commands_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'do/commands.rb'
+
+class Faker
+  extend DO::Commands
+
+  load_recipes
+
+  task :sample do
+    puts "I'm a fantastic sample"
+  end
+
+  def demos
+    @a=1
+  end
+end
+
+describe DO::Commands do
+
+  def cmd; DO::Commands; end
+
+  before(:each){ cmd.tasks.clear; cmd.load_recipes; cmd.servers.clear }
+  before(:all) { FileUtils.rm_rf(DO_PATH) }
+  after(:all)  { FileUtils.rm_rf(DO_PATH) }
+
+  it 'should set DO_PATH' do
+    DO_PATH.should == File.expand_path('../tmp', __FILE__)
+  end
+
+  it 'should have not an existent DO_PATH' do
+    File.exist?(DO_PATH).should be_false
+  end
+
+  it 'should have common tasks' do
+    Faker.tasks.size.should == 6
+  end
+
+  it 'should have not servers' do
+    cmd.servers.should be_empty
+    Faker.servers.should be_empty
+  end
+
+  it 'should create a new task' do
+    tasks_was = cmd.tasks.size
+    cmd.task(:nope) { }
+    cmd.tasks.size.should == tasks_was+1
+  end
+
+  it 'should have one server' do
+    cmd.server :srv1, 'srv1.domain.local', 'root'
+    cmd.servers.size.should == 1
+    Faker.servers.should be_empty
+  end
+
+  it 'should setup a new environment' do
+    cmd.task_run(:setup)
+    File.exist?(File.join(DO_PATH, 'dorc')).should be_true
+    logger.should match("Generated template, now you can add your config to:")
+  end
+
+  it 'should generate a correct template' do
+    dorc = File.read(File.join(DO_PATH, 'dorc'))
+    dorc.should match(/# Server definitions/)
+    dorc.should match(/# Here my plugins/)
+  end
+
+  it 'should add a plugin' do
+    recipe = "https://raw.github.com/gist/1143314/4e1c504e4dfbd988c76e6e28a445d985df2644d0/sample.rake"
+    begin
+      stdout_was = STDERR.dup; STDERR.reopen('/dev/null')
+      cmd.task_run(:download, '--url=%s' % recipe)
+      expect { Faker.task_run(:download, '--url=%s' % recipe) }.to raise_error(SystemExit)
+    ensure
+      STDERR.reopen(stdout_was)
+    end
+    logger.should match(/already has plugin/)
+    dorc = File.read(File.join(DO_PATH, 'dorc'))
+    dorc.should match("plugin :sample, '%s'" % recipe)
+    dest = File.join(DO_PATH, 'sample.rake')
+    File.exist?(dest).should be_true
+    logger.should match("## Installing plugin sample")
+    cmd.run_task('sample')
+    logger.should match("Hey")
+  end
+
+  it 'should print unformatted logs' do
+    cmd.task :sample do
+      cmd.log 'standard log'
+    end
+    cmd.task_run :sample
+    logger.should match("standard log")
+  end
+
+  it 'should set correclty an option to the given value' do
+    cmd.set :foo, :bar
+    cmd.foo.should == :bar
+  end
+
+  it 'should show version number' do
+    cmd.run_task(:version)
+    logger.should match(DO::VERSION)
+  end
+
+  it 'should show help' do
+    cmd.run_task(:help)
+    logger.should match(/Usage/)
+  end
+
+  context DO::Server do
+
+    it 'should create a basic server' do
+      cmd.server :sho0, 'sho0.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.task :test, :in => :sho0 do
+        cmd.run('uname').should == 'Linux'
+      end
+      cmd.task_run(:test)
+    end
+
+    it 'should connect to two servers' do
+      cmd.server :sho0, 'sho0.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.server :srv1, 'srv1.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.task :connection, :in => [:srv1, :sho0] do
+        cmd.run('uname -a').should match(cmd.current_server.name.to_s)
+      end
+      cmd.task_run(:connection)
+      cmd.current_server.should be_nil
+    end
+
+    it 'should works with complex tasks' do
+      cmd.server :sho0, 'sho0.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.server :srv1, 'srv1.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.task :connection, :in => :remote do
+        cmd.run('uname -a').should match(cmd.current_server.name.to_s)
+      end
+      cmd.task_run(:connection)
+      cmd.current_server.should be_nil
+    end
+
+    it 'should skip if --no-xx' do
+      cmd.server :sho0, 'sho0.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.server :srv1, 'srv1.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.task :hostname, :in => :remote do |options|
+        cmd.run('hostname').should match(/srv1/)
+      end
+      cmd.task_run(:hostname, '--no-sho0')
+    end
+
+    it 'should match one if --xx' do
+      cmd.server :sho0, 'sho0.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.server :srv1, 'srv1.lipsiasoft.biz', 'root', :keys => Dir['/Developer/keys/*.pem']
+      cmd.task :hostname, :in => :remote do |options|
+        cmd.run('hostname').should match(/srv1/)
+      end
+      cmd.task_run(:hostname, '--srv1')
+    end
+  end # DO::Server
+end # DO::Commands

data/spec/parser_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe DO::Parser do
+
+  it 'should parse --foo=bar' do
+    parsed = DO::Parser.new('--foo=bar')
+    parsed[:foo].should == 'bar'
+  end
+
+  it 'should parse -foo=bar' do
+    parsed = DO::Parser.new('-foo=bar')
+    parsed[:foo].should == 'bar'
+  end
+
+  it 'should parse --foo-bar=hey' do
+    parsed = DO::Parser.new('--foo-bar=hey')
+    parsed[:'foo-bar'].should == 'hey'
+  end
+
+  it 'should parse -foo-bar=hey' do
+    parsed = DO::Parser.new('-foo-bar=hey')
+    parsed[:'foo-bar'].should == 'hey'
+  end
+
+  it 'should parse --foo bar' do
+    parsed = DO::Parser.new('--foo', 'bar')
+    parsed[:foo].should == 'bar'
+  end
+
+  it 'should parse -foo bar' do
+    parsed = DO::Parser.new('-foo', 'bar')
+    parsed[:foo].should == 'bar'
+  end
+
+  it 'should parse --foo' do
+    parsed = DO::Parser.new('--foo')
+    parsed[:foo].should == true
+  end
+
+  it 'should parse -foo' do
+    parsed = DO::Parser.new('-foo')
+    parsed[:foo].should == true
+  end
+
+  it 'should parse --no-foo' do
+    parsed = DO::Parser.new('--no-foo')
+    parsed[:foo].should == false
+  end
+
+  it 'should parse -no-foo' do
+    parsed = DO::Parser.new('-no-foo')
+    parsed[:foo].should == false
+  end
+
+  it 'should parse int' do
+    parsed = DO::Parser.new('--foo=1')
+    parsed[:foo].should == 1
+  end
+
+  it 'should parse boolean' do
+    parsed = DO::Parser.new('--foo=true')
+    parsed[:foo].should == true
+    parsed = DO::Parser.new('--foo=false')
+    parsed[:foo].should == false
+  end
+
+  it 'should parse float' do
+    parsed = DO::Parser.new('--foo=100.99')
+    parsed[:foo].should == 100.99
+  end
+
+  it 'should parse array' do
+    parsed = DO::Parser.new('--foo=1,a,b,2')
+    parsed[:foo].should == ['1', 'a', 'b', '2']
+  end
+end

data/spec/server_spec.rb

@@ -2,9 +2,7 @@ require 'spec_helper'
 
 describe DO::Server do
   before do
-    keys = %w(/Developer/src/LipsiaSoft/lipsiahosting/lib/lipsiarec/recipes/servers/resources/keys/Lipsiasoft.pem)
-    @server = DO::Server.new(:sho0, 'sho0.lipsiasoft.biz', 'ec2-user', :keys => keys)
-    @server.logger = StringIO.new
+    @server = DO::Server.new(:sho0, 'sho0.lipsiasoft.biz', 'ec2-user', :keys => Dir['/Developer/keys/*.pem'])
     @fixture = File.expand_path('../fixtures/sample', __FILE__)
     @fixture_was = File.read(@fixture)
   end
@@ -14,7 +12,7 @@ describe DO::Server do
     release.should match(/Linux/)
   end
 
-  it 'should upload a something' do
+  it 'should upload something' do
     @server.upload @fixture, '/tmp/sample'
     @server.exist?('/tmp/sample').should be_true
   end

data/spec/spec_helper.rb

@@ -1,19 +1,20 @@
 require 'rubygems' unless defined?(Gem)
+require 'stringio'
+
+DO_PATH   = File.expand_path('../tmp', __FILE__)
+DO_LOGGER = StringIO.new
+
 require 'bundler/setup'
 require 'rspec'
 require 'fileutils'
 require 'do'
 
-module Helper
-  def capture_stdout(&block)
-    stdout_was, $stdout = $stdout, StringIO.new
-    block.call
-    return $stdout
-  ensure
-    $stdout = stdout_was
+module Helpers
+  def logger
+    DO_LOGGER.string
   end
 end
 
-RSpec.configure do |config|
-  config.include(Helper)
+RSpec.configure do |c|
+  c.include Helpers
 end

data/spec/tasks_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe DO::Tasks do
+
+  def cmd; DO::Tasks; end
+
+  before(:each){ cmd.tasks.clear }
+
+  it 'should init a basic task' do
+    DO::Commands.load_recipes
+    task = cmd.task(:name){}
+    task[:name].should == 'name'
+    task[:desc].should == ''
+    task[:namespace].should == ''
+    task[:block] == nil
+    cmd.tasks.size.should == 1
+  end
+
+  it 'should clear old task' do
+    cmd.tasks.size.should == 0
+  end
+
+  it 'should have description' do
+    cmd.desc :desc
+    task = cmd.task(:name){}
+    task[:desc].should == 'desc'
+  end
+
+  it 'should not confuse desc' do
+    cmd.desc :desc
+    task = cmd.task(:name){}
+    task[:desc].should == 'desc'
+    task = cmd.task(:name_alt){}
+    task[:desc].should == ''
+  end
+
+  it 'should have namespace' do
+    cmd.tasks.clear
+    @a = 0
+    cmd.namespace :namespace do
+      cmd.task(:one){ @a+=1 }
+      cmd.task(:two){ @a+=1 }
+    end
+    cmd.task(:three){ @a+=1 }
+    cmd.tasks.should have(3).items
+    @a.should == 0
+    cmd.tasks.each { |t| t[:block].call }
+    @a.should == 3
+    cmd.tasks[0][:namespace].should == 'namespace'
+    cmd.tasks[1][:namespace].should == 'namespace'
+    cmd.tasks[2][:namespace].should == ''
+  end
+
+  it 'should have nested namespaces' do
+    cmd.namespace :foo do
+      cmd.task(:one)
+      cmd.namespace :bar do
+        cmd.task(:two)
+        cmd.namespace :bax do
+          cmd.task(:three)
+        end
+      end
+      cmd.task(:four)
+    end
+    cmd.task(:five)
+    cmd.tasks[0][:namespace].should == 'foo'
+    cmd.tasks[1][:namespace].should == 'foo:bar'
+    cmd.tasks[2][:namespace].should == 'foo:bar:bax'
+    cmd.tasks[3][:namespace].should == 'foo'
+    cmd.tasks[4][:namespace].should == ''
+  end
+
+  it 'should raise notfound' do
+    expect { cmd.task_run(:foobar) }.to raise_error(DO::Tasks::NotFound)
+  end
+
+  it 'should have a dependency flag' do
+    cmd.task(:foo) { |o| o[:dependency].should be_true }
+    cmd.task(:bar => :foo) { |o| o.should_not have_key(:dependency) }
+    cmd.task_run(:bar)
+  end
+
+  context 'when using #task_run' do
+    it 'should run correctly' do
+      cmd.namespace :foo do
+        cmd.task(:one){@a=1}
+        cmd.namespace :bar do
+          cmd.task(:two){@b=2}
+        end
+        cmd.task(:three){@c=3}
+      end
+      cmd.task(:four){@d=4}
+      cmd.task_run('foo:one'); @a.should == 1
+      cmd.task_run('foo:bar:two'); @b.should == 2
+      cmd.task_run('foo:three'); @c.should == 3
+      cmd.task_run('four'); @d.should == 4
+    end
+
+    it 'should parse options' do
+      cmd.namespace :foo do
+        cmd.task(:one){ |o| @o=o }
+        cmd.namespace :bar do
+          cmd.task(:two){ |o| @o=o }
+        end
+        cmd.task(:three){ |o| @o=o }
+      end
+      cmd.task(:four){ |o| @o=o }
+      cmd.task_run('foo:one', '--name=mine'); @o[:name].should == 'mine'
+      cmd.task_run('foo:bar:two', '--age=2'); @o[:age].should == 2
+      cmd.task_run('foo:three', '--yes'); @o[:yes].should == true
+      cmd.task_run('four', '--no-value'); @o[:value].should == false
+    end
+
+    it 'should run deps' do
+      cmd.task(:dep1){@deps=1}
+      cmd.task(:last => [:dep1]){@deps}
+      cmd.task_run(:last) == 1
+    end
+
+    it 'should share with opts with deps' do
+      cmd.task(:dep1){ |d| @value = d[:value] }
+      cmd.task(:dep2){ |d| @value+=1 }
+      cmd.task(:dep3){ |d| @value+=1 }
+      cmd.task(:last => [:dep1, :dep2, :dep3]){ |d| @value+=1 }
+      cmd.task_run(:last, '--value=5')
+      @value.should == 8
+    end
+
+    it 'should repeat itself with blocks' do
+      cmd.task(:dep1){ |b| @value=3; b.call }
+      cmd.task(:last, :in => :dep1){ @value+=1 }
+      cmd.task_run(:last)
+      @value.should == 4
+    end
+
+    it 'should repeat itself without blocks' do
+      cmd.tasks.clear
+      cmd.task(:dep1) { @value  = 5 }
+      cmd.task(:dep2) { @value += 1 }
+      cmd.task(:dep3) { @value += 1 }
+      cmd.task(:dep4) { @value += 1 }
+      cmd.task(:last, :in => [:dep1, :dep2, :dep3, :dep4])
+      cmd.task_run(:last)
+      @value.should == 8
+    end
+
+    it 'should run methods if NotFound raised' do
+      cmd.tasks.clear
+      cmd.send(:define_method, :demos) {}
+      cmd.task(:demo => :demos)
+      expect { cmd.task_run(:demo) }.to_not raise_error
+    end
+  end
+end

data/spec/utils_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'DO::Utils' do
+  def shell
+    @_shell ||= Class.new { include DO::Utils }.new
+  end
+
+  it 'should log' do
+    DO_LOGGER.should_receive(:print).with('foo')
+    shell.log 'foo'
+  end
+
+  it 'should should ask' do
+    DO_LOGGER.should_receive(:print).with("\e[36mShould I overwrite it?: \e[0m")
+    $stdin.should_receive(:gets).and_return('Sure')
+    shell.ask("Should I overwrite it?").should == "Sure"
+  end
+
+  it 'should yes? and return true' do
+    DO_LOGGER.should_receive(:print).with("\e[36mIt is true? (y/n): \e[0m")
+    $stdin.should_receive(:gets).and_return('y')
+    shell.yes?('It is true').should be_true
+  end
+
+  it 'should yes? and return false' do
+    DO_LOGGER.should_receive(:print).with("\e[36mIt is true? (y/n): \e[0m")
+    $stdin.should_receive(:gets).and_return('n')
+    shell.yes?('It is true').should be_false
+  end
+
+  it 'should wait' do
+    DO_LOGGER.should_receive(:print).with("\e[36mPress ENTER to continue...\e[0m")
+    $stdin.should_receive(:gets).and_return('fooo')
+    shell.wait
+  end
+end