taketo 0.0.2 → 0.0.3

data/README.md

@@ -4,7 +4,15 @@ Take Me To
 [![Build Status](https://secure.travis-ci.org/v-yarotsky/taketo.png)](http://travis-ci.org/v-yarotsky/taketo)
 [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/v-yarotsky/taketo)
 
-A tiny helper utility to make access to servers eaiser for different projects and environments.
+A tiny helper utility to make access to servers easier for different projects and environments.
+
+Important note:
+---------------
+
+The project is currently actively developed, thus it may contain bugs;
+backward compatibility is not guaranteed.
+
+Suggestions and contributions are highly appreciated :)
 
 Usage:
 ------
@@ -28,9 +36,42 @@ puts a config into ```~/.taketo.rc.rb```:
   end
 ```
 
-Then execute ```taketo my_project staging server -c console``` to execute the "rails c" with corresponding environment variables set on desired server
-or just ```taketo my_project staging server``` to open bash
+Then execute ```taketo my_project:staging:server -c console``` to execute the "rails c" with corresponding environment variables set on desired server
+or just ```taketo my_project:staging:server``` to open bash
+
+Destination resolving works intelligently. Given the following config:
+
+```ruby
+  default_destination "my_project2:staging:s2"
 
+  project :my_project do
+    environment :staging do
+      server :s1 do
+        host "1.2.3.4"
+      end
+    end
+    environment :production do
+      server :ps1 do
+        host "3.4.5.6"
+      end
+    end
+  end
+  
+  project :my_project2 do
+    environment :staging do
+      server :s2 do
+        host "2.3.4.5"
+      end
+    end
+  end
+```
+
+```taketo my_project:staging``` will ssh to s1 with host = 1.2.3.4  
+```taketo my_project2``` will ssh to s2 with host = 2.3.4.5   
+
+Note that default destination can be specified via ```default_destination``` config option
+
+  
 To-Do:
 ------
 
@@ -40,6 +81,10 @@ To-Do:
 The Changelog:
 --------------
 
+### v0.0.3 (22.07.2012) ###
+* Add default_destination config option
+* Add intelligent destination resolving
+
 ### v0.0.2 (21.07.2012) ###
 * Add ability to define environment variables
 * Add support for server commands

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/bin/taketo

@@ -6,7 +6,7 @@ begin
   require 'taketo'
   require 'taketo/constructs_factory'
   require 'taketo/commands'
-  require 'taketo/taketo_argv_parser'
+  require 'taketo/destination_resolver'
   require 'optparse'
 rescue LoadError => e #development
   raise if $loaded
@@ -62,7 +62,7 @@ end
 
 def remote_command(server, options)
   command_name = options[:command] or return default_command(options)
-  server.command_by_name(command_name.to_sym) { default_command(options) }
+  server.find(:command, command_name.to_sym) { default_command(options) }
 end
 
 def default_command(options)
@@ -75,7 +75,8 @@ begin
   options = parse_options
   config  = parse_config(options[:config])
 
-  server = TaketoArgvParser.new(config, ARGV).parse
+  destination_path = ARGV.shift.to_s
+  server = DestinationResolver.new(config, destination_path).resolve
 
   server_command = remote_command(server, options)
   command_to_execute = Commands::SSHCommand.new(server).render(server_command)
@@ -91,3 +92,4 @@ rescue Exception => e
   STDERR.puts "An error occurred: #{e.message}"
   raise if options && options[:debug]
 end
+

data/features/commands.feature

@@ -16,7 +16,7 @@ Feature:
         end
       end
       """
-      And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command "TERM=xterm-256color bash" slots staging s1`
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command "TERM=xterm-256color bash"`
     Then the output should contain
       """
       ssh -t 1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging TERM=xterm-256color bash"
@@ -37,7 +37,7 @@ Feature:
         end
       end
       """
-      And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command console slots staging s1`
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command console slots:staging:s1`
     Then the output should contain
       """
       ssh -t 1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging rails c"

data/features/connect_to_server.feature

@@ -14,11 +14,15 @@ Feature:
             user "deployer"
             location "/var/apps/slots"
           end
+
+          server :s2 do
+            host "2.3.4.5"
+          end
         end
       end
 
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run slots staging s1`
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run slots:staging:s1`
     Then the output should contain
       """
       ssh -t deployer@1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging bash"
@@ -65,3 +69,44 @@ Feature:
       FOO=the\ value
       """
       
+  Scenario: Reopen config scopes
+    When I have the following config in "/tmp/taketo_test_cfg.rb"
+      """
+      project :slots do
+        environment :staging do
+          server :s1 do
+            host "1.2.3.4"
+          end
+        end
+      end
+
+      project :slots do
+        environment :staging do
+          server :s1 do
+            env :FOO => "bar"
+          end
+        end
+      end
+      """
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb slots:staging:s1 --dry-run`
+    Then the output should match /ssh -t 1\.2\.3\.4 "(RAILS_ENV=staging FOO=bar|FOO=bar RAILS_ENV=staging) bash"/
+
+  Scenario: Default destination
+    When I have the following config in "/tmp/taketo_test_cfg.rb"
+      """
+      default_destination "slots:staging:s2"
+      project :slots do
+        environment :staging do
+          server :s1 do
+          end
+          server :s2 do
+            host "2.3.4.5"
+          end
+        end
+      end
+      """
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
+    Then the output should contain
+      """
+      ssh -t 2.3.4.5 "RAILS_ENV=staging bash"
+      """

data/lib/taketo/constructs/base_construct.rb

@@ -0,0 +1,24 @@
+require 'taketo/support'
+
+module Taketo
+  module Constructs
+    class BaseConstruct
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def find(scope, name)
+        send("find_#{scope}", name) or
+          if block_given?
+            yield
+          else
+            raise KeyError, "#{scope.to_s.capitalize} #{name} not found for #{self.class.name} #{name}"
+          end
+      end
+    end
+  end
+end
+
+

data/lib/taketo/constructs/command.rb

@@ -1,19 +1,15 @@
+require 'taketo/constructs/base_construct'
 require 'shellwords'
 
 module Taketo
   module Constructs
-    class Command
+    class Command < BaseConstruct
       include Shellwords
 
-      attr_reader :name
       attr_accessor :command
       
-      def initialize(name)
-        @name = name
-      end
-
       def render(server)
-        %Q[#{location(server)} #{environment_variables(server)} #{command}].squeeze(" ")
+        %Q[#{location(server)} #{environment_variables(server)} #{command}].strip.squeeze(" ")
       end
 
       private

data/lib/taketo/constructs/config.rb

@@ -1,9 +1,11 @@
+require 'taketo/constructs/base_construct'
 require 'taketo/support'
 
 module Taketo
   module Constructs
-    class Config
+    class Config < BaseConstruct
       attr_reader :projects
+      attr_accessor :default_destination
 
       def initialize
         @projects = Taketo::Support::NamedNodesCollection.new
@@ -12,6 +14,10 @@ module Taketo
       def append_project(project)
         @projects << project
       end
+
+      def find_project(name)
+        @projects.find_by_name(name)
+      end
     end
   end
 end

data/lib/taketo/constructs/environment.rb

@@ -1,12 +1,13 @@
+require 'taketo/constructs/base_construct'
 require 'taketo/support'
 
 module Taketo
   module Constructs
-    class Environment
-      attr_reader :name, :servers
+    class Environment < BaseConstruct
+      attr_reader :servers
 
       def initialize(name)
-        @name = name
+        super
         @servers = Taketo::Support::NamedNodesCollection.new
       end
 
@@ -14,6 +15,10 @@ module Taketo
         server.environment = self
         @servers << server
       end
+
+      def find_server(name)
+        @servers.find_by_name(name)
+      end
     end
   end
 end

data/lib/taketo/constructs/project.rb

@@ -1,18 +1,23 @@
+require 'taketo/constructs/base_construct'
 require 'taketo/support'
 
 module Taketo
   module Constructs
-    class Project
-      attr_reader :name, :environments
+    class Project < BaseConstruct
+      attr_reader :environments
 
       def initialize(name)
-        @name = name
+        super
         @environments = Taketo::Support::NamedNodesCollection.new
       end
 
       def append_environment(environment)
         @environments << environment
       end
+
+      def find_environment(name)
+        @environments.find_by_name(name)
+      end
     end
   end
 end

data/lib/taketo/constructs/server.rb

@@ -1,15 +1,18 @@
+require 'taketo/constructs/base_construct'
+require 'taketo/support'
+
 module Taketo
   module Constructs
-    class Server
+    class Server < BaseConstruct
       class CommandNotFoundError < StandardError; end
 
-      attr_reader :name, :environment_variables, :commands
+      attr_reader :environment_variables, :commands
       attr_accessor :host, :port, :username, :default_location, :environment
       
       def initialize(name)
-        @name = name
+        super
         @environment_variables = {}
-        @commands = []
+        @commands = Taketo::Support::NamedNodesCollection.new
       end
 
       def env(env_variables)
@@ -20,20 +23,14 @@ module Taketo
         @commands << command
       end
 
+      def find_command(name)
+        @commands.find_by_name(name)
+      end
+
       def environment=(environment)
         env(:RAILS_ENV => environment.name.to_s)
         @environment = environment
       end
-
-      def command_by_name(command_name)
-        @commands.detect { |c| c.name == command_name } or 
-          if block_given?
-            yield
-          else
-            raise CommandNotFoundError, "Command #{command_name} not found for server #{name}"
-          end
-      end
-
     end
   end
 end

data/lib/taketo/destination_resolver.rb

@@ -0,0 +1,118 @@
+module Taketo
+  class ConfigError < StandardError; end
+  class AmbiguousDestinationError < StandardError; end
+  class NonExistentDestinationError < StandardError; end
+
+  class DestinationResolver
+    def initialize(config, path)
+      @config = config
+      set_destination(path)
+    end
+
+    def resolve
+      case @path.size
+      when 3 then resolve_by_three_segments
+      when 2 then resolve_by_two_segments
+      when 1 then resolve_by_one_segment
+      when 0 then resolve_with_no_segments
+      end
+    end
+
+    private
+
+    def set_destination(path)
+      @path_str = path
+      @path = String(path).split(":").map(&:to_sym)
+    end
+
+    def resolve_by_three_segments
+      get_server(*@path)
+    end
+
+    def resolve_by_two_segments
+      project, environment = get_project_and_environment(*@path)
+      get_only_server_for_project_and_environment(project, environment)
+    end
+
+    def resolve_by_one_segment
+      project = get_project(*@path)
+      get_only_server_for_project(project)
+    end
+
+    def resolve_with_no_segments
+      unless @config.default_destination.nil?
+        set_destination(@config.default_destination.to_s)
+        return resolve
+      end
+      get_only_server
+    end
+
+    def get_server(project_name, environment_name, server_name)
+      handling_failure("There is no such project, environment or server for destination: #@path_str") do
+        project, environment = get_project_and_environment(project_name, environment_name)
+        environment.servers[server_name]
+      end
+    end
+
+    def get_project_and_environment(project_name, environment_name)
+      handling_failure("There is no such project - environment pair: #@path_str") do
+        project = get_project(project_name)
+        environment = project.environments[environment_name]
+        [project, environment]
+      end
+    end
+
+    def get_only_server_for_project_and_environment(project, environment)
+      if environment.servers.one?
+        return environment.servers.first
+      else
+        raise_server_ambiguous!(project, environment)
+      end
+    end
+
+    def get_project(project_name)
+      handling_failure("There is no such project: #@path_str") do
+        @config.projects[project_name]
+      end
+    end
+
+    def get_only_server_for_project(project)
+      if project.environments.one?
+        environment = project.environments.first
+        get_only_server_for_project_and_environment(project, environment)
+      else
+        raise_environment_ambiguous!(project)
+      end
+    end
+
+    def get_only_server
+      if @config.projects.one?
+        project = @config.projects.first
+        get_only_server_for_project(project)
+      else
+        raise_project_ambiguous!
+      end
+    end
+
+    def raise_project_ambiguous!
+      raise AmbiguousDestinationError, "There are multiple projects #{@config.projects.map(&:name).join(", ")}"
+    end
+
+    def raise_environment_ambiguous!(project)
+      raise AmbiguousDestinationError, "There are multiple environments for project #{project.name}: " \
+        "#{project.environments.map(&:name).join(", ")}"
+    end
+
+    def raise_server_ambiguous!(project, environment)
+      raise AmbiguousDestinationError, "There are multiple servers for project #{project.name} " \
+        "in environment #{environment.name}: #{environment.servers.map(&:name).join(", ")}"
+    end
+
+    def handling_failure(message)
+      yield
+    rescue KeyError, NonExistentDestinationError
+      raise NonExistentDestinationError, message
+    end
+  end
+end
+

data/lib/taketo/dsl.rb

@@ -11,7 +11,7 @@ module Taketo
             raise ScopeError,
               "#{scope} can't be defined in #{current_scope} scope"
           end
-          scope_object = @factory.create(scope, name)
+          scope_object = current_scope_object.find(scope, name) { @factory.create(scope, name) }
           in_scope(scope, scope_object) do
             block.call
           end
@@ -55,12 +55,13 @@ module Taketo
     define_scope :server, :environment
     define_scope :command, :server
 
-    define_attribute(:host, :server)     { |hostname|    current_scope_object.host = hostname         }
-    define_attribute(:port, :server)     { |port_number| current_scope_object.port = port_number      }
-    define_attribute(:user, :server)     { |username|    current_scope_object.username = username     }
-    define_attribute(:location, :server) { |path|        current_scope_object.default_location = path }
-    define_attribute(:env, :server)      { |env|         current_scope_object.env(env)                }
-    define_attribute(:execute, :command) { |command|     current_scope_object.command = command       }
+    define_attribute(:default_destination, :config) { |destination| current_scope_object.default_destination = destination }
+    define_attribute(:host, :server)                { |hostname|    current_scope_object.host = hostname                   }
+    define_attribute(:port, :server)                { |port_number| current_scope_object.port = port_number                }
+    define_attribute(:user, :server)                { |username|    current_scope_object.username = username               }
+    define_attribute(:location, :server)            { |path|        current_scope_object.default_location = path           }
+    define_attribute(:env, :server)                 { |env|         current_scope_object.env(env)                          }
+    define_attribute(:execute, :command)            { |command|     current_scope_object.command = command                 }
 
     private
 
@@ -78,7 +79,7 @@ module Taketo
 
     def in_scope(scope, new_scope_object)
       parent_scope_object, @current_scope_object = @current_scope_object, new_scope_object
-      @scope << scope
+      @scope.push(scope)
       yield
       parent_scope_object.send("append_#{scope}", current_scope_object)
       @scope.pop

data/lib/taketo/support/named_nodes_collection.rb

@@ -7,19 +7,28 @@ module Taketo
       include Enumerable
       extend Forwardable
 
-      def_delegators :@nodes, :each, :<<, :push, :length, :size, :empty?
+      def_delegators :@nodes, :each, :length, :size, :empty?
 
       def initialize(nodes = [])
         @nodes = nodes
       end
 
+      def push(node)
+        @nodes << node unless find_by_name(node.name)
+      end
+      alias :<< :push
+
       def [](index)
         if index.is_a?(Symbol)
-          node = @nodes.detect { |n| n.name == index } or raise KeyError, "Element with name #{index} not found"
+          node = find_by_name(index) or raise KeyError, "Element with name #{index} not found"
           return node
         end
         @nodes[index] or raise KeyError, "Element ##{index} not found"
       end
+
+      def find_by_name(name)
+        @nodes.detect { |n| n.name == name }
+      end
     end
   end
 end

data/spec/integration/dsl_integration_spec.rb

@@ -11,6 +11,10 @@ describe "Taketo DSL" do
             host "127.0.0.2"
             user "deployer"
             location "/var/app"
+            env :FOO => "bar"
+            command :console do
+              execute "rails c"
+            end
           end
         end
 
@@ -40,6 +44,9 @@ describe "Taketo DSL" do
     staging_server.host.should == "127.0.0.2"
     staging_server.username.should == "deployer"
     staging_server.default_location.should == "/var/app"
+    staging_server.environment_variables.should == { :RAILS_ENV => "staging", :FOO => "bar" }
+    staging_server.commands.length.should == 1
+    staging_server.commands[:console].command.should == "rails c"
 
     production = project.environments[:production]
     production.servers.length.should == 2

data/spec/lib/taketo/constructs/base_construct_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../../../spec_helper', __FILE__)
+require 'taketo/constructs/base_construct'
+
+include Taketo
+
+describe "BaseConstruct" do
+  class TestConstruct < Constructs::BaseConstruct
+    attr_reader :foos
+
+    def initialize(name, foos)
+      super(name)
+      @foos = foos
+    end
+
+    def find_foo(name)
+      @foos[name]
+    end
+  end
+
+  let(:foos) { mock(:NamedNodesCollection) }
+  let(:construct) { TestConstruct.new(:construct, foos) }
+
+  describe "#find" do
+    context "if there is such node" do
+      it "should return node object with corresponding name" do
+        foos.should_receive(:[]).with(:bar).and_return(:qux)
+        construct.find(:foo, :bar).should == :qux
+      end
+    end
+
+    context "if there is no such command" do
+      before(:each) { foos.should_receive(:[]).and_return(nil) }
+
+      it "should yield if block given" do
+        expect { |b| construct.find(:foo, :bar, &b) }.to yield_control
+      end
+
+      it "should raise KeyError if no block given" do
+        expect { construct.find(:foo, :bar) }.to raise_error(KeyError)
+      end
+    end
+  end
+end
+
+

data/spec/lib/taketo/constructs/config_spec.rb

@@ -13,5 +13,18 @@ describe "Config" do
       config.projects.should include(project)
     end
   end
+
+  describe "#find_project" do
+    it "should find project by name" do
+      config.projects.should_receive(:find_by_name).with(:foo).and_return(:bar)
+      config.find_project(:foo).should == :bar
+    end
+  end
+
+  it "should set default_destination" do
+    config.default_destination.should be_nil
+    config.default_destination = "foo:bar:baz"
+    config.default_destination.should == "foo:bar:baz"
+  end
 end
 

data/spec/lib/taketo/constructs/environment_spec.rb

@@ -23,6 +23,13 @@ describe "Environment" do
       environment.append_server(server)
     end
   end
+
+  describe "#find_server" do
+    it "should find server by name" do
+      environment.servers.should_receive(:find_by_name).with(:foo).and_return(:bar)
+      environment.find_server(:foo).should == :bar
+    end
+  end
 end
 
 

data/spec/lib/taketo/constructs/project_spec.rb

@@ -17,5 +17,12 @@ describe "Project" do
       project.environments.should include(environment)
     end
   end
+
+  describe "#find_environment" do
+    it "should find environment by name" do
+      project.environments.should_receive(:find_by_name).with(:foo).and_return(:bar)
+      project.find_environment(:foo).should == :bar
+    end
+  end
 end
 

data/spec/lib/taketo/constructs/server_spec.rb

@@ -60,22 +60,10 @@ describe "Server" do
       end
     end
 
-    describe "#command_by_name" do
-      context "if there is such command" do
-        it "should return command object with corresponding name" do
-          server.append_command(command)
-          server.command_by_name(:foo).should == command
-        end
-      end
-
-      context "if there is no such command" do
-        it "should yield if block given" do
-          expect { |b| server.command_by_name(:bar, &b) }.to yield_control
-        end
-
-        it "should raise CommandNotFoundError if no block given" do
-          expect { server.command_by_name(:bar) }.to raise_error(Taketo::Constructs::Server::CommandNotFoundError)
-        end
+    describe "#find_command" do
+      it "should find command by name" do
+        server.commands.should_receive(:find_by_name).with(:foo).and_return(:bar)
+        server.find_command(:foo).should == :bar
       end
     end
   end

data/spec/lib/taketo/constructs_factory_spec.rb

@@ -6,7 +6,7 @@ include Taketo
 describe "ConstructsFactory" do
   let(:factory) { Taketo::ConstructsFactory.new }
 
-  specify "#create should delegate to appripriate method according to type" do
+  specify "#create should delegate to appropriate method according to the type" do
     factory.should_receive(:create_config)
     factory.create(:config)
 

data/spec/lib/taketo/destination_resolver_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'taketo/destination_resolver'
+require 'taketo/support/named_nodes_collection'
+
+include Taketo
+
+describe "DestinationResolver" do
+  let(:server1) { stub(:Server, :name => :s1) }
+  let(:server2) { stub(:Server, :name => :s2) }
+  let(:server3) { stub(:Server, :name => :s3) }
+  let(:server4) { stub(:Server, :name => :s4) }
+  let(:config) do
+    stub(:Config, :projects => list(
+      stub(:name => :foo, :environments => list(
+        stub(:name => :bar, :servers => list(server1))
+      )),
+      stub(:name => :baz, :environments => list(
+        stub(:name => :qux, :servers => list(server2))
+      )),
+      stub(:name => :quux, :environments => list(
+        stub(:name => :corge, :servers => list(server3, server4))
+      )),
+      stub(:name => :grault, :environments => list(
+        stub(:name => :garply, :servers => list(anything, anything)),
+        stub(:name => :waldo, :servers => list(anything))
+      ))
+    ))
+  end
+
+  context "when project, environment and server specified" do
+    it "should return server if it exists" do
+      resolver(config, "foo:bar:s1").resolve.should == server1
+    end
+
+    it "should raise error if server does not exist" do
+      config = stub(:Config, :projects => list())
+      expect { resolver(config, "foo:bar:noserver").resolve }.to raise_error(NonExistentDestinationError, /no such/i)
+    end
+  end
+
+  context "when there are 2 segments in path" do
+    context "when there is matching project - environment pair" do
+      it "should return server if only one specified" do
+        resolver(config, "foo:bar").resolve.should == server1
+        resolver(config, "baz:qux").resolve.should == server2
+      end
+
+      it "should raise error if there are multiple servers" do
+        expect { resolver(config, "quux:corge").resolve }.to raise_error(AmbiguousDestinationError, /servers/i)
+      end
+    end
+
+    context "when there is no matching project - environment pair" do
+      it "should raise error if no such project - environment pair exist" do
+        expect { resolver(config, "chunky:bacon").resolve }.to raise_error(NonExistentDestinationError, /project.*environment/i)
+      end
+    end
+  end
+
+  context "when there is only one segment in the path" do
+    context "when project with given name exists" do
+      context "when there's one environment" do
+        context "when there's one server" do
+          it "should return the server" do
+            resolver(config, "foo").resolve.should == server1
+          end
+        end
+
+        context "when there are multiple servers" do
+          it "should raise error" do
+            expect { resolver(config, "quux").resolve }.to raise_error(AmbiguousDestinationError, /servers/i)
+          end
+        end
+      end
+
+      context "when there are multiple environments" do
+        it "should raise error" do
+          expect { resolver(config, "grault").resolve }.to raise_error(AmbiguousDestinationError, /environments/i)
+        end
+      end
+    end
+
+    context "when there is no such project" do
+      it "should raise error" do
+        expect { resolver(config, "chunky").resolve }.to raise_error(NonExistentDestinationError, /project/i)
+      end
+    end
+  end
+
+  context "when passed path is empty" do
+    context "when there is no default destination set" do
+      context "when there's one project" do
+        context "when there's one environment" do
+          context "when there's one server" do
+            it "should execute command without asking project/environment/server" do
+              config = stub(:Config, :default_destination => nil, :projects => list(
+                stub(:name => :foo, :environments => list(
+                  stub(:name => :bar, :servers => list(
+                    server1
+                  ))
+                ))
+              ))
+
+              resolver(config, "").resolve.should == server1
+            end
+          end
+
+          context "when there are multiple servers" do
+            let(:server1) { stub(:Server, :name => :s1) }
+            let(:server2) { stub(:Server, :name => :s2) }
+
+            it "should ask for server" do
+              config = stub(:Config, :default_destination => nil, :projects => list(
+                stub(:name => :foo, :environments => list(
+                  stub(:name => :bar, :servers => list(
+                    server1, server2
+                  ))
+                ))
+              ))
+
+              expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /server/i
+            end
+          end
+        end
+
+        context "when there are multiple environments" do
+          it "should ask for environment" do
+            config = stub(:Config, :default_destination => nil, :projects => list(
+              stub(:name => :foo, :environments => list(
+                stub(:name => :bar, :servers => [anything]),
+                stub(:name => :baz, :servers => [anything])
+              ))
+            ))
+
+            expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /environment/i
+          end
+        end
+      end
+
+      context "when there are multiple projects" do
+        it "should ask for project" do
+          config = stub(:Config, :default_destination => nil, :projects => list(
+            stub(:name => :foo, :environments => [anything]),
+            stub(:name => :bar, :environments => [anything])
+          ))
+
+          expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /projects/i
+        end
+      end
+    end
+
+    context "when there is default destination" do
+      it "should resolve by default destination" do
+        config.stub(:default_destination => "foo:bar:s1")
+        resolver(config, "").resolve.should == server1
+      end
+    end
+  end
+
+
+  def resolver(*args)
+    DestinationResolver.new(*args)
+  end
+
+  def list(*items)
+    Taketo::Support::NamedNodesCollection.new(items)
+  end
+
+end
+

data/spec/lib/taketo/dsl_spec.rb

@@ -18,28 +18,36 @@ describe "DSL" do
       it { should_not be_appropriate_construct(scope_name, :foo).under(inappropriate_scope) }
     end
 
-    it "should create a #{scope_name} and set it as current scope object" do
-      dsl(parent_scope, factory.create(parent_scope_name)) do |c|
-        factory.should_receive(:create).with(scope_name, :bar)
-        c.send(scope_name, :bar) do
-          c.current_scope_object.should == factory.send(scope_name)
-        end
-      end
-    end
-
-    it "should not leak #{scope_name} as current scope object" do
-      dsl(parent_scope, factory.create(parent_scope_name)) do |c|
-        c.send(scope_name, :bar) {}
-        c.current_scope_object.should_not == factory.send(scope_name)
-      end
-    end
-
-    it "should add a #{scope_name} to the #{parent_scope_name}'s #{scope_name}s collection" do
-      dsl(parent_scope, factory.create(parent_scope_name)) do |c|
-        c.current_scope_object.should_receive("append_#{scope_name}").with(factory.send("create_#{scope_name}", :bar))
-        c.send(scope_name, :bar) {}
-      end
-    end
+    it "should create a #{scope_name} and set it as current scope object" do # it "should create project and set it as current scope object"
+      dsl(parent_scope, factory.create(parent_scope_name)) do |c|            #   dsl([:config], factory.create(:config)) do |c|
+        c.current_scope_object.should_receive(:find).with(scope_name, :bar). #     c.current_scope_object.should_receive(:find).with(:project, :bar).
+          and_yield.and_return(:bacon)                                       #       and_yield.and_return(:bacon)
+        factory.should_receive(:create).with(scope_name, :bar)               #     factory.should_receive(:create).with(:project, :bar)
+        c.send(scope_name, :bar) do                                          #     c.project(:bar) do
+          c.current_scope_object.should_not be_nil                           #       c.current_scope_object.should_not be_nil
+          c.current_scope_object.should == :bacon                            #       c.current_scope_object.should == factory.project
+        end                                                                  #     end
+      end                                                                    #   end
+    end                                                                      # end
+
+    it "should not leak #{scope_name} as current scope object" do              # it "should not leak project as current scope object"
+      dsl(parent_scope, factory.create(parent_scope_name)) do |c|              #   dsl([:config], factory.create(:config)) do |c|
+        c.current_scope_object.stub(:find => factory.create(scope_name, :bar)) #     c.current_scope.stub(:find => factory.create(:project, :bar)) 
+        c.send(scope_name, :bar) do                                            #     c.project(:bar) do
+          c.current_scope_object.should == factory.send(scope_name)            #       c.current_scope_object.should == factory.project
+        end                                                                    #     end
+        c.current_scope_object.should_not == factory.send(scope_name)          #     c.current_scope_object.should_not == factory.project
+      end                                                                      #   end
+    end                                                                        # end
+
+    it "should add a #{scope_name} to the #{parent_scope_name}'s #{scope_name}s collection" do # it "should add a project to the config's projects collection" do
+      dsl(parent_scope, factory.create(parent_scope_name)) do |c|                              #   dsl([:config], factory.create(:config)) do |c|
+        c.current_scope_object.stub(:find => factory.create(scope_name, :bar))                 #     c.current_scope_object.stub(:find => factory.create(:project, :bar))
+        c.current_scope_object.should_receive("append_#{scope_name}").                         #     c.current_scope_object.should_receive(:append_project).
+          with(factory.send(scope_name))                                                       #       with(factory.project)
+        c.send(scope_name, :bar) {}                                                            #     c.project(:bar) {}
+      end                                                                                      #   end
+    end                                                                                        # end
   end
 
   shared_examples "an attribute" do |attribute_name, parent_scope_name, parent_scope_method, example_value|
@@ -51,14 +59,18 @@ describe "DSL" do
       it { should_not be_appropriate_construct(attribute_name, example_value).under(inaproppriate_scope) }
     end
 
-    it "should call #{parent_scope_method} on current #{parent_scope_name}" do
-      dsl(parent_scope, factory.create(parent_scope_name, :foo)) do |c|
-        factory.send(parent_scope_name).should_receive(parent_scope_method).with(example_value)
-        c.send(attribute_name, example_value)
-      end
+    it "should call #{parent_scope_method} on current #{parent_scope_name}" do                  # it "should call default_location= on current server" do
+      dsl(parent_scope, factory.create(parent_scope_name, :foo)) do |c|                         #   dsl([:config, :project, :environment, :server], factory.create(:server, :foo)) do |c|
+        factory.send(parent_scope_name).should_receive(parent_scope_method).with(example_value) #     factory.server.should_receive(:default_location=).with('/var/app/')
+        c.send(attribute_name, example_value)                                                   #   c.location "/var/app"
+      end                                                                                       # end
     end
   end
 
+  describe "#default_destination" do
+    it_behaves_like "an attribute", :default_destination, :config, :default_destination=, "foo:bar:baz"
+  end
+
   describe "#project" do
     it_behaves_like "a scope", :project, :config
 

data/spec/lib/taketo/support/eval_delegator_spec.rb

@@ -26,7 +26,13 @@ describe Taketo::Support::EvalDelegator do
       end.not_to raise_error
     end
 
-    it "should pass local variables through the scopes" do
+    it "should raise if external context does not respond" do
+      expect do
+        EvalDelegatorContext.new.evaluate { qux }
+      end.to raise_error(NameError)
+    end
+
+    it "should pass local variabnes through the scopes" do
       baz = :foo
       expect do
         EvalDelegatorContext.new.evaluate { baz }

data/spec/lib/taketo/support/named_nodes_collection_spec.rb

@@ -24,6 +24,13 @@ describe "NamedNodesCollection" do
     expect { collection[3] }.to raise_error KeyError, /#3/i
     expect { collection[:quux] }.to raise_error KeyError, /name/i
   end
+
+  it "should not add if node with same name exists" do
+    collection << node1
+    collection.push node1
+    collection.length.should == 1
+    collection.first.should == node1
+  end
 end
 
 

data/spec/support/helpers/dsl_spec_helper.rb

@@ -6,7 +6,7 @@ module DSLSpec
       send("create_#{type}", *args)
     end
 
-    def create_config
+    def create_config(*args)
       @config ||= RSpec::Mocks::Mock.new(:Config).as_null_object
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taketo
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-21 00:00:00.000000000 Z
+date: 2012-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -86,6 +86,7 @@ files:
 - lib/taketo/commands/ssh_command.rb
 - lib/taketo/commands.rb
 - lib/taketo/config_validator.rb
+- lib/taketo/constructs/base_construct.rb
 - lib/taketo/constructs/command.rb
 - lib/taketo/constructs/config.rb
 - lib/taketo/constructs/environment.rb
@@ -93,26 +94,27 @@ files:
 - lib/taketo/constructs/server.rb
 - lib/taketo/constructs.rb
 - lib/taketo/constructs_factory.rb
+- lib/taketo/destination_resolver.rb
 - lib/taketo/dsl.rb
 - lib/taketo/support/eval_delegator.rb
 - lib/taketo/support/key_error.rb
 - lib/taketo/support/named_nodes_collection.rb
 - lib/taketo/support.rb
-- lib/taketo/taketo_argv_parser.rb
 - lib/taketo.rb
 - spec/integration/dsl_integration_spec.rb
 - spec/lib/taketo/commands/ssh_command_spec.rb
 - spec/lib/taketo/config_validator_spec.rb
+- spec/lib/taketo/constructs/base_construct_spec.rb
 - spec/lib/taketo/constructs/command_spec.rb
 - spec/lib/taketo/constructs/config_spec.rb
 - spec/lib/taketo/constructs/environment_spec.rb
 - spec/lib/taketo/constructs/project_spec.rb
 - spec/lib/taketo/constructs/server_spec.rb
 - spec/lib/taketo/constructs_factory_spec.rb
+- spec/lib/taketo/destination_resolver_spec.rb
 - spec/lib/taketo/dsl_spec.rb
 - spec/lib/taketo/support/eval_delegator_spec.rb
 - spec/lib/taketo/support/named_nodes_collection_spec.rb
-- spec/lib/taketo/taketo_argv_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/helpers/dsl_spec_helper.rb
 - spec/support/matchers/be_appropriate_construct_matcher.rb

data/lib/taketo/taketo_argv_parser.rb

@@ -1,48 +0,0 @@
-module Taketo
-  class ConfigError < StandardError; end
-
-  class TaketoArgvParser
-    def initialize(config, argv)
-      @config = config
-      @argv   = argv
-    end
-
-    def parse
-      if all_specified?
-        project_name, environment_name, server_name = @argv.shift(3).map(&:to_sym)
-
-        begin
-          return @config.projects[project_name].environments[environment_name].servers[server_name]
-        rescue KeyError
-          raise ArgumentError,
-            "Server #{server_name} in environment #{environment_name} for project #{project_name} does not exist"
-        end
-      end
-
-      if @config.projects.one?
-        project = @config.projects.first
-        if project.environments.one?
-          environment = project.environments.first
-          if environment.servers.one?
-            return environment.servers.first
-          elsif environment.servers.length > 1
-            if server_name = @argv.shift
-              return environment.servers[server_name.to_sym]
-            else
-              raise ArgumentError, "There are multiple servers for project #{project.name} " \
-                "in environment #{environment.name}: #{environment.servers.map(&:name).join(", ")}"
-            end
-          end
-        end
-      end
-    end
-
-    private
-
-    def all_specified?
-      @argv.size >= 3
-    end
-
-  end
-end
-

data/spec/lib/taketo/taketo_argv_parser_spec.rb

@@ -1,92 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require 'taketo/taketo_argv_parser'
-require 'taketo/support/named_nodes_collection'
-
-include Taketo
-
-describe "TaketoArgvParser" do
-  context "when project, environment and server specified" do
-    let(:server) { stub(:Server, :name => :baz) }
-
-    it "should return server if it exists" do
-      config = stub(:Config, :projects => list(
-        stub(:name => :foo, :environments => list(
-          stub(:name => :bar, :servers => list(
-            server
-          ))
-        ))
-      ))
-
-      parser(config, %w(foo bar baz)).parse.should == server
-    end
-
-    it "should raise error if server does not exist" do
-      config = stub(:Config, :projects => list())
-      expect do
-        parser(config, %w(foo bar baz)).parse
-      end.to raise_error ArgumentError, /exist/i
-    end
-  end
-
-  context "when there are two arguments" do
-  end
-
-  context "when there are no args" do
-    context "when there's one project" do
-      context "when there's one environment" do
-        context "when there's one server" do
-          let(:server) { stub(:Server) }
-
-          it "should execute command without asking project/environment/server" do
-            config = stub(:Config, :projects => list(
-              stub(:name => :foo, :environments => list(
-                stub(:name => :bar, :servers => list(
-                  server
-                ))
-              ))
-            ))
-
-            parser(config, []).parse.should == server
-          end
-        end
-
-        context "when there are multiple servers" do
-          let(:server1) { stub(:Server, :name => :s1) }
-          let(:server2) { stub(:Server, :name => :s2) }
-
-          it "should ask for server if it's not specified" do
-            config = stub(:Config, :projects => list(
-              stub(:name => :foo, :environments => list(
-                stub(:name => :bar, :servers => list(
-                  server1, server2
-                ))
-              ))
-            ))
-
-            expect do
-              parser(config, []).parse
-            end.to raise_error ArgumentError, /server/i
-
-            parser(config, ["s1"]).parse.should == server1
-          end
-        end
-      end
-
-      context "when there are multiple environments" do
-        context "when environment not specified" do
-          it "should ask for environment"
-        end
-      end
-    end
-  end
-
-  def parser(*args)
-    TaketoArgvParser.new(*args)
-  end
-
-  def list(*items)
-    Taketo::Support::NamedNodesCollection.new(items)
-  end
-
-end
-