taketo 0.0.1 → 0.0.2

data/lib/taketo/dsl.rb

@@ -1,9 +1,9 @@
-require 'taketo/support'
+require 'taketo/constructs_factory'
 
 module Taketo
   class DSL
     class ScopeError < StandardError; end
-    
+
     class << self
       def define_scope(scope, parent_scope)
         define_method scope do |name, &block|
@@ -11,7 +11,7 @@ module Taketo
             raise ScopeError,
               "#{scope} can't be defined in #{current_scope} scope"
           end
-          scope_object = @factory.send("create_#{scope}", name)
+          scope_object = @factory.create(scope, name)
           in_scope(scope, scope_object) do
             block.call
           end
@@ -20,7 +20,7 @@ module Taketo
 
       def define_attribute(name, parent_scope, &block)
         define_method name do |attribute|
-          unless server_scope?
+          unless current_scope?(parent_scope)
             raise ScopeError,
               "#{name} can't be defined in #{current_scope} scope"
           end
@@ -31,36 +31,36 @@ module Taketo
 
     attr_reader :current_scope_object, :config
 
-    def initialize(factory)
+    def initialize(factory = Taketo::ConstructsFactory.new)
       @factory = factory
       @scope = [:config]
       @config = @current_scope_object = factory.create_config
     end
 
-    def configure(&block)
-      instance_eval(&block)
+    def configure(filename = nil, &block)
+      if filename
+        filename = filename.to_s
+        config_text = File.read(filename)
+        instance_eval config_text, filename, 1
+      elsif block
+        instance_eval(&block)
+      else
+        raise ArgumentError, "Either filename or block should be provided"
+      end
       @config
     end
 
     define_scope :project, :config
     define_scope :environment, :project
     define_scope :server, :environment
+    define_scope :command, :server
 
-    define_attribute :host, :server do |hostname|
-      current_scope_object.host = hostname
-    end
-
-    define_attribute :port, :server do |port_number|
-      current_scope_object.port = port_number
-    end
-
-    define_attribute :user, :server do |username|
-      current_scope_object.username = username
-    end
-
-    define_attribute :location, :server do |path|
-      current_scope_object.default_location = path
-    end
+    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
 
@@ -72,7 +72,7 @@ module Taketo
       current_scope == scope
     end
 
-    [:config, :project, :environment, :server].each do |scope|
+    [:config, :project, :environment, :server, :command].each do |scope|
       define_method("#{scope}_scope?") { current_scope == scope }
     end
 
@@ -80,7 +80,7 @@ module Taketo
       parent_scope_object, @current_scope_object = @current_scope_object, new_scope_object
       @scope << scope
       yield
-      parent_scope_object.send("append_#{scope}", current_scope_object) 
+      parent_scope_object.send("append_#{scope}", current_scope_object)
       @scope.pop
       @current_scope_object = parent_scope_object
     end

data/lib/taketo/support/key_error.rb

@@ -0,0 +1,4 @@
+unless defined? KeyError
+  class KeyError < StandardError; end
+end
+

data/lib/taketo/support/named_nodes_collection.rb

@@ -0,0 +1,26 @@
+require 'forwardable'
+require 'taketo/support'
+
+module Taketo
+  module Support
+    class NamedNodesCollection
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :@nodes, :each, :<<, :push, :length, :size, :empty?
+
+      def initialize(nodes = [])
+        @nodes = nodes
+      end
+
+      def [](index)
+        if index.is_a?(Symbol)
+          node = @nodes.detect { |n| n.name == index } or raise KeyError, "Element with name #{index} not found"
+          return node
+        end
+        @nodes[index] or raise KeyError, "Element ##{index} not found"
+      end
+    end
+  end
+end
+

data/lib/taketo/support.rb

@@ -4,4 +4,6 @@ module Taketo
 end
 
 require 'taketo/support/eval_delegator'
+require 'taketo/support/named_nodes_collection'
+require 'taketo/support/key_error'
 

data/lib/taketo/taketo_argv_parser.rb

@@ -0,0 +1,48 @@
+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/lib/taketo.rb

@@ -1,9 +1,10 @@
 module Taketo
   version_file = File.expand_path('../VERSION', File.dirname(__FILE__))
-  VERSION = File.read(version_file).freeze
+  VERSION = File.read(version_file).freeze unless defined? VERSION
 end
 
 require 'taketo/support'
 require 'taketo/dsl'
 require 'taketo/commands'
+require 'taketo/config_validator'
 

data/spec/lib/{commands → taketo/commands}/ssh_command_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../../../../spec_helper', __FILE__)
 require 'taketo/commands/ssh_command'
 
 include Taketo::Commands
@@ -11,33 +11,27 @@ describe "SSH Command" do
                   :port => 22,
                   :username => "deployer", 
                   :default_location => "/var/app",
-                  :environment => environment)
+                  :environment => environment,
+                  :environment_variables => {})
   end
+  let(:command) { mock(:Command, :render => "the_command") }
 
   let(:ssh_command) { SSHCommand.new(server) }
 
   it "should compose command based on provided server object" do
-    ssh_command.render("bash").should == %q[ssh -t -p 22 "deployer"@"1.2.3.4" "cd '/var/app'; RAILS_ENV=staging bash"]
+    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"]
   end
 
   it "should ignore absent parts" do
     server.stub(:port => nil)
     server.stub(:username => nil)
-    ssh_command.render("bash").should == %q[ssh -t "1.2.3.4" "cd '/var/app'; RAILS_ENV=staging bash"]
-
-    server.stub(:default_location => nil)
-    ssh_command.render("bash").should == %q[ssh -t "1.2.3.4" "RAILS_ENV=staging bash"]
+    ssh_command.render(command).should == %q[ssh -t 1.2.3.4 "the_command"]
   end
 
   it "should require host" do
     server.stub(:host => nil)
-    expect do
-      ssh_command.render("bash")
-    end.to raise_error ArgumentError, /host/
-  end
-
-  it "should have 'bash' as command default" do
-    ssh_command.render.should =~ /bash/
+    expect { ssh_command.render("bash") }.to raise_error ArgumentError, /host/
   end
 end
 

data/spec/lib/taketo/config_validator_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'taketo/config_validator'
+
+include Taketo
+
+describe "ConfigValidator" do
+  it "should require at least one project" do
+    config = stub(:projects => [])
+    expect { validator(config).validate! }.to raise_error ConfigError, /projects/i
+  end
+
+  it "should require every project to have at least one environment" do
+    project_1 = stub(:Project, :name => :project_1, :environments => [])
+    project_2 = stub(:Project, :name => :project_2, :environments => [stub])
+
+    config = stub(:projects => [project_1, project_2])
+    expect { validator(config).validate! }.to raise_error ConfigError, /project_1/i
+
+    project_1.stub(:environments => { :e => stub })
+    expect { validator(config).validate! }.not_to raise_error ConfigError, /project_1/i
+  end
+
+  it "should require every environment to have at least one server" do
+    environment_1 = stub(:Environment, :name => :environment_1, :servers => [])
+    environment_2 = stub(:Environment, :name => :environment_2, :servers => [stub])
+    project_1 = stub(:Project, :name => :project_1, :environments => [environment_1])
+    project_2 = stub(:Project, :name => :project_2, :environments => [environment_2])
+
+    config = stub(:projects => [project_1, project_2])
+    expect { validator(config).validate! }.to raise_error ConfigError, /environment_1/i
+
+    environment_2.stub(:servers => [stub])
+    expect { validator(config).validate! }.not_to raise_error ConfigError, /environment_2/i
+  end
+
+  def validator(config)
+    Taketo::ConfigValidator.new(config)
+  end
+end
+
+

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

@@ -0,0 +1,22 @@
+require File.expand_path('../../../../spec_helper', __FILE__)
+require 'taketo/constructs/command'
+
+include Taketo
+
+describe "Command" do
+  let(:cmd) { 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
+
+  describe "#render" do
+    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"
+    end
+  end
+end
+

data/spec/lib/{constructs → taketo/constructs}/config_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../../../../spec_helper', __FILE__)
 require 'taketo/constructs/config'
 
 include Taketo
@@ -10,7 +10,7 @@ describe "Config" do
     it "should add project to config's projects collection" do
       project = stub(:name => :foo)
       config.append_project(project)
-      config.projects[:foo].should == project
+      config.projects.should include(project)
     end
   end
 end

data/spec/lib/{constructs → taketo/constructs}/environment_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../../../../spec_helper', __FILE__)
 require 'taketo/constructs/environment'
 
 include Taketo
@@ -15,7 +15,7 @@ describe "Environment" do
 
     it "should add a server to environment's servers collection" do
       environment.append_server(server)
-      environment.servers[:foo].should == server
+      environment.servers.should include(server)
     end
 
     it "should set environment attribute on a server to self" do

data/spec/lib/{constructs → taketo/constructs}/project_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../../../../spec_helper', __FILE__)
 require 'taketo/constructs/project'
 
 include Taketo
@@ -14,7 +14,7 @@ describe "Project" do
     it "should add an environment to project's environments collection" do
       environment = stub(:name => :foo)
       project.append_environment(environment)
-      project.environments[:foo].should == environment
+      project.environments.should include(environment)
     end
   end
 end

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

@@ -0,0 +1,84 @@
+require File.expand_path('../../../../spec_helper', __FILE__)
+require 'taketo/constructs/server'
+
+include Taketo
+
+describe "Server" do
+  let(:environment) { environment = stub(:Environment, :name => :the_environment) }
+  let(:server) { Taketo::Constructs::Server.new(:foo) }
+
+  it "should have name" do
+    server.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
+
+  describe "#environment=" do
+    it "should set environment" do
+      server.environment = environment
+      server.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
+    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")
+  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 "#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
+      end
+    end
+  end
+end
+
+

data/spec/lib/{constructs_factory_spec.rb → taketo/constructs_factory_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../spec_helper', __FILE__)
 require 'taketo/constructs_factory'
 
 include Taketo
@@ -6,6 +6,14 @@ include Taketo
 describe "ConstructsFactory" do
   let(:factory) { Taketo::ConstructsFactory.new }
 
+  specify "#create should delegate to appripriate method according to type" do
+    factory.should_receive(:create_config)
+    factory.create(:config)
+
+    factory.should_receive(:create_project).with(:foo)
+    factory.create(:project, :foo)
+  end
+
   specify "#create_config should create a config object" do
     factory.create_config.should be_an_instance_of(Taketo::Constructs::Config)
   end
@@ -24,5 +32,10 @@ describe "ConstructsFactory" do
     server = factory.create_server(:foo)
     server.should be_an_instance_of(Taketo::Constructs::Server)
   end
+
+  specify "#create_command should create a command object" do
+    command = factory.create_command(:foo)
+    command.should be_an_instance_of(Taketo::Constructs::Command)
+  end
 end
 

data/spec/lib/{dsl_spec.rb → taketo/dsl_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../spec_helper', __FILE__)
 require 'support/helpers/dsl_spec_helper'
 require 'taketo/dsl'
 
@@ -19,8 +19,8 @@ describe "DSL" do
     end
 
     it "should create a #{scope_name} and set it as current scope object" do
-      factory.should_receive("create_#{scope_name}").with(:bar)
-      dsl(parent_scope, factory.send("create_#{parent_scope_name}")) do |c|
+      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
@@ -28,14 +28,14 @@ describe "DSL" do
     end
 
     it "should not leak #{scope_name} as current scope object" do
-      dsl(parent_scope, factory.send("create_#{parent_scope_name}")) do |c|
+      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.send("create_#{parent_scope_name}")) do |c|
+      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
@@ -51,8 +51,8 @@ describe "DSL" do
       it { should_not be_appropriate_construct(attribute_name, example_value).under(inaproppriate_scope) }
     end
 
-    it "should set #{parent_scope_method.to_s.gsub('=', '')} attribute on current server" do
-      dsl(parent_scope, factory.send("create_#{parent_scope_name}", :foo)) do |c|
+    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
@@ -83,6 +83,18 @@ describe "DSL" do
         describe "#location" do
           it_behaves_like "an attribute", :location, :server, :default_location=, "/var/app/"
         end
+
+        describe "#env" do
+          it_behaves_like "an attribute", :env, :server, :env, { :FOO => "bar" }
+        end
+
+        describe "#command" do
+          it_behaves_like "a scope", :command, :server
+
+          describe "#execute" do
+            it_behaves_like "an attribute", :execute, :command, :command=, "rails c"
+          end
+        end
       end
     end
   end
@@ -104,5 +116,31 @@ describe "DSL" do
       end
     end
   end
+
+  describe "#configure" do
+    it "should read config from file if filename passed" do
+      File.stub(:read => "the config")
+      dsl = Taketo::DSL.new(factory)
+      dsl.should_receive(:instance_eval) do |config, *args|
+        config.should == "the config"
+      end
+      dsl.configure("path/to/config")
+    end
+
+    it "should be configured from block unless filename specified" do
+      dsl = Taketo::DSL.new(factory)
+      config = proc { }
+      dsl.should_receive(:instance_eval).with(&config)
+      dsl.configure &config
+    end
+
+    it "should raise an error if neither config filename nor block passed" do
+      expect do
+        Taketo::DSL.new(factory).configure
+      end.to raise_error ArgumentError, /(config|block)/
+    end
+
+    it "should raise meaningful error if config parse failed"
+  end
 end
 

data/spec/lib/{support → taketo/support}/eval_delegator_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../../../../spec_helper', __FILE__)
 require 'taketo/support/eval_delegator'
 
 class EvalDelegatorContext

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

@@ -0,0 +1,29 @@
+require File.expand_path('../../../../spec_helper', __FILE__)
+require 'taketo/support/named_nodes_collection'
+
+describe "NamedNodesCollection" do
+  let(:collection) { Taketo::Support::NamedNodesCollection.new }
+  let(:node1) { stub(:name => :foo) }
+  let(:node2) { stub(:name => :bar) }
+
+  it "should be able to initialize with array" do
+    Taketo::Support::NamedNodesCollection.new([1, 2, 3]).length.should == 3
+  end
+
+  it "should mimic Array" do
+    collection.should be_empty
+    collection << node1
+    collection.push node2
+    collection[0].should == node1
+    collection.map(&:name).should == [:foo, :bar]
+    collection.length.should == 2
+    collection.size.should == 2
+  end
+
+  it "should raise error if element not found" do
+    expect { collection[3] }.to raise_error KeyError, /#3/i
+    expect { collection[:quux] }.to raise_error KeyError, /name/i
+  end
+end
+
+