ztk 1.0.0.rc.0 → 1.0.0.rc.1

data/lib/ztk/spinner.rb

@@ -60,16 +60,16 @@ module ZTK
         options = Base.build_config({
           :step => 0.1
         }.merge(options))
-        options.logger.debug { "options(#{options.send(:table).inspect})" }
+        options.ui.logger.debug { "options(#{options.send(:table).inspect})" }
 
-        !block_given? and Base.log_and_raise(options.logger, SpinnerError, "You must supply a block!")
+        !block_given? and Base.log_and_raise(options.ui.logger, SpinnerError, "You must supply a block!")
 
         count = 0
         spinner = Thread.new do
           while count do
-            options.stdout.print(CHARSET[(count += 1) % CHARSET.length])
-            options.stdout.print("\b")
-            options.stdout.respond_to?(:flush) and options.stdout.flush
+            options.ui.stdout.print(CHARSET[(count += 1) % CHARSET.length])
+            options.ui.stdout.print("\b")
+            options.ui.stdout.respond_to?(:flush) and options.ui.stdout.flush
             sleep(options.step)
           end
         end

data/lib/ztk/ssh.rb

@@ -139,7 +139,7 @@ module ZTK
         :timeout => 60,
         :ignore_exit_status => false
       }.merge(configuration))
-      config.logger.debug { "config=#{config.send(:table).inspect}" }
+      config.ui.logger.debug { "config=#{config.send(:table).inspect}" }
     end
 
     # Starts an SSH session.  Can also be used to get the Net::SSH object.
@@ -158,7 +158,7 @@ module ZTK
 
     # Close our session gracefully.
     def close
-      config.logger.debug { "close" }
+      config.ui.logger.debug { "close" }
       ssh and !ssh.closed? and ssh.close
     end
 
@@ -174,8 +174,8 @@ module ZTK
     #   end
     #   ssh.console
     def console
-      config.logger.debug { "config=#{config.send(:table).inspect}" }
-      config.logger.info { "console(#{console_command.inspect})" }
+      config.ui.logger.debug { "config=#{config.send(:table).inspect}" }
+      config.ui.logger.info { "console(#{console_command.inspect})" }
 
       Kernel.exec(console_command)
     end
@@ -204,9 +204,9 @@ module ZTK
     def exec(command, options={})
       options = OpenStruct.new({ :exit_code => 0, :silence => false }.merge(options))
 
-      config.logger.debug { "config=#{config.send(:table).inspect}" }
-      config.logger.debug { "options=#{options.send(:table).inspect}" }
-      config.logger.info { "exec(#{command.inspect})" }
+      config.ui.logger.debug { "config=#{config.send(:table).inspect}" }
+      config.ui.logger.debug { "options=#{options.send(:table).inspect}" }
+      config.ui.logger.info { "exec(#{command.inspect})" }
 
       output = ""
       exit_code = -1
@@ -220,7 +220,7 @@ module ZTK
             @ssh = Net::SSH.start(config.host_name, config.user, ssh_options)
 
             channel = ssh.open_channel do |chan|
-              config.logger.debug { "Channel opened." }
+              config.ui.logger.debug { "Channel opened." }
 
               direct_log(:debug) { log_header("COMMAND") }
               direct_log(:debug) { "#{command}\n" }
@@ -237,7 +237,7 @@ module ZTK
                   end
                   direct_log(:debug) { data }
 
-                  config.stdout.print(data) unless options.silence
+                  config.ui.stdout.print(data) unless options.silence
                   output += data
                 end
 
@@ -249,7 +249,7 @@ module ZTK
                   end
                   direct_log(:warn) { data }
 
-                  config.stderr.print(data) unless options.silence
+                  config.ui.stderr.print(data) unless options.silence
                   output += data
                 end
 
@@ -262,7 +262,7 @@ module ZTK
                 end
 
                 ch.on_open_failed do |c, code, desc|
-                  config.logger.fatal { "Open failed! (#{code.inspect} - #{desc.inspect})" }
+                  config.ui.logger.fatal { "Open failed! (#{code.inspect} - #{desc.inspect})" }
                 end
 
               end
@@ -270,7 +270,7 @@ module ZTK
             channel.wait
 
             direct_log(:debug) { log_header("CLOSED") }
-            config.logger.debug { "Channel closed." }
+            config.ui.logger.debug { "Channel closed." }
           end
         end
 
@@ -284,7 +284,7 @@ module ZTK
         (exit_signal.nil? ? nil : "exit_signal=#{exit_signal} (#{EXIT_SIGNALS[exit_signal]})")
       ].compact.join(", ")
 
-      config.logger.debug { message }
+      config.ui.logger.debug { message }
 
       if !config.ignore_exit_status && (exit_code != options.exit_code)
         log_and_raise(SSHError, message)
@@ -308,23 +308,23 @@ module ZTK
     #   remote = File.expand_path(File.join("/tmp", "id_rsa.pub"))
     #   ssh.upload(local, remote)
     def upload(local, remote)
-      config.logger.debug { "config=#{config.send(:table).inspect}" }
-      config.logger.info { "upload(#{local.inspect}, #{remote.inspect})" }
+      config.ui.logger.debug { "config=#{config.send(:table).inspect}" }
+      config.ui.logger.info { "upload(#{local.inspect}, #{remote.inspect})" }
 
       ZTK::RescueRetry.try(:tries => 3, :on => EOFError) do
         @sftp = Net::SFTP.start(config.host_name, config.user, ssh_options)
         sftp.upload!(local.to_s, remote.to_s) do |event, uploader, *args|
           case event
           when :open
-            config.logger.debug { "upload(#{args[0].local} -> #{args[0].remote})" }
+            config.ui.logger.debug { "upload(#{args[0].local} -> #{args[0].remote})" }
           when :close
-            config.logger.debug { "close(#{args[0].remote})" }
+            config.ui.logger.debug { "close(#{args[0].remote})" }
           when :mkdir
-            config.logger.debug { "mkdir(#{args[0]})" }
+            config.ui.logger.debug { "mkdir(#{args[0]})" }
           when :put
-            config.logger.debug { "put(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
+            config.ui.logger.debug { "put(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
           when :finish
-            config.logger.debug { "finish" }
+            config.ui.logger.debug { "finish" }
           end
         end
       end
@@ -348,23 +348,23 @@ module ZTK
     #   remote = File.expand_path(File.join(ENV["HOME"], ".ssh", "id_rsa.pub"))
     #   ssh.download(remote, local)
     def download(remote, local)
-      config.logger.debug { "config=#{config.send(:table).inspect}" }
-      config.logger.info { "download(#{remote.inspect}, #{local.inspect})" }
+      config.ui.logger.debug { "config=#{config.send(:table).inspect}" }
+      config.ui.logger.info { "download(#{remote.inspect}, #{local.inspect})" }
 
       ZTK::RescueRetry.try(:tries => 3, :on => EOFError) do
         @sftp = Net::SFTP.start(config.host_name, config.user, ssh_options)
         sftp.download!(remote.to_s, local.to_s) do |event, downloader, *args|
           case event
           when :open
-            config.logger.debug { "download(#{args[0].remote} -> #{args[0].local})" }
+            config.ui.logger.debug { "download(#{args[0].remote} -> #{args[0].local})" }
           when :close
-            config.logger.debug { "close(#{args[0].local})" }
+            config.ui.logger.debug { "close(#{args[0].local})" }
           when :mkdir
-            config.logger.debug { "mkdir(#{args[0]})" }
+            config.ui.logger.debug { "mkdir(#{args[0]})" }
           when :get
-            config.logger.debug { "get(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
+            config.ui.logger.debug { "get(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
           when :finish
-            config.logger.debug { "finish" }
+            config.ui.logger.debug { "finish" }
           end
         end
       end
@@ -389,7 +389,7 @@ module ZTK
       command << [ "-o", "ProxyCommand=\"#{proxy_command}\"" ] if config.proxy_host_name
       command << "#{config.user}@#{config.host_name}"
       command = command.flatten.compact.join(" ")
-      config.logger.debug { "console_command(#{command.inspect})" }
+      config.ui.logger.debug { "console_command(#{command.inspect})" }
       command
     end
 
@@ -410,7 +410,7 @@ module ZTK
       command << "#{config.proxy_user}@#{config.proxy_host_name}"
       command << "nc %h %p"
       command = command.flatten.compact.join(" ")
-      config.logger.debug { "proxy_command(#{command.inspect})" }
+      config.ui.logger.debug { "proxy_command(#{command.inspect})" }
       command
     end
 
@@ -441,7 +441,7 @@ module ZTK
       # This is not plainly documented on the Net::SSH config class.
       options.merge!(:password => config.password) if config.password
 
-      config.logger.debug { "ssh_options(#{options.inspect})" }
+      config.ui.logger.debug { "ssh_options(#{options.inspect})" }
       options
     end
 

data/lib/ztk/tcp_socket_check.rb

@@ -94,7 +94,7 @@ module ZTK
         :timeout => 5,
         :wait => 60
       }.merge(configuration))
-      config.logger.debug { "config=#{config.send(:table).inspect}" }
+      config.ui.logger.debug { "config=#{config.send(:table).inspect}" }
     end
 
     # Check to see if socket on the host and port specified is ready.  This
@@ -110,15 +110,15 @@ module ZTK
       socket = TCPSocket.new(config.host, config.port)
 
       if config.data.nil?
-        config.logger.debug { "read(#{config.host}:#{config.port})" }
+        config.ui.logger.debug { "read(#{config.host}:#{config.port})" }
         ((IO.select([socket], nil, nil, config.timeout) && socket.gets) ? true : false)
       else
-        config.logger.debug { "write(#{config.host}:#{config.port}, #{config.data.size} bytes)" }
+        config.ui.logger.debug { "write(#{config.host}:#{config.port}, #{config.data.size} bytes)" }
         ((IO.select(nil, [socket], nil, config.timeout) && socket.write(config.data)) ? true : false)
       end
 
     rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH => e
-      config.logger.debug { "#{config.host}:#{config.port} - #{e.message}" }
+      config.ui.logger.debug { "#{config.host}:#{config.port} - #{e.message}" }
       false
     ensure
       (socket && socket.close)
@@ -131,16 +131,16 @@ module ZTK
     # @return [Boolean] Returns true or false depending on weither the socket
     #   became ready or not.
     def wait
-      config.logger.debug { "Waiting for socket to become available; timeout after #{config.wait} seconds." }
+      config.ui.logger.debug { "Waiting for socket to become available; timeout after #{config.wait} seconds." }
       Timeout.timeout(config.wait) do
         until ready?
-          config.logger.debug { "Sleeping 1 second." }
+          config.ui.logger.debug { "Sleeping 1 second." }
           sleep(1)
         end
       end
       true
     rescue Timeout::Error => e
-      config.logger.warn { "socket(#{config.host}:#{config.port}) timeout!" }
+      config.ui.logger.warn { "socket(#{config.host}:#{config.port}) timeout!" }
       false
     end
 

data/lib/ztk/ui.rb

@@ -22,24 +22,31 @@ require "base64"
 
 module ZTK
 
-  # ZTK::Ui Error Class
+  # ZTK::UI Error Class
   #
   # @author Zachary Patten <zachary@jovelabs.net>
   class UIError < Error; end
 
+  # ZTK UI Wrapper Class
+  #
   # @author Zachary Patten <zachary@jovelabs.net>
   class UI < ZTK::Base
 
     attr_accessor :stdout, :stderr, :stdin, :logger
 
     def initialize(configuration={})
-      super({
-        :stdout => $stdout,
-        :stderr => $stderr,
-        :stdin => $stdin,
-        :logger => $logger
-      }.merge(configuration))
-      config.logger.debug { "config=#{config.send(:table).inspect}" }
+      defined?(Rails) and (rails_logger = Rails.logger)
+      null_logger = (::ZTK::Logger.new("/dev/null") rescue ::Logger.new("/dev/null"))
+
+      @stdout = (configuration[:stdout] || $stdout || STDOUT)
+      @stderr = (configuration[:stderr] || $stderr || STDERR)
+      @stdin  = (configuration[:stdin]  || $stdin  || STDIN)
+      @logger = (configuration[:logger] || $logger || rails_logger || null_logger)
+
+      (@stdout && @stdout.respond_to?(:sync=)) and @stdout.sync = true
+      (@stderr && @stderr.respond_to?(:sync=)) and @stderr.sync = true
+      (@stdin  && @stdin.respond_to?(:sync=))  and @stdin.sync  = true
+      (@logger && @logger.respond_to?(:sync=)) and @logger.sync = true
     end
 
   end

data/lib/ztk/version.rb

@@ -21,6 +21,6 @@
 module ZTK
 
   # ZTK Version String
-  VERSION = "1.0.0.rc.0"
+  VERSION = "1.0.0.rc.1"
 
 end

data/spec/spec_helper.rb

@@ -32,10 +32,28 @@ ENV['LOG_LEVEL'] = "DEBUG"
 
 WAIT_SMALL = 3
 
-$logger = ZTK::Logger.new(File.join("/tmp", "test.log"))
+RSpec.configure do |config|
+
+  config.before(:all) do
+    $stdout = File.open("/dev/null", "w")
+    $stderr = File.open("/dev/null", "w")
+    $stdin = File.open("/dev/null", "r")
+    $logger = ZTK::Logger.new(File.join("/tmp", "test.log"))
+
+    $logger.info { "=" * 80 }
+    $logger.info { "STARTING ZTK v#{ZTK::VERSION} TEST RUN @ #{Time.now.utc}" }
+    $logger.info { "=" * 80 }
+  end
+
+  config.before(:each) do
+    $ui = ZTK::UI.new(
+      :stdout => StringIO.new,
+      :stderr => StringIO.new,
+      :stdin => StringIO.new
+    )
+  end
+
+end
 
-$logger.info { "=" * 80 }
-$logger.info { "STARTING ZTK v#{ZTK::VERSION} TEST RUN @ #{Time.now.utc}" }
-$logger.info { "=" * 80 }
 
 ################################################################################

data/spec/ztk/background_spec.rb

@@ -24,42 +24,12 @@ describe ZTK::Background do
 
   subject { ZTK::Background.new }
 
-  before(:all) do
-    $stdout = File.open("/dev/null", "w")
-    $stderr = File.open("/dev/null", "w")
-    $stdin = File.open("/dev/null", "r")
-  end
-
   describe "class" do
 
     it "should be an instance of ZTK::Background" do
       subject.should be_an_instance_of ZTK::Background
     end
 
-    describe "default config" do
-
-      it "should use $stdout as the default" do
-        subject.config.stdout.should be_a_kind_of $stdout.class
-        subject.config.stdout.should == $stdout
-      end
-
-      it "should use $stderr as the default" do
-        subject.config.stderr.should be_a_kind_of $stderr.class
-        subject.config.stderr.should == $stderr
-      end
-
-      it "should use $stdin as the default" do
-        subject.config.stdin.should be_a_kind_of $stdin.class
-        subject.config.stdin.should == $stdin
-      end
-
-      it "should use $logger as the default" do
-        subject.config.logger.should be_a_kind_of ZTK::Logger
-        subject.config.logger.should == $logger
-      end
-
-    end
-
   end
 
   describe "behaviour" do

data/spec/ztk/base_spec.rb

@@ -24,12 +24,6 @@ describe ZTK::Base do
 
   subject { ZTK::Base }
 
-  before(:all) do
-    $stdout = File.open("/dev/null", "w")
-    $stderr = File.open("/dev/null", "w")
-    $stdin = File.open("/dev/null", "r")
-  end
-
   describe "class" do
 
     it "should be ZTK::Base" do

data/spec/ztk/benchmark_spec.rb

@@ -24,12 +24,6 @@ describe ZTK::Benchmark do
 
   subject { ZTK::Benchmark }
 
-  before(:all) do
-    $stdout = File.open("/dev/null", "w")
-    $stderr = File.open("/dev/null", "w")
-    $stdin = File.open("/dev/null", "r")
-  end
-
   describe "class" do
 
     it "should be ZTK::Benchmark" do
@@ -54,33 +48,29 @@ describe ZTK::Benchmark do
     end
 
     it "should throw an exception if executed with a message but without a mark" do
-      stdout = StringIO.new
       lambda {
-        ZTK::Benchmark.bench(:stdout => stdout, :message => "Hello World")
+        ZTK::Benchmark.bench(:ui => $ui, :message => "Hello World")
       }.should raise_error ZTK::BenchmarkError
     end
 
     it "should throw an exception if executed without a message but with a mark" do
-      stdout = StringIO.new
       lambda {
-        ZTK::Benchmark.bench(:stdout => stdout, :mark => "%0.4f")
+        ZTK::Benchmark.bench(:ui => $ui, :mark => "%0.4f")
       }.should raise_error ZTK::BenchmarkError
     end
 
     it "should not write to STDOUT if not given a message or mark" do
-      stdout = StringIO.new
-      ZTK::Benchmark.bench(:stdout => stdout) do
+      ZTK::Benchmark.bench(:ui => $ui) do
         sleep(0.1)
       end
-      stdout.size.should == 0
+      $ui.stdout.size.should == 0
     end
 
     it "should write to STDOUT if given a message and mark" do
-      stdout = StringIO.new
-      ZTK::Benchmark.bench(:stdout => stdout, :message => "Hello World", :mark => "%0.4f") do
+      ZTK::Benchmark.bench(:ui => $ui, :message => "Hello World", :mark => "%0.4f") do
         sleep(0.1)
       end
-      stdout.size.should > 0
+      $ui.stdout.size.should > 0
     end
 
   end

data/spec/ztk/command_spec.rb

@@ -24,42 +24,12 @@ describe ZTK::Command do
 
   subject { ZTK::Command.new }
 
-  before(:all) do
-    $stdout = File.open("/dev/null", "w")
-    $stderr = File.open("/dev/null", "w")
-    $stdin = File.open("/dev/null", "r")
-  end
-
   describe "class" do
 
     it "should be an instance of ZTK::Command" do
       subject.should be_an_instance_of ZTK::Command
     end
 
-    describe "default config" do
-
-      it "should use $stdout as the default" do
-        subject.config.stdout.should be_a_kind_of $stdout.class
-        subject.config.stdout.should == $stdout
-      end
-
-      it "should use $stderr as the default" do
-        subject.config.stderr.should be_a_kind_of $stderr.class
-        subject.config.stderr.should == $stderr
-      end
-
-      it "should use $stdin as the default" do
-        subject.config.stdin.should be_a_kind_of $stdin.class
-        subject.config.stdin.should == $stdin
-      end
-
-      it "should use $logger as the default" do
-        subject.config.logger.should be_a_kind_of ZTK::Logger
-        subject.config.logger.should == $logger
-      end
-
-    end
-
   end
 
   describe "behaviour" do
@@ -67,21 +37,19 @@ describe ZTK::Command do
     describe "execute" do
 
       it "should be able to execute the command \"hostname -f\"" do
-        stdout = StringIO.new
         subject.config do |config|
-          config.stdout = stdout
+          config.ui = $ui
         end
         hostname = %x(hostname -f).chomp
         status = subject.exec("hostname -f")
         status.exit_code.should == 0
-        stdout.rewind
-        stdout.read.chomp.should == hostname
+        $ui.stdout.rewind
+        $ui.stdout.read.chomp.should == hostname
       end
 
       it "should timeout after the period specified" do
-        stdout = StringIO.new
         subject.config do |config|
-          config.stdout = stdout
+          config.ui = $ui
           config.timeout = WAIT_SMALL
         end
         hostname = %x(hostname -f).chomp
@@ -89,26 +57,23 @@ describe ZTK::Command do
       end
 
       it "should throw an exception if the exit status is not as expected" do
-        stdout = StringIO.new
         subject.config do |config|
-          config.stdout = stdout
+          config.ui = $ui
         end
         lambda { subject.exec("/bin/bash -c 'exit 64'") }.should raise_error ZTK::CommandError
       end
 
       it "should return a instance of an OpenStruct object" do
-        stdout = StringIO.new
         subject.config do |config|
-          config.stdout = stdout
+          config.ui = $ui
         end
         result = subject.exec(%q{echo "Hello World"})
         result.should be_an_instance_of OpenStruct
       end
 
       it "should return the exit code" do
-        stdout = StringIO.new
         subject.config do |config|
-          config.stdout = stdout
+          config.ui = $ui
         end
         data = 64
 
@@ -117,9 +82,8 @@ describe ZTK::Command do
       end
 
       it "should return the output" do
-        stdout = StringIO.new
         subject.config do |config|
-          config.stdout = stdout
+          config.ui = $ui
         end
         data = "Hello World @ #{Time.now.utc}"
 
@@ -128,9 +92,8 @@ describe ZTK::Command do
       end
 
       it "should allow us to change the expected exit code" do
-        stdout = StringIO.new
         subject.config do |config|
-          config.stdout = stdout
+          config.ui = $ui
         end
         data = 32
         result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
@@ -139,25 +102,21 @@ describe ZTK::Command do
       describe "stdout" do
 
         it "should capture STDOUT and send it to the appropriate pipe" do
-          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
-
           subject.config do |config|
-            config.stdout = stdout
-            config.stderr = stderr
-            config.stdin = stdin
+            config.ui = $ui
           end
           data = "Hello World @ #{Time.now.utc}"
 
           subject.exec(%Q{echo "#{data}" -f >&1})
 
-          stdout.rewind
-          stdout.read.match(data).should_not be nil
+          $ui.stdout.rewind
+          $ui.stdout.read.match(data).should_not be nil
 
-          stderr.rewind
-          stderr.read.match(data).should be nil
+          $ui.stderr.rewind
+          $ui.stderr.read.match(data).should be nil
 
-          stdin.rewind
-          stdin.read.match(data).should be nil
+          $ui.stdin.rewind
+          $ui.stdin.read.match(data).should be nil
         end
 
       end
@@ -165,25 +124,21 @@ describe ZTK::Command do
       describe "stderr" do
 
         it "should capture STDERR and send it to the appropriate pipe" do
-          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
-
           subject.config do |config|
-            config.stdout = stdout
-            config.stderr = stderr
-            config.stdin = stdin
+            config.ui = $ui
           end
           data = "Hello World @ #{Time.now.utc}"
 
           subject.exec(%Q{echo "#{data}" -f >&2})
 
-          stdout.rewind
-          stdout.read.match(data).should be nil
+          $ui.stdout.rewind
+          $ui.stdout.read.match(data).should be nil
 
-          stderr.rewind
-          stderr.read.match(data).should_not be nil
+          $ui.stderr.rewind
+          $ui.stderr.read.match(data).should_not be nil
 
-          stdin.rewind
-          stdin.read.match(data).should be nil
+          $ui.stdin.rewind
+          $ui.stdin.read.match(data).should be nil
         end
       end