taketo 0.0.4 → 0.0.5

data/README.md

@@ -61,6 +61,7 @@ Destination resolving works intelligently. Given the following config:
     end
     environment :production do
       server :ps1 do
+        global_alias :mps1
         host "3.4.5.6"
       end
     end
@@ -77,6 +78,7 @@ Destination resolving works intelligently. Given the following config:
 
 ```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   
+```taketo mps2``` will ssh to s2 with host = 3.4.5.6 - note the use of global alias
 
 Note that default destination can be specified via ```default_destination``` config option
 
@@ -90,6 +92,10 @@ To-Do:
 The Changelog:
 --------------
 
+### v0.0.5 (24.07.2012) ###
+* Add --directory option, which enables specifying directory on remote server upon launch
+* Add global_alias config option for servers
+
 ### v0.0.4 (22.07.2012) ###
 * Add --view option. Now you can view your config quickly: ```taketo my_project:environment:server --view``` or just ```taketo --view```
 * Now commands can have description

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/bin/taketo

@@ -45,6 +45,11 @@ def parse_options
       options[:command] = c
     end
 
+    opts.on("-d DIRECTORY", "--directory", "Directory on destination server to cd to") do |d|
+      raise OptionParser::MissingArgument if String(d).strip.empty?
+      options[:directory] = d
+    end
+
     opts.on("-v", "--view", "Show config contents and exit") do |v|
       options[:view] = v
     end
@@ -87,14 +92,14 @@ begin
   destination_path = ARGV.shift.to_s
   resolver         = DestinationResolver.new(config, destination_path)
 
-  if options[:view]
+  if options.delete(:view)
     node = resolver.get_node
     puts ConfigPrinter.new.render(node).chomp
   else
     server = resolver.resolve
 
     server_command = remote_command(server, options)
-    command_to_execute = Commands::SSHCommand.new(server).render(server_command)
+    command_to_execute = Commands::SSHCommand.new(server).render(server_command.render(server, options))
 
     if options[:dry_run]
       puts command_to_execute

data/features/commands.feature

@@ -4,7 +4,7 @@ Feature:
   I want to have ability to create command shortcuts via config
   or specify command directly
 
-  Scenario: Run explicit command
+  Background:
     When I have the following config in "/tmp/taketo_test_cfg.rb"
       """
       project :slots do
@@ -12,34 +12,31 @@ Feature:
           server do
             host "1.2.3.4"
             location "/var/apps/slots"
+            command :console do
+              execute "rails c"
+            end
           end
         end
       end
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command "TERM=xterm-256color bash"`
+
+  Scenario: Run explicit command
+    When 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"
       """
 
   Scenario: Run command defined in config
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
-      """
-      project :slots do
-        environment :staging do
-          server do
-            host "1.2.3.4"
-            location "/var/apps/slots"
-            command :console do
-              execute "rails c"
-            end
-          end
-        end
-      end
-      """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command console slots:staging`
+    When I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command console slots:staging`
     Then the output should contain
       """
       ssh -t 1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging rails c"
       """
 
+  Scenario: Override default location specified for server
+    When I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --directory /var/www slots:staging`
+    Then the output should contain
+      """
+      ssh -t 1.2.3.4 "cd /var/www; RAILS_ENV=staging bash"
+      """

data/features/connect_to_server.feature

@@ -110,3 +110,24 @@ Feature:
       """
       ssh -t 2.3.4.5 "RAILS_ENV=staging bash"
       """
+
+  Scenario: Unique server alias
+    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
+          server :s2 do
+            global_alias :ss2
+            host "2.3.4.5"
+          end
+        end
+      end
+      """
+    And I successfully run `taketo ss2 --config=/tmp/taketo_test_cfg.rb --dry-run`
+    Then the output should contain
+      """
+      ssh -t 2.3.4.5 "RAILS_ENV=staging bash"
+      """

data/features/error_handling.feature

@@ -0,0 +1,28 @@
+Feature:
+  To be able to troubleshoot my config issues quickly
+  As a user
+  I want to see meaningful errors when I accidentally specify bad location
+
+  Background:
+    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
+      """
+
+  Scenario: Non-existent location
+    And I run `taketo slots:staging:qqq --config=/tmp/taketo_test_cfg.rb --dry-run`
+    Then the stderr should contain "server qqq not found for environment staging"
+
+  Scenario: Ambiguous location
+    And I run `taketo slots:staging --config=/tmp/taketo_test_cfg.rb --dry-run`
+    Then the stderr should contain "There are multiple servers for environment staging: s1, s2"
+

data/lib/taketo/commands/ssh_command.rb

@@ -12,8 +12,8 @@ module Taketo
         @environment = @server.environment
       end
 
-      def render(command)
-        %Q[ssh -t #{port} #{username}#{host} "#{command.render(@server)}"].squeeze(" ")
+      def render(rendered_command)
+        %Q[ssh -t #{port} #{username}#{host} "#{rendered_command}"].squeeze(" ")
       end
 
       def host

data/lib/taketo/config_printer.rb

@@ -10,7 +10,7 @@ module Taketo
     end
 
     def render(object)
-      method = "render_#{object.class.name.gsub(/[\w:]*::/, '').downcase}"
+      method = "render_#{object.node_type}"
       send(method, object)
     end
 

data/lib/taketo/config_validator.rb

@@ -10,6 +10,7 @@ module Taketo
       ensure_projects_exist
       ensure_environments_exist
       ensure_servers_exist
+      ensure_global_server_aliases_unique
     end
 
     private
@@ -38,6 +39,15 @@ module Taketo
         end
       end
     end
+
+    def ensure_global_server_aliases_unique
+      aliases = @config.projects.map { |p| p.environments.map { |e| e.servers.map(&:global_alias) } }.flatten
+      non_uniq_aliases = aliases.reject(&:nil?).group_by(&:to_sym).reject { |k, v| v.size == 1 }
+      unless non_uniq_aliases.empty?
+        raise ConfigError,
+          "There are duplicates among global server aliases: #{non_uniq_aliases.keys.join(", ")}"
+      end
+    end
   end
 end
 

data/lib/taketo/constructs/base_construct.rb

@@ -1,22 +1,72 @@
 require 'taketo/support'
 
 module Taketo
+  class NodesNotDefinedError < StandardError; end
+
   module Constructs
     class BaseConstruct
       attr_reader :name
 
+      ##
+      # Adds nodes collections to the construct
+      # 
+      # Example:
+      #
+      # class Bar < BaseConstruct
+      #   has_nodes :foos, :foo
+      # end
+      #
+      # bar = Bar.new
+      # bar.foos                                  # => foos collection
+      # bar.append_foo(foo)                       # adds node the collection
+      # bar.find_foo(:foo_name)                   # find foo in foos collection by name
+      #
+      def self.has_nodes(name_plural, name_singular)
+        self.node_types << name_plural
+
+        define_method "append_#{name_singular}" do |object|
+          nodes(name_plural) << object
+        end
+
+        define_method "find_#{name_singular}" do |name|
+          nodes(name_plural).find_by_name(name)
+        end
+
+        define_method name_plural do
+          nodes(name_plural)
+        end
+      end
+
+      def self.node_types
+        @node_types ||= []
+      end
+
       def initialize(name)
         @name = name
+        @nodes = {}
       end
 
-      def find(scope, name)
-        send("find_#{scope}", name) or
+      def find(singular_node_name, name)
+        send("find_#{singular_node_name}", name) or
           if block_given?
             yield
           else
-            raise KeyError, "#{scope.to_s.capitalize} #{name} not found for #{self.class.name} #{name}"
+            raise KeyError, "#{singular_node_name} #{name} not found for #{node_type} #{self.name}"
           end
       end
+
+      def nodes(name_plural)
+        unless self.class.node_types.include?(name_plural)
+          raise NodesNotDefinedError, "#{name_plural} not defined for #{node_type}"
+        end
+        @nodes[name_plural] ||= Taketo::Support::NamedNodesCollection.new
+      end
+
+      def node_type
+        demodulized = self.class.name.gsub(/.*::/, '')
+        demodulized.gsub(/([a-z])([A-Z])/, '\\1_\\2').downcase.to_sym
+      end
+      
     end
   end
 end

data/lib/taketo/constructs/command.rb

@@ -8,14 +8,15 @@ module Taketo
 
       attr_accessor :command, :description
       
-      def render(server)
-        %Q[#{location(server)} #{environment_variables(server)} #{command}].strip.squeeze(" ")
+      def render(server, options = {})
+        %Q[#{location(server, options)} #{environment_variables(server)} #{command}].strip.squeeze(" ")
       end
 
       private
 
-      def location(server)
-        %Q[cd #{shellescape server.default_location};] if server.default_location
+      def location(server, options = {})
+        directory = options.fetch(:directory) { server.default_location }
+        %Q[cd #{shellescape directory};] if directory
       end
 
       def environment_variables(server)

data/lib/taketo/constructs/config.rb

@@ -4,19 +4,12 @@ require 'taketo/support'
 module Taketo
   module Constructs
     class Config < BaseConstruct
-      attr_reader :projects
-      attr_accessor :default_destination
-
-      def initialize
-        @projects = Taketo::Support::NamedNodesCollection.new
-      end
+      has_nodes :projects, :project
 
-      def append_project(project)
-        @projects << project
-      end
+      attr_accessor :default_destination
 
-      def find_project(name)
-        @projects.find_by_name(name)
+      def initialize(*args)
+        super(nil)
       end
     end
   end

data/lib/taketo/constructs/environment.rb

@@ -4,20 +4,11 @@ require 'taketo/support'
 module Taketo
   module Constructs
     class Environment < BaseConstruct
-      attr_reader :servers
-
-      def initialize(name)
-        super
-        @servers = Taketo::Support::NamedNodesCollection.new
-      end
+      has_nodes :servers, :server
 
       def append_server(server)
         server.environment = self
-        @servers << server
-      end
-
-      def find_server(name)
-        @servers.find_by_name(name)
+        nodes(:servers) << server
       end
     end
   end

data/lib/taketo/constructs/project.rb

@@ -4,20 +4,7 @@ require 'taketo/support'
 module Taketo
   module Constructs
     class Project < BaseConstruct
-      attr_reader :environments
-
-      def initialize(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
+      has_nodes :environments, :environment
     end
   end
 end

data/lib/taketo/constructs/server.rb

@@ -2,31 +2,24 @@ require 'taketo/constructs/base_construct'
 require 'taketo/support'
 
 module Taketo
+  class CommandNotFoundError < StandardError; end
+
   module Constructs
     class Server < BaseConstruct
-      class CommandNotFoundError < StandardError; end
-
-      attr_reader :environment_variables, :commands
-      attr_accessor :host, :port, :username, :default_location, :environment
+      attr_reader :environment_variables
+      attr_accessor :host, :port, :username, :default_location, :environment, :global_alias
       
+      has_nodes :commands, :command
+
       def initialize(name)
         super
         @environment_variables = {}
-        @commands = Taketo::Support::NamedNodesCollection.new
       end
 
       def env(env_variables)
         @environment_variables.merge!(env_variables)
       end
 
-      def append_command(command)
-        @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

data/lib/taketo/destination_resolver.rb

@@ -1,126 +1,81 @@
 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
+    class Path
+      PATH = [[:project, :projects], [:environment, :environments], [:server, :servers]].freeze
 
-    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
+      class PathNode < Struct.new(:name, :singular, :plural); end
 
-    def get_node
-      case @path.size
-      when 3 then get_server(*@path)
-      when 2 then get_project_and_environment(*@path).last
-      when 1 then get_project(*@path)
-      when 0 then @config
+      def initialize(names)
+        names = names.split(":").map(&:to_sym)
+        @path = PATH.each_with_index.map { |n, i| PathNode.new(names[i], *n) }
       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
+      def specified
+        @path.reject { |n| n.name.nil? }
       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]
+      def unspecified
+        @path - specified
       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)
+    def initialize(config, path)
+      @config = config
+      if String(path).empty? && !String(config.default_destination).empty?
+        path = config.default_destination
       end
+      @path_str = path.dup
+      @path = Path.new(path)
     end
 
-    def get_project(project_name)
-      handling_failure("There is no such project: #@path_str") do
-        @config.projects[project_name]
-      end
+    def resolve
+      resolve_by_global_alias || resolve_by_path
     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)
+    def get_node(node = @config, remaining_path = @path.specified)
+      handling_failure do
+        return node if remaining_path.empty?
+        next_in_path = remaining_path.shift
+        node = node.find(next_in_path.singular, next_in_path.name)
+        get_node(node, remaining_path)
       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
+    private
 
-    def raise_project_ambiguous!
-      raise AmbiguousDestinationError, "There are multiple projects #{@config.projects.map(&:name).join(", ")}"
+    def resolve_by_global_alias
+      aliases_and_servers = Hash[servers_with_aliases]
+      aliases_and_servers[@path_str.to_sym] unless String(@path_str).empty?
     end
 
-    def raise_environment_ambiguous!(project)
-      raise AmbiguousDestinationError, "There are multiple environments for project #{project.name}: " \
-        "#{project.environments.map(&:name).join(", ")}"
+    def resolve_by_path
+      node = get_node
+      get_only_server(node)
     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(", ")}"
+    def get_only_server(node, remaining_path = @path.unspecified)
+      return node if remaining_path.empty?
+      next_in_path = remaining_path.shift
+      nested_nodes = node.nodes(next_in_path.plural)
+      if nested_nodes.one?
+        node = nested_nodes.first
+        get_only_server(node, remaining_path)
+      else
+        raise AmbiguousDestinationError, "There are multiple #{next_in_path.plural} for #{node.node_type} #{node.name}: #{nested_nodes.map(&:name).join(", ")}"
+      end
     end
 
-    def handling_failure(message)
+    def handling_failure(message = nil)
       yield
     rescue KeyError, NonExistentDestinationError
-      raise NonExistentDestinationError, message
+      raise NonExistentDestinationError, message || $!.message
+    end
+
+    def servers_with_aliases
+      @config.nodes(:projects).map { |p| p.nodes(:environments).map { |e| e.nodes(:servers).reject { |s| s.global_alias.nil? }.map { |s| [s.global_alias, s] } } }.flatten(2)
     end
   end
 end

data/lib/taketo/dsl.rb

@@ -61,6 +61,7 @@ module Taketo
     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(:global_alias,:server)         { |alias_name|  current_scope_object.global_alias = alias_name         }
     define_attribute(:env, :server)                 { |env|         current_scope_object.env(env)                          }
     define_attribute(:execute, :command)            { |command|     current_scope_object.command = command                 }
     define_attribute(:desc, :command)               { |description| current_scope_object.description = description         }

data/spec/lib/taketo/commands/ssh_command_spec.rb

@@ -19,14 +19,13 @@ describe "SSH Command" do
   let(:ssh_command) { SSHCommand.new(server) }
 
   it "should compose command based on provided server object" do
-    command.should_receive(:render).with(server).and_return("foobar")
-    ssh_command.render(command).should == %q[ssh -t -p 22 deployer@1.2.3.4 "foobar"]
+    ssh_command.render("foobar").should == %q[ssh -t -p 22 deployer@1.2.3.4 "foobar"]
   end
 
   it "should ignore absent parts" do
     server.stub(:port => nil)
     server.stub(:username => nil)
-    ssh_command.render(command).should == %q[ssh -t 1.2.3.4 "the_command"]
+    ssh_command.render("foobar").should == %q[ssh -t 1.2.3.4 "foobar"]
   end
 
   it "should require host" do

data/spec/lib/taketo/config_printer_spec.rb

@@ -6,8 +6,9 @@ include Taketo
 describe "ConfigPrinter" do
   describe "#render" do
     it "should render based on node class name" do
-      printer.should_receive(:render_fixnum)
-      printer.render(1)
+      construct = stub(:Server, :node_type => :server)
+      printer.should_receive(:render_server)
+      printer.render(construct)
     end
   end
 

data/spec/lib/taketo/config_validator_spec.rb

@@ -33,6 +33,26 @@ describe "ConfigValidator" do
     expect { validator(config).validate! }.not_to raise_error ConfigError, /environment_2/i
   end
 
+  describe "global server aliases" do
+    let(:server_1) { stub(:Server) }
+    let(:server_2) { stub(:Server) }
+    let(:environment) { stub(:Environment, :name => :environment, :servers => [server_1, server_2]) }
+    let(:project) { stub(:Project, :name => :project, :environments => [environment]) }
+    let(:config) { stub(:Config, :projects => [project]) }
+
+    it "should not raise error if unique" do
+      server_1.stub(:global_alias => :foo)
+      server_2.stub(:global_alias => :bar)
+      expect { validator(config).validate! }.not_to raise_error(ConfigError, /alias/i)
+    end
+
+    it "should raise error unless unique" do
+      server_1.stub(:global_alias => :foo)
+      server_2.stub(:global_alias => :foo)
+      expect { validator(config).validate! }.to raise_error(ConfigError, /alias/i)
+    end
+  end
+
   def validator(config)
     Taketo::ConfigValidator.new(config)
   end

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

@@ -40,6 +40,45 @@ describe "BaseConstruct" do
       end
     end
   end
+
+  describe "#node_type" do
+    it "should return demodulized snake-cased class name" do
+      construct.node_type.should == :test_construct
+    end
+  end
+
+  describe "nodes" do
+    class TestConstruct2 < Constructs::BaseConstruct
+      has_nodes :foos, :foo
+    end
+
+    let(:construct) { TestConstruct2.new(:node_name) }
+
+    let(:foo) { stub(:name => :bar) }
+
+    describe ".has_nodes" do
+      it "should define add node type to class's node_types" do
+        TestConstruct2.node_types.should include(:foos)
+      end
+
+      it "should make nodes accessible via added methods" do
+        construct.append_foo(foo)
+        construct.foos.should include(foo)
+        construct.find_foo(:bar).should == foo
+      end
+    end
+
+    describe "#nodes" do
+      it "should return nodes collection by plural name" do
+        construct.append_foo(foo)
+        construct.nodes(:foos).should include(foo)
+      end
+
+      it "should raise NodesNotDefinedError if non-specified node requested" do
+        expect { construct.nodes(:bars) }.to raise_error(NodesNotDefinedError, /bars/)
+      end
+    end
+  end
 end
 
 

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

@@ -4,23 +4,26 @@ require 'taketo/constructs/command'
 include Taketo
 
 describe "Command" do
-  let(:cmd) { Taketo::Constructs::Command.new(:the_command) }
+  subject { Taketo::Constructs::Command.new(:the_command) }
 
-  specify "#command= should set which command to execute" do
-    cmd.command= "rails c"
-    cmd.command.should == "rails c"
-  end
-
-  specify "#description= should set command description" do
-    cmd.description= "Run rails console"
-    cmd.description.should == "Run rails console"
-  end
+  it { should have_accessor(:command) }
+  it { should have_accessor(:description) }
 
   describe "#render" do
+    let(:server) do
+      mock(:Server,
+           :environment_variables => { :FOO => "bar baz" },
+           :default_location => "/var/apps/the app")
+    end
+
     it "should pick up server's environment variables and location" do
-      server = mock(:Server, :environment_variables => { :FOO => "bar baz" }, :default_location => "/var/apps/the app")
-      cmd.command = "rails c"
-      cmd.render(server).should == "cd /var/apps/the\\ app; FOO=bar\\ baz rails c"
+      subject.command = "rails c"
+      subject.render(server).should == "cd /var/apps/the\\ app; FOO=bar\\ baz rails c"
+    end
+
+    it "should let user override default directory" do
+      subject.command = "rails c"
+      subject.render(server, :directory => "/var/qux").should == "cd /var/qux; FOO=bar\\ baz rails c"
     end
   end
 end

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

@@ -1,30 +1,18 @@
 require File.expand_path('../../../../spec_helper', __FILE__)
+require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/config'
 
 include Taketo
 
 describe "Config" do
-  let(:config) { Taketo::Constructs::Config.new }
+  subject { Taketo::Constructs::Config.new }
 
-  describe "#append_project" do
-    it "should add project to config's projects collection" do
-      project = stub(:name => :foo)
-      config.append_project(project)
-      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_behaves_like "a construct with nodes", :projects, :project
 
   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"
+    subject.default_destination.should be_nil
+    subject.default_destination = "foo:bar:baz"
+    subject.default_destination.should == "foo:bar:baz"
   end
 end
 

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

@@ -1,34 +1,22 @@
 require File.expand_path('../../../../spec_helper', __FILE__)
+require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/environment'
 
 include Taketo
 
 describe "Environment" do
-  let(:environment) { Taketo::Constructs::Environment.new(:foo) }
+  subject { Taketo::Constructs::Environment.new(:foo) }
 
   it "should have name" do
-    environment.name.should == :foo
+    subject.name.should == :foo
   end
 
-  describe "#append_server" do
-    let(:server) { mock(:Server, :name => :foo).as_null_object }
+  it_behaves_like "a construct with nodes", :servers, :server
 
-    it "should add a server to environment's servers collection" do
-      environment.append_server(server)
-      environment.servers.should include(server)
-    end
-
-    it "should set environment attribute on a server to self" do
-      server.should_receive(:environment=).with(environment)
-      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
+  specify "#append_server should set environment attribute on a server to self" do
+    server = mock(:Server, :name => :foo)
+    server.should_receive(:environment=).with(subject)
+    subject.append_server(server)
   end
 end
 

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

@@ -1,28 +1,16 @@
 require File.expand_path('../../../../spec_helper', __FILE__)
+require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/project'
 
 include Taketo
 
 describe "Project" do
-  let(:project) { Taketo::Constructs::Project.new(:foo) }
+  subject { Taketo::Constructs::Project.new(:foo) }
 
   it "should have name" do
-    project.name.should == :foo
-  end
-
-  describe "#append_environment" do
-    it "should add an environment to project's environments collection" do
-      environment = stub(:name => :foo)
-      project.append_environment(environment)
-      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
+    subject.name.should == :foo
   end
+  
+  it_behaves_like "a construct with nodes", :environments, :environment
 end
 

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

@@ -1,72 +1,44 @@
 require File.expand_path('../../../../spec_helper', __FILE__)
+require 'support/helpers/construct_spec_helper'
 require 'taketo/constructs/server'
 
 include Taketo
 
 describe "Server" do
-  let(:environment) { environment = stub(:Environment, :name => :the_environment) }
-  let(:server) { Taketo::Constructs::Server.new(:foo) }
+  subject { Taketo::Constructs::Server.new(:foo) }
 
   it "should have name" do
-    server.name.should == :foo
+    subject.name.should == :foo
   end
 
-  it "should set host" do
-    server.host = "foo"
-    server.host.should == "foo"
-  end
-
-  it "should set port" do
-    server.port = "foo"
-    server.port.should == "foo"
-  end
-
-  it "should set username" do
-    server.username = "foo"
-    server.username.should == "foo"
-  end
-
-  it "should set default_location" do
-    server.default_location = "foo"
-    server.default_location.should == "foo"
-  end
+  it { should have_accessor(:host) }
+  it { should have_accessor(:port) }
+  it { should have_accessor(:username) }
+  it { should have_accessor(:default_location) }
+  it { should have_accessor(:global_alias) }
 
   describe "#environment=" do
+    let(:environment) { environment = stub(:Environment, :name => :the_environment) }
+
     it "should set environment" do
-      server.environment = environment
-      server.environment.should == environment
+      subject.environment = environment
+      subject.environment.should == environment
     end
 
     it "should set RAILS_ENV environment variable" do
-      server.environment_variables.should == {}
-      server.environment = environment
-      server.environment_variables[:RAILS_ENV].should == environment.name.to_s
+      subject.environment_variables.should == {}
+      subject.environment = environment
+      subject.environment_variables[:RAILS_ENV].should == environment.name.to_s
     end
   end
 
   it "should set environment variables" do
-    server.env :FOO => "bar"
-    server.env :BAR => "baz"
-    server.environment_variables.should include(:FOO => "bar", :BAR => "baz")
+    subject.env :FOO => "bar"
+    subject.env :BAR => "baz"
+    subject.environment_variables.should include(:FOO => "bar", :BAR => "baz")
   end
 
-  context "Commands" do
-    let(:command) { mock(:Command, :name => :foo).as_null_object }
-
-    describe "#append_command" do
-      it "should add a command to servers's commands collection" do
-        server.append_command(command)
-        server.commands.should include(command)
-      end
-    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
+  it_behaves_like "a construct with nodes", :commands, :command
 end
 
 

data/spec/lib/taketo/destination_resolver_spec.rb

@@ -5,36 +5,57 @@ 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))
-      ))
-    ))
+  class TestNode
+    attr_reader :name, :node_type
+    def initialize(node_type, name, *nodes)
+      @node_type, @name, @nodes = node_type, name, nodes
+    end
+
+    def find(type, name)
+      @nodes.detect { |s| s.name == name } or raise KeyError, name.to_s
+    end
+
+    def nodes(type)
+      @nodes
+    end
+
+    def global_alias
+      :the_alias if name == :s1 && node_type == :server
+    end
   end
 
+  [:project, :environment, :server].each do |node_type|
+    define_method node_type do |name, *nodes|
+      TestNode.new(node_type, name, *nodes)
+    end
+  end
+
+  let(:server1) { server(:s1) }
+  let(:environment1) { environment(:bar, server1) }
+  let(:project1) { project(:foo, environment1) }
+
+  let(:server2) { server(:s2) }
+  let(:environment2) { environment(:qux, server2) }
+  let(:project2) { project(:baz, environment2) }
+
+  let(:server3) { server(:s3) }
+  let(:server4) { server(:s4) }
+  let(:environment3) { environment(:corge, server3, server4) }
+  let(:project3) { environment(:quux, environment3) }
+
+  let(:environment4) { environment(:garply, server(:s5), server(:s6)) }
+  let(:environment5) { environment(:waldo, server(:s7)) }
+  let(:project4) { project(:grault, environment4, environment5) }
+
+  let(:config) { TestNode.new(:config, nil, project1, project2, project3, project4) }
+
   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)
+      expect { resolver(config, "foo:bar:noserver").resolve }.to raise_error(NonExistentDestinationError)
     end
   end
 
@@ -46,13 +67,13 @@ describe "DestinationResolver" do
       end
 
       it "should raise error if there are multiple servers" do
-        expect { resolver(config, "quux:corge").resolve }.to raise_error(AmbiguousDestinationError, /servers/i)
+        expect { resolver(config, "quux:corge").resolve }.to raise_error(AmbiguousDestinationError)
       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)
+        expect { resolver(config, "chunky:bacon").resolve }.to raise_error(NonExistentDestinationError)
       end
     end
   end
@@ -68,21 +89,21 @@ describe "DestinationResolver" do
 
         context "when there are multiple servers" do
           it "should raise error" do
-            expect { resolver(config, "quux").resolve }.to raise_error(AmbiguousDestinationError, /servers/i)
+            expect { resolver(config, "quux").resolve }.to raise_error(AmbiguousDestinationError)
           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)
+          expect { resolver(config, "grault").resolve }.to raise_error(AmbiguousDestinationError)
         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)
+        expect { resolver(config, "chunky").resolve }.to raise_error(NonExistentDestinationError)
       end
     end
   end
@@ -93,31 +114,16 @@ describe "DestinationResolver" 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
-                  ))
-                ))
-              ))
-
+              config = TestNode.new(:config, nil, project1)
+              config.stub(:default_destination => nil)
               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
-                  ))
-                ))
-              ))
-
+              config = TestNode.new(:config, nil, project3)
+              config.stub(:default_destination => nil)
               expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /server/i
             end
           end
@@ -125,13 +131,8 @@ describe "DestinationResolver" do
 
         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])
-              ))
-            ))
-
+            config = TestNode.new(:config, nil, project4)
+            config.stub(:default_destination => nil)
             expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /environment/i
           end
         end
@@ -139,10 +140,8 @@ describe "DestinationResolver" do
 
       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])
-          ))
+          config = TestNode.new(:config, nil, project3, project4)
+          config.stub(:default_destination => nil)
 
           expect { resolver(config, "").resolve }.to raise_error AmbiguousDestinationError, /projects/i
         end
@@ -157,24 +156,32 @@ describe "DestinationResolver" do
     end
   end
 
+  context "when there is global matching server alias" do
+    it "should resolve by alias" do
+      resolver(config, "the_alias").resolve.should == server1
+    end
+  end
+
   describe "#get_node" do
     it "should return server when path has 3 segments and is correct" do
       resolver(config, "foo:bar:s1").get_node.should == server1
     end
 
     it "should return environment when path has 2 segments and is correct" do
-      resolver(config, "foo:bar").get_node.name.should == :bar
+      resolver(config, "foo:bar").get_node.should == environment1
     end
 
     it "should return project when path has 1 segment and is correct" do
-      resolver(config, "foo").get_node.name.should == :foo
+      resolver(config, "foo").get_node.should == project1
     end
 
-    it "should return the config if path has is empty" do
+    it "should return the config if path has is empty and there's no default destination" do
+      config.stub(:default_destination => nil)
       resolver(config, "").get_node.should == config
     end
 
     it "should raise NonExistentDestinationError when path is not correct" do
+      config.should_receive(:find).with(:project, :i).and_raise(KeyError)
       expect { resolver(config, "i").get_node }.to raise_error(NonExistentDestinationError)
     end
   end

data/spec/lib/taketo/dsl_spec.rb

@@ -107,6 +107,10 @@ describe "DSL" do
           it_behaves_like "an attribute", :env, :server, :env, { :FOO => "bar" }
         end
 
+        describe "#global_alias" do
+          it_behaves_like "an attribute", :global_alias, :server, :global_alias=, "foobared"
+        end
+
         describe "#command" do
           it_behaves_like "a scope", :command, :server
 

data/spec/support/helpers/construct_spec_helper.rb

@@ -0,0 +1,15 @@
+shared_examples "a construct with nodes" do |name_plural, name_singular|
+  specify "#append_#{name_singular} should add a #{name_singular} to " +   # specify "#append_server should add a server to " +
+    "#{subject.class.name}'s #{name_plural} collection" do                 #   "environment's servers collection" do
+    node = mock(:name => :foo).as_null_object                              #   server = mock(:name => :foo).as_null_object
+    subject.send("append_#{name_singular}", node)                          #   environment.append_server(server)
+    subject.send(name_plural).should include(node)                         #   environment.servers.should include(server)
+  end                                                                      # end
+
+  specify "#find_#{name_singular} should find #{name_singular} by name" do # specify "#find_server should find server by name" do
+    subject.send(name_plural).should_receive(:find_by_name).               #   environment.servers.should_receive(:find_by_name).
+      with(:foo).and_return(:bar)                                          #     with(:foo).and_return(:bar)
+    subject.send("find_#{name_singular}", :foo).should == :bar             #   environment.find_server(:foo).should == :bar
+  end                                                                      # end
+end
+

data/spec/support/matchers/have_accessor_matcher.rb

@@ -0,0 +1,7 @@
+RSpec::Matchers.define :have_accessor do |accessor|
+  match do |construct|
+    construct.send("#{accessor}=", :foo)
+    construct.send(accessor) == :foo
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taketo
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-22 00:00:00.000000000 Z
+date: 2012-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -118,12 +118,15 @@ files:
 - spec/lib/taketo/support/eval_delegator_spec.rb
 - spec/lib/taketo/support/named_nodes_collection_spec.rb
 - spec/spec_helper.rb
+- spec/support/helpers/construct_spec_helper.rb
 - spec/support/helpers/dsl_spec_helper.rb
 - spec/support/matchers/be_appropriate_construct_matcher.rb
 - spec/support/matchers/enclose_scope_matcher.rb
+- spec/support/matchers/have_accessor_matcher.rb
 - features/commands.feature
 - features/config_validation.feature
 - features/connect_to_server.feature
+- features/error_handling.feature
 - features/help.feature
 - features/step_definitions/main_steps.rb
 - features/support/env.rb