taketo 0.0.6 → 0.0.7

data/lib/taketo/config_visitor.rb

@@ -0,0 +1,29 @@
+require 'taketo/constructs'
+
+module Taketo
+  def self.downcased_construct_class_name(klass)
+    klass.name.gsub("Taketo::Constructs::", "").gsub(/[A-Z][^A-Z]*/) { |s| s.gsub("::", "").downcase + "_" }.chop
+  end
+
+  class ConfigVisitor
+    include Taketo::Constructs
+
+    def self.visit(*klasses, &block)
+      klasses.each do |klass|
+        define_method(:"visit_#{Taketo.downcased_construct_class_name(klass)}", block)
+      end
+    end
+
+    def visit(obj)
+      obj.class.ancestors.each do |ancestor|
+        next unless ancestor.name # skip anonymous classes
+        method_name = :"visit_#{Taketo.downcased_construct_class_name(ancestor)}"
+        next unless respond_to?(method_name)
+        return send(method_name, obj)
+      end
+
+      raise "Don't know how to visit #{obj.class}"
+    end
+  end
+end
+

data/lib/taketo/constructs/base_construct.rb

@@ -1,72 +1,27 @@
 require 'taketo/support'
+require 'taketo/associated_nodes'
 
 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
+      include AssociatedNodes
+      attr_reader :name
 
       def initialize(name)
+        super
         @name = name
-        @nodes = {}
-      end
-
-      def find(singular_node_name, name)
-        send("find_#{singular_node_name}", name) or
-          if block_given?
-            yield
-          else
-            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
-      
+
+      def qualified_name
+        "#{node_type} #{self.name}"
+      end
+
     end
   end
 end

data/lib/taketo/constructs/command.rb

@@ -7,7 +7,15 @@ module Taketo
       include Shellwords
 
       attr_accessor :command, :description
-      
+
+      def self.default
+        new(:default).tap { |cmd| cmd.command = "bash" }
+      end
+
+      def self.explicit_command(command_string)
+        new(:explicit_command).tap { |cmd| cmd.command = command_string }
+      end
+
       def render(server, options = {})
         %Q[#{location(server, options)} #{environment_variables(server)} #{command}].strip.squeeze(" ")
       end

data/lib/taketo/constructs/environment.rb

@@ -6,9 +6,19 @@ module Taketo
     class Environment < BaseConstruct
       has_nodes :servers, :server
 
+      attr_accessor :project
+
+      def initialize(name)
+        super(name)
+      end
+
+      def project_name
+        @project.name if defined? @project
+      end
+
       def append_server(server)
         server.environment = self
-        nodes(:servers) << server
+        super
       end
     end
   end

data/lib/taketo/constructs/project.rb

@@ -5,6 +5,11 @@ module Taketo
   module Constructs
     class Project < BaseConstruct
       has_nodes :environments, :environment
+
+      def append_environment(environment)
+        environment.project = self
+        super
+      end
     end
   end
 end

data/lib/taketo/constructs/server.rb

@@ -1,14 +1,13 @@
 require 'taketo/constructs/base_construct'
+require 'taketo/constructs/command'
 require 'taketo/support'
 
 module Taketo
-  class CommandNotFoundError < StandardError; end
-
   module Constructs
     class Server < BaseConstruct
       attr_reader :environment_variables
-      attr_accessor :host, :port, :username, :default_location, :environment, :global_alias, :identity_file
-      
+      attr_accessor :host, :port, :username, :default_location, :default_command, :environment, :global_alias, :identity_file
+
       has_nodes :commands, :command
 
       def initialize(name)
@@ -24,6 +23,10 @@ module Taketo
         env(:RAILS_ENV => environment.name.to_s)
         @environment = environment
       end
+
+      def default_command
+        defined?(@default_command) ? @default_command : Command.default
+      end
     end
   end
 end

data/lib/taketo/dsl.rb

@@ -74,9 +74,20 @@ module Taketo
       @shared_server_configs.store(name.to_sym, blk)
     end
 
-    define_method_in_scope(:include_shared_server_config, :server) do |name, *args|
-      instance_exec(*args, &shared_server_configs[name])
+    define_method_in_scope(:include_shared_server_config, :server) do |*args|
+      if args.first.is_a?(Hash)
+        configs_and_arguments = args.shift
+        configs_and_arguments.each do |config_name, arguments|
+          instance_exec(*arguments, &shared_server_configs[config_name])
+        end
+      else
+        args.each do |config_name|
+          instance_exec(&shared_server_configs[config_name])
+        end
+      end
     end
+    alias :include_shared_server_configs :include_shared_server_config
+
 
     private
 

data/lib/taketo/support/named_nodes_collection.rb

@@ -15,6 +15,7 @@ module Taketo
 
       def push(node)
         @nodes << node unless find_by_name(node.name)
+        self
       end
       alias :<< :push
 
@@ -29,6 +30,15 @@ module Taketo
       def find_by_name(name)
         @nodes.detect { |n| n.name == name }
       end
+
+      def ==(other)
+        return true if other.equal?(self)
+        @nodes == other.is_a?(NamedNodesCollection) ? other.nodes : other
+      end
+
+      protected
+      
+      attr_reader :nodes
     end
   end
 end

data/lib/taketo/support.rb

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

data/lib/taketo.rb

@@ -6,6 +6,7 @@ end
 require 'taketo/support'
 require 'taketo/dsl'
 require 'taketo/commands'
+require 'taketo/config_traverser'
 require 'taketo/config_validator'
-require 'taketo/config_printer'
+require 'taketo/config_printer_visitor'
 

data/spec/integration/dsl_integration_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/dsl'
 
 describe "Taketo DSL" do

data/spec/lib/taketo/associated_nodes_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'taketo/associated_nodes'
+
+include Taketo
+
+class TestAssociatedNodes
+  include AssociatedNodes
+
+  has_nodes :foos, :foo
+end
+
+describe "AssociatedNodes" do
+  subject(:construct) { TestAssociatedNodes.new(:my_node) }
+  let(:foo) { stub(:FooNode, :name => :bar) }
+
+  describe ".has_nodes" do
+    it "adds node type to class's node_types" do
+      expect(TestAssociatedNodes.node_types).to include(:foos)
+    end
+
+    specify "#foos returns mutable foos collection" do
+      construct.nodes(:foos) << foo
+      expect(construct.foos).to eq([foo])
+    end
+
+    specify "#append_foo adds a foo to nested foos collection" do
+      construct.nodes(:foos) << foo
+      expect(construct.nodes(:foos)).to include(foo)
+    end
+
+    specify "#find_foo returns node with corresponding name" do
+      construct.nodes(:foos) << foo
+      expect(construct.find_foo(:bar)).to eq(foo)
+    end
+
+    describe "#has_foos?" do
+      context "when there are no foos" do
+        it "returns false" do
+          expect(construct).not_to have_foos
+        end
+      end
+
+      context "when there are some foos" do
+        it "returns true" do
+          construct.nodes(:foos) << foo
+          expect(construct).to have_foos
+        end
+      end
+    end
+  end
+
+  describe "#find" do
+    context "when node is present" do
+      it "returns node object with corresponding name" do
+        construct.nodes(:foos) << foo
+        expect(construct.find(:foo, :bar)).to eq(foo)
+      end
+    end
+
+    context "when node is absent" do
+      it "yields if block given" do
+        expect { |b| construct.find(:foo, :bar, &b) }.to yield_control
+      end
+
+      it "raises KeyError if no block given" do
+        expect { construct.find(:foo, :bar) }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe "#nodes" do
+    it "returns nodes collection by plural name" do
+      construct.nodes(:foos) << foo
+      expect(construct.nodes(:foos)).to eq([foo])
+    end
+
+    it "raises NodesNotDefinedError if non-specified node requested" do
+      expect { construct.nodes(:bars) }.to raise_error(NodesNotDefinedError, /bars/)
+    end
+  end
+
+  describe "#has_nodes?" do
+    context "when nodes are present" do
+      it "returns true" do
+        construct.nodes(:foos) << foo
+        expect(construct).to have_nodes(:foos)
+      end
+    end
+
+    context "when nodes are absent" do
+      it "returns false" do
+        expect(construct).not_to have_nodes(:foos)
+      end
+    end
+
+    it "raises if node can not have children of specified type" do
+      expect { construct.has_nodes?(:quack) }.to raise_error NodesNotDefinedError
+    end
+  end
+end
+

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

@@ -1,10 +1,9 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
+require 'spec_helper'
 require 'taketo/commands/ssh_command'
 
 include Taketo::Commands
 
 describe "SSH Command" do
-  let(:environment) { stub(:Environment, :name => :staging) }
   let(:server) do
     stub(:Server, :name => :s1,
                   :host => "1.2.3.4", 
@@ -12,27 +11,18 @@ describe "SSH Command" do
                   :username => "deployer", 
                   :default_location => "/var/app",
                   :identity_file => "/home/gor/.ssh/qqq",
-                  :environment => environment,
                   :environment_variables => {})
   end
-  let(:command) { mock(:Command, :render => "the_command") }
 
-  let(:ssh_command) { SSHCommand.new(server) }
+  subject(:ssh_command) { SSHCommand.new(server) }
 
-  it "should compose command based on provided server object" do
+  it "composes command based on provided server object" do
     ssh_command.render("foobar").should == %q[ssh -t -p 22 -i /home/gor/.ssh/qqq deployer@1.2.3.4 "foobar"]
   end
 
-  it "should ignore absent parts" do
-    server.stub(:port => nil)
-    server.stub(:username => nil)
-    server.stub(:identity_file => nil)
+  it "ignores absent parts if they are not required" do
+    server.stub(:port => nil, :username => nil, :identity_file => nil)
     ssh_command.render("foobar").should == %q[ssh -t 1.2.3.4 "foobar"]
   end
-
-  it "should require host" do
-    server.stub(:host => nil)
-    expect { ssh_command.render("bash") }.to raise_error ArgumentError, /host/
-  end
 end
 

data/spec/lib/taketo/config_printer_visitor_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'taketo/config_printer_visitor'
+
+include Taketo
+
+describe "ConfigPrinterVisitor" do
+  subject(:printer) { ConfigPrinterVisitor.new }
+
+  describe "#visit_command" do
+    let(:command) { stub(:Command, :name => :foo, :description => nil) }
+
+    it "renders command name" do
+      printer.visit_command(command)
+      expect(printer.result).to eq("foo")
+    end
+
+    it "renders description if available" do
+      command.stub(:description => "The description")
+      printer.visit_command(command)
+      expect(printer.result).to eq("foo - The description")
+    end
+  end
+
+  describe "#visit_server" do
+    let(:server) do
+      stub(:Server,
+           :name => :sponge,
+           :host => "1.2.3.4",
+           :port => 8000,
+           :username => "bob",
+           :default_location => "/var/app",
+           :environment_variables => { :FOO => "bar", :BOO => "baz" })
+    end
+
+    it "renders available server info" do
+      server.stub(:has_commands? => true)
+      printer.visit_server(server)
+      expect(printer.result).to match(
+%r[Server: sponge
+  Host: 1\.2\.3\.4
+  Port: 8000
+  User: bob
+  Default location: /var/app
+  Environment: (FOO=bar BOO=baz|BOO=baz FOO=bar)])
+    end
+
+    it "renders appropriate message if there are no commands" do
+      server.stub(:has_commands? => false)
+      printer.visit_server(server)
+      expect(printer.result).to include("(No commands)")
+    end
+  end
+
+  describe "#visit_environment" do
+    let(:environment) { stub(:Environment, :name => :foo) }
+
+    it "renders environment info" do
+      environment.stub(:has_servers? => true)
+      printer.visit_environment(environment)
+      expect(printer.result).to eq("Environment: foo")
+    end
+
+    it "renders appropriate message if there are no servers" do
+      environment.stub(:has_servers? => false)
+      printer.visit_environment(environment)
+      expect(printer.result).to include("Environment: foo\n  (No servers)")
+    end
+  end
+
+  describe "#visit_project" do
+    let(:project) { stub(:Project, :name => :quux) }
+
+    it "renders project info" do
+      project.stub(:has_environments? => true)
+      printer.visit_project(project)
+      expect(printer.result).to eq("\nProject: quux")
+    end
+
+    it "renders appropriate message if there are no environments for project" do
+      project.stub(:has_environments? => false)
+      printer.visit_project(project)
+      expect(printer.result).to eq("\nProject: quux\n  (No environments)")
+    end
+  end
+
+  describe "#visit_config" do
+    let(:config) { stub(:Config, :default_destination => "hello:bye") }
+
+    it "renders default destination and all projects" do
+      config.stub(:has_projects? => true)
+      printer.visit_config(config)
+      expect(printer.result).to eq("Default destination: hello:bye")
+    end
+
+    it "renders appropriate message if there are no projects" do
+      config.stub(:has_projects? => false)
+      printer.visit_config(config)
+      expect(printer.result).to eq("There are no projects yet...")
+    end
+  end
+
+  it "indents relatively" do
+    config = stub(:Config, :default_destination => "hello:bye", :has_projects? => true)
+    project = stub(:Project, :name => :quux, :has_environments? => true)
+    environment = stub(:Environment, :name => :foo, :has_servers? => false)
+    printer.visit_config(config)
+    printer.visit_project(project)
+    printer.visit_environment(environment)
+    expect(printer.result).to eq("Default destination: hello:bye\n\nProject: quux\n  Environment: foo\n    (No servers)")
+  end
+end
+

data/spec/lib/taketo/config_traverser_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'taketo/config_traverser'
+
+# config           1
+#                 / \
+# project        1   2
+#               / \
+# environment  1   2
+#                 /|\
+# server         1 2 3
+
+describe Taketo::ConfigTraverser do
+  let(:server_1) { stub(:Server1, :node_type => :server, :name => :server_1).as_null_object }
+  let(:server_2) { stub(:Server2, :node_type => :server, :name => :server_2).as_null_object }
+  let(:server_3) { stub(:Server3, :node_type => :server, :name => :server_3).as_null_object }
+
+  let(:environment_1) { stub(:Environment1, :node_type => :environment, :name => :environment_1) }
+  let(:environment_2) { stub(:Environment2, :node_type => :environment, :name => :environment_2, :servers => [server_1, server_2, server_3]) }
+
+  let(:project_1) { stub(:Project1, :node_type => :project, :name => :project_1, :environments => [environment_1, environment_2]) }
+  let(:project_2) { stub(:Project2, :node_type => :project, :name => :project_2) }
+
+  let(:config) { stub(:Config, :node_type => :config, :projects => [project_1, project_2], :name => :config) }
+
+  let(:traverser) { described_class.new(config) }
+
+  before do
+    config.stub(:has_nodes?).with(:projects).and_return(true)
+    config.stub(:nodes).with(:projects).and_return([project_1, project_2])
+
+    project_1.stub(:has_nodes?).with(:environments).and_return(true)
+    project_1.stub(:nodes).with(:environments).and_return([environment_1, environment_2])
+
+    project_2.stub(:has_nodes?).with(:environments).and_return(false)
+    project_2.should_not_receive(:nodes)
+
+    environment_1.stub(:has_nodes?).with(:servers).and_return(false)
+    environment_1.should_not_receive(:nodes)
+
+    environment_2.stub(:has_nodes?).with(:servers).and_return(true)
+    environment_2.stub(:nodes).and_return([server_1, server_2, server_3])
+  end
+
+  class PrintingVisitor
+    def initialize
+      @result = []
+    end
+
+    def visit(type)
+    end
+  end
+
+  describe "#visit_depth_first" do
+    it "traverses in depth with visitor" do
+      visitor = stub(:Visitor)
+      [config, project_1, environment_1, environment_2, server_1, server_2, server_3, project_2].each do |node|
+        visitor.should_receive(:visit).with(node).ordered
+      end
+      traverser.visit_depth_first(visitor)
+    end
+  end
+end
+