wizard 0.0.1

data/lib/wizard/spells/update_file.rb

@@ -0,0 +1,95 @@
+require 'wizard/spells/make_file'
+
+module Wizard
+  class Formula
+    
+    colorizers.merge!(
+      :missing => :red
+    )
+    
+    def update_file(filename, content=nil, options={})
+      spell = Spells::UpdateFile.new(filename, content, options)
+      spell.perform
+      render(spell)
+    end
+    alias_method :update, :update_file
+  
+    def append_to_file(filename, content, options={})
+      update_file(filename, content, options.merge(:before => :EOF))
+    end
+    alias_method :append, :append_to_file
+    alias_method :append_to, :append_to_file
+    
+    def prepend_to_file(filename, content, options={})
+      update_file(filename, content, options.merge(:after => :BOF))
+    end
+    alias_method :prepend, :prepend_to_file
+    alias_method :prepend_to, :prepend_to_file
+    
+    def replace_in_file(filename, content, replace, options={})
+      update_file(filename, content, options.merge(:replace => replace))
+    end
+    alias_method :replace, :replace_in_file
+    alias_method :replace_content, :replace_in_file
+  
+  end # Formula
+
+  module Spells
+    class UpdateFile < MakeFile
+    
+      attr_reader :filename, :chmod, :content, :before, :after, :replace
+      attr_status :missing
+    
+      def initialize(filename, content=nil, options={})
+        super(filename, nil, options)
+
+        @content = content
+        @before  = options[:before]
+        @after   = options[:after]
+        @replace = options[:replace]
+      end
+    
+      def perform_with_content_update
+        if File.exist?(filename)
+          force! and rebuild_content and perform_without_content_update
+        elsif content && !before && !after && !replace
+          perform_without_content_update
+        else
+          missing!
+        end
+      rescue Object
+        error!
+      end
+      
+      alias_method :perform_without_content_update, :perform
+      alias_method :perform, :perform_with_content_update
+      
+      # Build new content based on original one, including specified update
+      # directives. All directives can't be mixed, which mean that only 
+      # one update can ba applied on the file at one time. If none directive 
+      # is specified, then whole file content will be replaced with specified 
+      # in constructor.
+      def rebuild_content
+        if (before || after) && !replace
+          content = File.read(filename)
+          
+          return @content = [@content, content].join("\n") if after == :BOF
+          return @content = [content, @content].join("\n") if before == :EOF
+          
+          content = content.sub(/\r\n/, "\n").sub(/\r/, "\n").split(/\n/)
+          content.each_with_index do |line, id|
+            content[id] = [@content, line].join("\n") if !after && before && line =~ before
+            content[id] = [line, @content].join("\n") if !before && after && line =~ after
+          end
+          
+          @content = content.join("\n")
+        elsif replace
+          @content = File.read(filename).sub(replace, @content)
+        else
+          @content
+        end
+      end
+      
+    end # UpdateFile
+  end # Spells
+end # Wizard

data/spec/helpers_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Wizard::Helpers do
+  subject do
+    Wizard
+  end
+  
+  context "#say!" do
+    Wizard::Helpers::COLORS.each do |color, code|
+      [false, true].each do |bold|
+        it "should properly display #{bold ? "bold and" : ""}#{color.to_s} text on screen" do 
+          capture { Wizard.say!(color.to_s, color, bold) }
+          last_stdout.should == "\e[#{bold ? 1 : 0};#{code}m#{color.to_s}\n\e[0m"
+        end
+      end
+    end
+  end
+  
+  describe "#print" do
+    it "should properly print given text to stdout" do
+      capture { subject.print "This is SPARTA!" }
+      last_stdout.should == "This is SPARTA!"
+    end
+  end
+  
+  describe "#colorize" do
+    it "should colorize given text" do 
+      subject.colorize("foo", :red).should == "\e[0;31mfoo\e[0m"
+      subject.colorize("bar", :red, true).should == "\e[1;31mbar\e[0m"
+    end
+  end
+  
+  describe "#console_width" do
+    it "should return actual console width" do
+      # tested manualy...
+      subject.console_width
+    end
+  end
+  
+  describe "#adjust" do
+    context "when size given" do
+      it "should adjust text to given size" do
+        subject.adjust("foo", 8).should == "foo \e[0;30m....\e[0m"
+        subject.adjust("foo", 8, '-').should == "foo \e[0;30m----\e[0m"
+      end
+    end
+    
+    context "when no size given" do
+      it "should adjust text to console size" do
+        subject.expects(:console_width).returns(10)
+        subject.adjust("foo").should == "foo \e[0;30m......\e[0m"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,71 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'stringio'
+require 'ostruct'
+require 'rspec'
+require 'mocha'
+require 'wizard'
+
+module Helpers
+  # Capture and silence output streams (stdout, stderr), and return it values.
+  #
+  #   capture { puts "This is sparta!" }
+  #   last_stdout # => "This is sparta!"
+  #   last_stderr # => ""   
+  def capture
+    @last_stdout = StringIO.new
+    @last_stderr = StringIO.new
+    begin
+      $stdout = @last_stdout
+      $stderr = @last_stderr
+      yield
+    ensure
+      $stdout = STDERR
+      $stderr = STDOUT
+    end
+    [@last_stdout.string, @last_stderr.string]
+  end
+  
+  # Replace standard input with faked one StringIO. 
+  def fake_stdin(text)
+    begin
+      $stdin = StringIO.new
+      $stdin.puts(text)
+      $stdin.rewind
+      yield
+    ensure
+      $stdin = STDIN
+    end
+  end 
+
+  # Returns last string written to captured output stream.
+  def last_stdout
+    @last_stdout.string if @last_stdout
+  end
+  
+  # Returns last string written to captured error stream.
+  def last_stderr
+    @last_stdout.string if @last_stdout
+  end
+
+  # Executes code within given temp directory context. 
+  def within_tmp(&block) 
+    FileUtils.mkdir(dirname = File.join(File.dirname(__FILE__), 'tmp'))
+    yield(File.expand_path(dirname))
+  ensure
+    FileUtils.rm_rf(dirname)
+  end
+  
+  # Returns mock generator. 
+  def mock_gen(opts={})
+    Ryori::Generator.new(File.dirname(__FILE__)+"/tmp", opts)
+  end
+end
+
+RSpec.configure do |config| 
+  config.mock_with :mocha
+  config.include Helpers
+end
+

data/spec/spells/compile_template_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Wizard::Spells::CompileTemplate do
+  subject do
+    Wizard::Spells::CompileTemplate
+  end
+  
+  describe "#initialize" do
+    it "should set given filename" do
+      subject.new("/path/to/file", "/path/to/tpl").filename.should == "/path/to/file"
+    end
+    
+    context "given template name" do
+      it "should be set" do
+        subject.new("/path/to/file", "/path/to/tpl").template.should == "/path/to/tpl"
+      end
+    end
+    
+    it "should set default chmod" do
+      subject.new("/path/to/file", "/path/to/tpl").chmod.should == 644
+    end
+    
+    context "given :mode option" do
+      it "should set it" do
+        subject.new("/path/to/file", "/path/to/tpl", :mode => 755).chmod.should == 755
+      end
+    end
+    
+    context "given :force option" do
+      it "should run in force mode" do
+        subject.new("/path/to/file", "/path/to/tpl", :force => true).should be_forced
+      end
+    end
+  end
+  
+  context "#perform" do
+    subject do
+      Wizard::Spells::CompileTemplate.new("/path/to/file", "/path/to/tpl")
+    end
+    
+    context "when specified template causes errors" do
+      it "should set :error state" do
+        File.expects(:read).with("/path/to/tpl").raises(Exception)
+        spell = subject
+        spell.perform.should == :error
+        spell.should be_error
+      end
+    end
+    
+    context "when specified template is ok" do
+      it "should compile it and invoke make_file" do
+        File.expects(:read).with("/path/to/tpl").returns("<%='test'%>")
+        spell = subject
+        spell.expects(:perform_without_template_compilation).returns(:created)
+        spell.perform.should == :created
+        spell.content.should == 'test'
+      end
+    end
+  end
+end

data/spec/spells/execute_shell_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Wizard::Spells::ExecuteShell do
+  subject do
+    Wizard::Spells::ExecuteShell
+  end
+  
+  describe "#initialize" do
+    it "should set given command" do
+      subject.new("echo 'test'").command.should == "echo 'test'"
+    end
+  end
+  
+  describe "#perform" do
+    context "when given command is valid" do
+      subject do
+        Wizard::Spells::ExecuteShell.new("echo 'test'")
+      end
+      
+      it "should execute command and set :executed status" do
+        spell = subject
+        spell.perform == :executed
+        spell.should be_executed
+      end
+      
+      it "should set it output to instance variable" do
+        spell = subject
+        spell.perform
+        spell.output.should == "test\n"
+      end
+    end
+    
+    context "when given command causes errors" do
+      subject do
+        Wizard::Spells::ExecuteShell.new("some-error")
+      end
+      
+      it "should execute command and set :executed status" do
+        spell = subject
+        spell.expects(:failed!).raises(Exception)
+        spell.perform == :error
+        spell.should be_error
+      end
+    end
+    
+    context "when given command can't be executed" do
+      subject do
+        Wizard::Spells::ExecuteShell.new("no-such-command")
+      end
+      
+      it "should execute command and set :executed status" do
+        spell = subject
+        spell.perform == :failed
+        spell.should be_failed
+      end
+    end 
+  end
+end

data/spec/spells/make_dir_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Wizard::Spells::MakeDir do
+  subject do
+    Wizard::Spells::MakeDir
+  end
+  
+  describe "#initialize" do
+    it "should set given dirname" do
+      subject.new("/path/to/dir").dirname.should == "/path/to/dir"
+    end
+    
+    it "should have empty chmod by default" do
+      subject.new("/path/to/dir").chmod.should == nil
+    end
+    
+    context "given :mode" do
+      it "should set it" do
+        subject.new("/path/to/dir", :mode => 755).chmod.should == 755
+      end
+    end
+  end
+  
+  describe "#perform" do
+    subject do
+      Wizard::Spells::MakeDir.new("/path/to/dir")
+    end
+    
+    context "when specified directory exists" do
+      it "should set :exist status" do
+        File.expects(:exist?).returns(true)
+        spell = subject
+        spell.perform.should == :exist
+        spell.should be_exist
+      end
+    end
+    
+    context "when specified directory doesn't exist" do
+      context "and user have access to create it" do
+        it "should set :created status" do
+          FileUtils.expects(:mkdir_p).with("/path/to/dir", :mode => 644).returns("/path/to/dir")
+          spell = subject
+          spell.perform.should == :created
+          spell.should be_created
+        end
+      end
+      
+      context "and user don't have access to create it" do
+        it "should set :noaccess status" do
+          FileUtils.expects(:mkdir_p).with("/path/to/dir", :mode => 644).raises(Errno::EACCES)
+          spell = subject
+          spell.perform.should == :noaccess
+          spell.should be_noaccess
+        end
+      end
+    end
+    
+    context "when unknown error raised while creating directory" do
+      it "shouldn't create it and set :noaccess status" do
+        FileUtils.expects(:mkdir_p).with("/path/to/dir", :mode => 644).raises(Exception)
+        spell = subject
+        spell.perform.should == :error
+        spell.should be_error
+      end
+    end
+    
+    context "when directory can't been created" do
+      it "shouldn't create it and set :error status" do
+        FileUtils.expects(:mkdir_p).with("/path/to/dir", :mode => 644).returns(false)
+        spell = subject
+        spell.perform.should == :error
+        spell.should be_error
+      end
+    end
+  end
+end
+

data/spec/spells/make_file_spec.rb

@@ -0,0 +1,125 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Wizard::Spells::MakeFile do
+  subject do
+    Wizard::Spells::MakeFile
+  end
+  
+  describe "#initialize" do
+    it "should set given filename" do
+      subject.new("/path/to/file").filename.should == "/path/to/file"
+    end
+    
+    context "given content" do
+      it "should be set" do
+        subject.new("/path/to/file", "hello world!").content.should == "hello world!"
+      end
+    end
+    
+    it "should have empty chmod by default" do
+      subject.new("/path/to/file").chmod.should == nil
+    end
+    
+    context "given :mode option" do
+      it "should set it" do
+        subject.new("/path/to/file", nil, :mode => 755).chmod.should == 755
+      end
+    end
+    
+    context "given :force option" do
+      it "should run in force mode" do
+        subject.new("/path/to/file", nil, :force => true).should be_forced
+      end
+    end
+  end
+  
+  describe "#perform" do
+    subject do
+      Wizard::Spells::MakeFile.new("/path/to/file")
+    end
+
+    context "when specified file exists" do
+      subject do
+        Wizard::Spells::MakeFile.new("/path/to/file", "testing")
+      end
+
+      context "and it content is identical as given one" do
+        it "should set :identical status" do
+          File.expects(:exist?).returns(true)
+          File.expects(:read).with("/path/to/file").returns("testing")
+          spell = subject
+          spell.perform.should == :identical
+          spell.should be_identical
+        end
+      end
+      
+      context "and it content is different than given one" do
+        subject do
+          Wizard::Spells::MakeFile.new("/path/to/file", "testing")
+        end
+        
+        it "should set :conflict status" do
+          File.expects(:exist?).returns(true)
+          File.expects(:read).with("/path/to/file").returns("not-testing")
+          spell = subject
+          spell.perform.should == :conflict
+          spell.should be_conflict
+        end
+        
+        context "and force mode is on" do
+          subject do
+            Wizard::Spells::MakeFile.new("/path/to/file", "testing", :force => true)
+          end
+      
+          it "should overwrite current file" do
+            File.expects(:exist?).returns(true)
+            File.expects(:read).with("/path/to/file").returns("not-testing")
+            spell = subject
+            spell.expects(:create_file!).returns(true)
+            spell.perform.should == :updated
+            spell.should be_updated
+          end
+        end
+      end
+    end
+    
+    context "when specified file doesn't exist" do
+      context "and user have access to create it" do
+        it "should set :created status" do
+          File.expects(:open).with("/path/to/file", "w+").returns(true)
+          FileUtils.expects(:chmod).with(644, "/path/to/file").returns(true)
+          spell = subject
+          spell.perform.should == :created
+          spell.should be_created
+        end
+      end
+      
+      context "and user don't have access to create it" do
+        it "should set :noaccess status" do
+          File.expects(:open).with("/path/to/file", "w+").raises(Errno::EACCES)
+          spell = subject
+          spell.perform.should == :noaccess
+          spell.should be_noaccess
+        end
+      end
+    end
+    
+    context "when unknown error raised while creating file" do
+      it "shouldn't create it and set :noaccess status" do
+        File.expects(:open).with("/path/to/file", "w+").raises(Exception)
+        spell = subject
+        spell.perform.should == :error
+        spell.should be_error
+      end
+    end
+    
+    context "when file can't be created or chmod not set" do
+      it "shouldn't create it and set :error status" do
+        File.expects(:open).with("/path/to/file", "w+").returns(false)
+        spell = subject
+        spell.perform.should == :error
+        spell.should be_error
+      end
+    end
+  end
+end