rubycut-babushka 0.10.8 → 0.15.6.1

data/lib/inkan/inkan.rb

@@ -1,6 +1,6 @@
 class Inkan
   attr_accessor :credit, :comment, :comment_suffix
-  
+
   def self.legitimate?(filename)
     File.open(filename) do |file|
       file_content = file.read
@@ -14,43 +14,43 @@ class Inkan
       !seal[/\s#{sha(content || '')}\s*$/].nil?
     end
   end
-  
+
   def self.seal(file)
     new(file).tap {|inkan| yield inkan }.seal
   end
-  
+
   def self.render
     new(nil).tap {|inkan| yield inkan }.render
   end
-  
+
   def self.sha(content)
     require 'digest/sha1'
     Digest::SHA1.hexdigest(content)
   end
-  
+
   def initialize(file)
     @file = file
-    
+
     # Set Defaults
     @credit         = 'Generated by Inkan'
     @comment        = '#'
     @comment_suffix = ''
   end
-  
+
   def print(string)
     file_content << string
   end
-  
+
   def puts(string)
     file_content << string << "\n"
   end
-  
+
   def seal
     File.open(@file, 'w') do |f|
       f.print render
     end
   end
-  
+
   def render
     if file_content[/\A#!/]
       hashbang, remaining_content = file_content.split("\n", 2)
@@ -59,17 +59,17 @@ class Inkan
       "#{render_seal}\n#{file_content}"
     end
   end
-  
+
   private
-  
+
   def render_seal
     "#{comment} #{credit}. #{sha} #{comment_suffix}"
   end
-  
+
   def sha
     self.class.sha(file_content)
   end
-  
+
   def file_content
     @file_content ||= ''
   end

data/spec/acceptance/acceptance.rb

@@ -8,7 +8,7 @@ describe "babushka" do
 
   context "basics" do
     it "should have installed babushka" do
-      @vm.run('babushka --version').should =~ /^[\d.]+$/
+      @vm.run('babushka --version').should =~ /^[\d.]+ \(\w{7}\)$/
     end
   end
 
@@ -23,11 +23,11 @@ describe "babushka" do
       @vm.babushka('benhoskings:system') # once to set the locale
       @vm.should meet('benhoskings:system')
     end
-    it "should build ruby 1.9" do
-      @vm.should meet('benhoskings:ruby19.src')
+    it "should build a recent ruby" do
+      @vm.should meet('benhoskings:ruby.src')
     end
     it "should set up nginx" do
-      @vm.should meet('benhoskings:webserver running.nginx')
+      @vm.should meet('benhoskings:running.nginx')
     end
   end
 

data/spec/acceptance_helper.rb

@@ -7,8 +7,8 @@ require 'cloudservers'
 require 'spec_helper'
 
 class Babushka::Logging
-  def self.print_log message, printable
-    print message if printable
+  def self.write_to_persistent_log message
+    # Don't overwrite logs when running acceptance specs.
   end
 end
 
@@ -20,7 +20,7 @@ class VM
   SERVER_NAME = 'babushka-specs'
 
   def babushka task
-    run("babushka \"#{task}\" --defaults --no-colour").tap {|result|
+    run("babushka \"#{task}\" --defaults").tap {|result|
       # Fetch the debug log if the dep failed
       run "cat ~/.babushka/logs/\"#{task}\"" unless result
     }
@@ -83,11 +83,13 @@ class VM
   end
 
   def image
-    connection.list_images.detect {|image| image[:name][cfg['image_name']] }
+    connection.list_images.detect {|image| image[:name][cfg['image_name']] } ||
+      raise(RuntimeError, "Couldn't find an image that matched '#{cfg['image_name']}'.")
   end
 
   def flavor
-    connection.list_flavors.detect {|flavor| flavor[:ram] == 256 }
+    connection.list_flavors.detect {|flavor| flavor[:ram] == 256 } ||
+      raise(RuntimeError, "Couldn't find the specs for a 256MB instance.")
   end
 
   def connection
@@ -95,9 +97,11 @@ class VM
       :username => cfg['username'], :api_key => cfg['api_key']
     )
   end
+
   def cfg
     @_cfg ||= YAML.load_file(Babushka::Path.path / 'conf/rackspace.yml')
   end
+
   def public_key
     Dir.glob(File.expand_path("~/.ssh/id_[dr]sa.pub")).first
   end
@@ -108,6 +112,6 @@ RSpec::Matchers.define :meet do |expected|
     vm.babushka(expected).should =~ /^\} ✓ #{Regexp.escape(expected)}\z/
   }
   failure_message_for_should {|vm|
-    "The '#{expected}' dep couldn't bet met."
+    "The '#{expected}' dep couldn't be met."
   }
 end

data/spec/babushka/accepts_for_spec.rb

@@ -1,174 +1,169 @@
 require 'spec_helper'
 require 'accepts_for_support'
 
-describe "invalid input" do
-  it "should reject values and a block at once" do
-    L{
-      AcceptsForTest.new.records "stuff" do
-        more "stuff"
-      end
-    }.should raise_error(ArgumentError, "You can supply arguments or a block, but not both.")
-  end
-end
+describe "accepts_*_for" do
+  subject { AcceptsForTest.new }
 
-describe "storing" do
-  before {
-    @list = AcceptsForTest.new
-  }
-  it "should return self to allow chaining" do
-    [
-      :package, :renders, :format, :records, :produces, :valid_formats
-    ].each {|method_name|
-      @list.send(method_name, "hello").should == @list
-    }
+  describe "invalid input" do
+    it "should reject values and a block at once" do
+      L{
+        subject.records "stuff" do
+          more "stuff"
+        end
+      }.should raise_error(ArgumentError, "You can supply arguments or a block, but not both.")
+    end
   end
-end
 
-describe "accepts_value_for" do
-  before {
-    @value = AcceptsForTest.new
-  }
-  it "should return nil for no input" do
-    @value.package.should == nil
-  end
-  it "should return the correct default when no value is stored" do
-    @value.renders.should == "a default response"
-    @value.format.should == "json"
-  end
-  it "should return the value when called without args" do
-    [:package, :renders, :format].each {|method_name|
-      @value.send(method_name, "hello").send(method_name).should == "hello"
-    }
-  end
-  it "should return the result of callable items" do
-    [:package, :renders, :format].each {|method_name|
-      @value.send(method_name, L{ "world" }).send(method_name).should == "world"
-    }
-  end
-  it "should replace existing values with new ones" do
-    @value.package "ruby-1.8"
-    @value.package "ruby-1.9"
-    @value.package.should == "ruby-1.9"
+  describe "storing" do
+    it "should return self to allow chaining" do
+      [
+        :package, :renders, :format, :records, :produces, :valid_formats
+      ].each {|method_name|
+        subject.send(method_name, "hello").should == subject
+      }
+    end
   end
-end
 
-describe "accepts_value_for input processing" do
-  describe "lambda input" do
-    it "should return the correct call's args" do
-      test_value_lambdas.each_pair {|input, expected|
-        value = AcceptsForTest.new(input)
-        value.package &input
-        value.package.should == expected
+  describe "accepts_value_for" do
+    it "should return nil for no input" do
+      subject.package.should == nil
+    end
+    it "should return the correct default when no value is stored" do
+      subject.renders.should == "a default response"
+      subject.format.should == "json"
+    end
+    it "should return the value when called without args" do
+      [:package, :renders, :format].each {|method_name|
+        subject.send(method_name, "hello").send(method_name).should == "hello"
       }
     end
-    it "should ignore default whenever any lambda is specified" do
-      test_value_lambdas.each_pair {|input, expected|
-        value = AcceptsForTest.new(input)
-        value.renders &input
-        value.renders.should == expected
+    it "should return the result of callable items" do
+      [:package, :renders, :format].each {|method_name|
+        subject.send(method_name, L{ "world" }).send(method_name).should == "world"
       }
     end
+    it "should replace existing values with new ones" do
+      subject.package "ruby-1.8"
+      subject.package "ruby-1.9"
+      subject.package.should == "ruby-1.9"
+    end
   end
-end
 
-
-describe "accepts_list_for" do
-  before {
-    @list = AcceptsForTest.new
-  }
-  it "should return the empty list for no input" do
-    @list.records.should == []
-  end
-  it "should return the empty list for nil input" do
-    @list.records nil
-    @list.records.should == []
-  end
-  it "should return the correct default when no value is stored" do
-    @list.produces.should == ["a default response"]
-    @list.valid_formats.should == %w[html xml js json]
-  end
-  it "should accept splatted args" do
-    @list.records "an item", "another item"
-    @list.records.should == ["an item", "another item"]
-  end
-  it "should accept an array of args" do
-    @list.records ["an item", "another item"]
-    @list.records.should == ["an item", "another item"]
-  end
-  it "should return the value when called without args" do
-    [:records, :produces, :valid_formats].each {|method_name|
-      @list.send(method_name, "hello").send(method_name).should == ["hello"]
-    }
-  end
-  it "should return the result of callable items" do
-    [:records, :produces, :valid_formats].each {|method_name|
-      @list.send(method_name, "hello", L{ "world" }).send(method_name).should == ["hello", "world"]
-    }
-  end
-  it "should append new values to existing ones" do
-    @list.records "scores", "quips"
-    @list.records "tall tales"
-    @list.records.should == ["scores", "quips", "tall tales"]
+  describe "accepts_value_for input processing" do
+    describe "lambda input" do
+      it "should return the correct call's args" do
+        test_value_lambdas.each_pair {|input, expected|
+          value = AcceptsForTest.new(input)
+          value.package &input
+          value.package.should == expected
+        }
+      end
+      it "should ignore default whenever any lambda is specified" do
+        test_value_lambdas.each_pair {|input, expected|
+          value = AcceptsForTest.new(input)
+          value.renders &input
+          value.renders.should == expected
+        }
+      end
+    end
   end
-end
 
 
-describe "accepts_list_for input processing" do
-  describe "value input" do
-    test_lists.each_pair {|input, expected|
-      it "should return #{expected.inspect} when passed #{input.inspect}" do
-        list = AcceptsForTest.new
-        list.records input
-        list.records.should == expected
-      end
-    }
+  describe "accepts_list_for" do
+    it "should return the empty list for no input" do
+      subject.records.should == []
+    end
+    it "should return the empty list for nil input" do
+      subject.records nil
+      subject.records.should == []
+    end
+    it "should return the correct default when no value is stored" do
+      subject.produces.should == ["a default response"]
+      subject.valid_formats.should == %w[html xml js json]
+    end
+    it "should accept splatted args" do
+      subject.records "an item", "another item"
+      subject.records.should == ["an item", "another item"]
+    end
+    it "should accept an array of args" do
+      subject.records ["an item", "another item"]
+      subject.records.should == ["an item", "another item"]
+    end
+    it "should return the value when called without args" do
+      [:records, :produces, :valid_formats].each {|method_name|
+        subject.send(method_name, "hello").send(method_name).should == ["hello"]
+      }
+    end
+    it "should return the result of callable items" do
+      [:records, :produces, :valid_formats].each {|method_name|
+        subject.send(method_name, "hello", L{ "world" }).send(method_name).should == ["hello", "world"]
+      }
+    end
+    it "should append new values to existing ones" do
+      subject.records "scores", "quips"
+      subject.records "tall tales"
+      subject.records.should == ["scores", "quips", "tall tales"]
+    end
   end
 
-  describe "lambda input" do
-    it "should return the correct call's args" do
-      test_list_lambdas.each_pair {|input, expected|
-        list = AcceptsForTest.new(input)
-        list.records &input
-        list.records.should == expected
+
+  describe "accepts_list_for input processing" do
+    describe "value input" do
+      test_lists.each_pair {|input, expected|
+        it "should return #{expected.inspect} when passed #{input.inspect}" do
+          list = AcceptsForTest.new
+          list.records input
+          list.records.should == expected
+        end
       }
     end
-    it "should ignore default whenever any lambda is specified" do
-      test_list_lambdas.each_pair {|input, expected|
-        list = AcceptsForTest.new(input)
-        list.produces &input
-        list.produces.should == expected
+
+    describe "lambda input" do
+      it "should return the correct call's args" do
+        test_list_lambdas.each_pair {|input, expected|
+          list = AcceptsForTest.new(input)
+          list.records &input
+          list.records.should == expected
+        }
+      end
+      it "should ignore default whenever any lambda is specified" do
+        test_list_lambdas.each_pair {|input, expected|
+          list = AcceptsForTest.new(input)
+          list.produces &input
+          list.produces.should == expected
+        }
+      end
+    end
+
+    describe "lambda and value input" do
+      test_lists.each_pair {|input, expected|
+        it "should return #{expected.inspect} when passed #{input.inspect} within a lambda" do
+          l = L{
+            via :brew, input
+          }
+          list = AcceptsForTest.new
+          list.records &l
+          list.records.should == expected
+        end
       }
     end
-  end
 
-  describe "lambda and value input" do
-    test_lists.each_pair {|input, expected|
-      it "should return #{expected.inspect} when passed #{input.inspect} within a lambda" do
+    describe "nested lambdas" do
+      it "should choose recursively" do
         l = L{
-          via :macports, input
+          via :brew do
+            via :brew, "haha, excellent"
+            via :apt, ":|"
+          end
+          via :apt do
+            via :brew, "no, not this one"
+            via :apt, "OK this one is just completely wrong"
+          end
         }
         list = AcceptsForTest.new
         list.records &l
-        list.records.should == expected
+        list.records.should == ["haha, excellent"]
       end
-    }
-  end
-
-  describe "nested lambdas" do
-    it "should choose recursively" do
-      l = L{
-        via :macports do
-          via :macports, "haha, excellent"
-          via :apt, ":|"
-        end
-        via :apt do
-          via :macports, "no, not this one"
-          via :apt, "OK this one is just completely wrong"
-        end
-      }
-      list = AcceptsForTest.new
-      list.records &l
-      list.records.should == ["haha, excellent"]
     end
   end
 end