ztk 1.0.11 → 1.1.0

data/.gitignore

@@ -2,7 +2,6 @@
 *.txt
 *.gem
 *.rbc
-.rvmrc
 .bundle
 .config
 .yardoc

data/.ruby-gemset

@@ -0,0 +1 @@
+ztk

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'coveralls', :require => false
+
 gemspec

data/README.md

@@ -1,6 +1,7 @@
 [![Gem Version](https://badge.fury.io/rb/ztk.png)](http://badge.fury.io/rb/ztk)
 [![Dependency Status](https://gemnasium.com/zpatten/ztk.png)](https://gemnasium.com/zpatten/ztk)
 [![Build Status](https://secure.travis-ci.org/zpatten/ztk.png)](http://travis-ci.org/zpatten/ztk)
+[![Coverage Status](https://coveralls.io/repos/zpatten/testlab/badge.png?branch=master)](https://coveralls.io/r/zpatten/testlab)
 [![Code Climate](https://codeclimate.com/github/zpatten/ztk.png)](https://codeclimate.com/github/zpatten/ztk)
 
 # ZTK

data/Rakefile

@@ -29,16 +29,9 @@ task :test => :spec
 
 ################################################################################
 
-desc "Run RSpec with code coverage"
-task :coverage do
-  `rake spec COVERAGE=true`
-  case RUBY_PLATFORM
-  when /darwin/
-    `open coverage/index.html`
-  when /linux/
-    `google-chrome coverage/index.html`
-  end
-end
+require 'coveralls/rake/task'
+Coveralls::RakeTask.new
+task :coveralls => [:spec, 'coveralls:push']
 
 ################################################################################
 

data/lib/ztk.rb

@@ -41,6 +41,7 @@ module ZTK
   autoload :Benchmark, "ztk/benchmark"
   autoload :Command, "ztk/command"
   autoload :Config, "ztk/config"
+  autoload :Locator, "ztk/locator"
   autoload :Logger, "ztk/logger"
   autoload :Parallel, "ztk/parallel"
   autoload :PTY, "ztk/pty"

data/lib/ztk/dsl/core.rb

@@ -35,8 +35,8 @@ module ZTK::DSL
       base.class_eval do
         base.send(:extend, ZTK::DSL::Core::ClassMethods)
 
-        base.send(:extend, ZTK::DSL::Core::DualMethods)
-        base.send(:include, ZTK::DSL::Core::DualMethods)
+        # base.send(:extend, ZTK::DSL::Core::DualMethods)
+        # base.send(:include, ZTK::DSL::Core::DualMethods)
 
         base.send(:include, ZTK::DSL::Core::Attributes)
         base.send(:include, ZTK::DSL::Core::Actions)
@@ -47,19 +47,19 @@ module ZTK::DSL
     end
 
     # @author Zachary Patten <zachary@jovelabs.net>
-    module DualMethods
+    # module DualMethods
 
-      def logger
-        unless defined?($logger)
-          $logger = ::ZTK::Logger.new("dsl.log")
-          $logger.info {"=" * 80}
-          $logger.info {"=" * 80}
-          $logger.info {"=" * 80}
-        end
-        $logger
-      end
+    #   def logger
+    #     unless defined?($logger)
+    #       $logger = ::ZTK::Logger.new("dsl.log")
+    #       $logger.info {"=" * 80}
+    #       $logger.info {"=" * 80}
+    #       $logger.info {"=" * 80}
+    #     end
+    #     $logger
+    #   end
 
-    end
+    # end
 
     # @author Zachary Patten <zachary@jovelabs.net>
     module ClassMethods

data/lib/ztk/dsl/core/actions/find.rb

@@ -38,7 +38,6 @@ module ZTK::DSL::Core::Actions
       end
 
       def find(*args)
-        logger.debug { "*args(#{args.inspect})" }
         ids = [args].flatten
         all.select{ |data| ids.include?(data.id) }
       end

data/lib/ztk/dsl/core/relations/belongs_to.rb

@@ -36,15 +36,9 @@ module ZTK::DSL::Core::Relations
     end
 
     def get_belongs_to_reference(key)
-      logger.debug { "key(#{key})" }
-
       if belongs_to_references.key?(key)
-        logger.debug { "found key -> (#{key})" }
-
         belongs_to_references[key]
       else
-        logger.debug { "looking up key -> (#{key})" }
-
         key_id = send("#{key}_id")
         item = key.to_s.classify.constantize.find(key_id).first
         belongs_to_references[key] = item
@@ -52,13 +46,11 @@ module ZTK::DSL::Core::Relations
     end
 
     def set_belongs_to_reference(key, value)
-      logger.debug { "key(#{key}), value(#{value})" }
-
       belongs_to_references[key] = value
       attributes.merge!("#{key}_id".to_sym => value.id)
 
       klass = self.class.to_s.demodulize.downcase.pluralize
-      logger.debug { "send(#{klass})" }
+
       many = value.send(klass)
       many << self
       many.uniq!
@@ -80,11 +72,8 @@ module ZTK::DSL::Core::Relations
           :class_name => key.to_s.classify,
           :key => key
         }.merge(options)
-        logger.debug { "key(#{key.inspect}), options(#{belongs_to_relations[key].inspect})" }
 
         define_method(key) do |*args|
-          logger.debug { "*args(#{args.inspect})" }
-
           if args.count == 0
             get_belongs_to_reference(key)
           else
@@ -93,14 +82,10 @@ module ZTK::DSL::Core::Relations
         end
 
         define_method("#{key}=") do |value|
-          logger.debug { "#{key}= value(#{value.inspect})" }
-
           set_belongs_to_reference(key, value)
         end
 
         define_method("#{key}_id") do |*args|
-          logger.debug { "#{key}_id *args(#{args.inspect})" }
-
           if args.count == 0
             attributes["#{key}_id".to_sym]
           else
@@ -111,8 +96,6 @@ module ZTK::DSL::Core::Relations
 
         define_method("#{key}_id=") do |value|
           options = self.class.belongs_to_relations[key]
-          logger.debug { "#{key}_id= value(#{value.inspect}), options(#{options.inspect})" }
-
           if value != attributes["#{key}_id".to_sym]
             item = options[:class_name].constantize.find(value).first
             set_belongs_to_reference(key, item)

data/lib/ztk/dsl/core/relations/has_many.rb

@@ -36,22 +36,14 @@ module ZTK::DSL::Core::Relations
     end
 
     def get_has_many_reference(key)
-      logger.debug { "key(#{key})" }
-
       if has_many_references.key?(key)
-        logger.debug { "found key -> (#{key})" }
-
         has_many_references[key]
       else
-        logger.debug { "looking up key -> (#{key})" }
-
         has_many_references[key] ||= []
       end
     end
 
     def set_has_many_reference(key, value)
-      logger.debug { "key(#{key}), value(#{value})" }
-
       dataset = get_has_many_reference(key)
       dataset.clear
       dataset.concat(value)
@@ -73,11 +65,8 @@ module ZTK::DSL::Core::Relations
           :class_name => key.to_s.classify,
           :key => key
         }.merge(options)
-        logger.debug { "key(#{key.inspect}), options(#{has_many_relations[key].inspect})" }
 
         define_method(key) do |*args|
-          logger.debug { "#{key} *args(#{args.inspect})" }
-
           if args.count == 0
             get_has_many_reference(key)
           else
@@ -86,18 +75,16 @@ module ZTK::DSL::Core::Relations
         end
 
         define_method("#{key}=") do |value|
-          logger.debug { "#{key}= value(#{value.inspect})" }
-
           set_has_many_reference(key, value)
         end
 
         define_method(key.to_s.singularize) do |id=nil, &block|
           options = self.class.has_many_relations[key]
-          logger.debug { "#{key.to_s.singularize} block(#{block.inspect}), options(#{options.inspect})" }
           data = options[:class_name].constantize.new(id, &block)
           get_has_many_reference(key) << data
+
           klass = self.class.to_s.demodulize.singularize.downcase
-          logger.debug { "send(#{klass})" }
+
           data.send("#{klass}=", self)
           data
         end

data/lib/ztk/locator.rb

@@ -0,0 +1,57 @@
+################################################################################
+#
+#      Author: Zachary Patten <zachary@jovelabs.net>
+#   Copyright: Copyright (c) Zachary Patten
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+module ZTK
+
+  # ZTK::Locator Error Class
+  #
+  # @author Zachary Patten <zachary@jovelabs.net>
+  class LocatorError < Error; end
+
+  # @author Zachary Patten <zachary@jovelabs.net>
+  class Locator
+
+    class << self
+
+      # Locate a file or directory
+      #
+      # Attempts to locate the file or directory supplied, starting with
+      # the current working directory and crawling it up looking for a match
+      # at each step of the way.
+      #
+      # @param [String,Array<String>] args A string or array of strings to
+      #   attempt to locate.
+      #
+      # @return [String] The expanded path to the located entry.
+      def find(*args)
+        pwd = Dir.pwd.split(File::SEPARATOR)
+
+        (pwd.length - 1).downto(0) do |i|
+          candidate = File.expand_path(File.join(pwd[0..i], args))
+          return candidate if File.exists?(candidate)
+        end
+
+        raise LocatorError, "Could not locate '#{File.join(args)}'!"
+      end
+
+    end
+
+  end
+
+end

data/lib/ztk/version.rb

@@ -21,6 +21,6 @@
 module ZTK
 
   # ZTK Version String
-  VERSION = "1.0.11"
+  VERSION = "1.1.0"
 
 end

data/spec/spec_helper.rb

@@ -17,42 +17,15 @@
 #   limitations under the License.
 #
 ################################################################################
+require 'coveralls'
+Coveralls.wear!
+################################################################################
 require 'tempfile'
-
-require 'simplecov'
-SimpleCov.start do
-  add_filter '/spec/'
-end if ENV["COVERAGE"]
-
 require 'ztk'
 
 ENV['LOG_LEVEL'] = "DEBUG"
 
-WAIT_SMALL = 3
+WAIT_SMALL = 5
 READ_PARTIAL_CHUNK = 2048
 
-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
-
-
 ################################################################################

data/spec/ztk/benchmark_spec.rb

@@ -22,6 +22,14 @@ require "spec_helper"
 
 describe ZTK::Benchmark do
 
+  before(:each) do
+    @ui = ZTK::UI.new(
+      :stdout => StringIO.new,
+      :stderr => StringIO.new,
+      :stdin => StringIO.new
+    )
+  end
+
   subject { ZTK::Benchmark }
 
   describe "class" do
@@ -49,28 +57,28 @@ describe ZTK::Benchmark do
 
     it "should throw an exception if executed with a message but without a mark" do
       lambda {
-        ZTK::Benchmark.bench(:ui => $ui, :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
       lambda {
-        ZTK::Benchmark.bench(:ui => $ui, :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
-      ZTK::Benchmark.bench(:ui => $ui) do
+      ZTK::Benchmark.bench(:ui => @ui) do
         sleep(0.1)
       end
-      $ui.stdout.size.should == 0
+      @ui.stdout.size.should == 0
     end
 
     it "should write to STDOUT if given a message and mark" do
-      ZTK::Benchmark.bench(:ui => $ui, :message => "Hello World", :mark => "%0.4f") do
+      ZTK::Benchmark.bench(:ui => @ui, :message => "Hello World", :mark => "%0.4f") do
         sleep(0.1)
       end
-      $ui.stdout.size.should > 0
+      @ui.stdout.size.should > 0
     end
 
   end

data/spec/ztk/command_spec.rb

@@ -22,7 +22,15 @@ require "spec_helper"
 
 describe ZTK::Command do
 
-  subject { ZTK::Command.new }
+  before(:each) do
+    @ui = ZTK::UI.new(
+      :stdout => StringIO.new,
+      :stderr => StringIO.new,
+      :stdin => StringIO.new
+    )
+  end
+
+  subject { ZTK::Command.new(:ui => @ui) }
 
   describe "class" do
 
@@ -38,18 +46,18 @@ describe ZTK::Command do
 
       it "should be able to execute the command \"hostname\"" do
         subject.config do |config|
-          config.ui = $ui
+          config.ui = @ui
         end
         hostname = %x(hostname).chomp
         status = subject.exec("hostname")
         status.exit_code.should == 0
-        $ui.stdout.rewind
-        $ui.stdout.read.chomp.should == hostname
+        @ui.stdout.rewind
+        @ui.stdout.read.chomp.should == hostname
       end
 
       it "should timeout after the period specified" do
         subject.config do |config|
-          config.ui = $ui
+          config.ui = @ui
           config.timeout = WAIT_SMALL
         end
         hostname = %x(hostname).chomp
@@ -58,14 +66,14 @@ describe ZTK::Command do
 
       it "should throw an exception if the exit status is not as expected" do
         subject.config do |config|
-          config.ui = $ui
+          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
         subject.config do |config|
-          config.ui = $ui
+          config.ui = @ui
         end
         result = subject.exec(%q{echo "Hello World"})
         result.should be_an_instance_of OpenStruct
@@ -73,7 +81,7 @@ describe ZTK::Command do
 
       it "should return the exit code" do
         subject.config do |config|
-          config.ui = $ui
+          config.ui = @ui
         end
         data = 64
 
@@ -83,7 +91,7 @@ describe ZTK::Command do
 
       it "should return the output" do
         subject.config do |config|
-          config.ui = $ui
+          config.ui = @ui
         end
         data = "Hello World @ #{Time.now.utc}"
 
@@ -93,7 +101,7 @@ describe ZTK::Command do
 
       it "should allow us to change the expected exit code" do
         subject.config do |config|
-          config.ui = $ui
+          config.ui = @ui
         end
         data = 32
         result = subject.exec(%Q{/bin/bash -c 'exit #{data}'}, :exit_code => data)
@@ -103,20 +111,20 @@ describe ZTK::Command do
 
         it "should capture STDOUT and send it to the appropriate pipe" do
           subject.config do |config|
-            config.ui = $ui
+            config.ui = @ui
           end
           data = "Hello World @ #{Time.now.utc}"
 
           subject.exec(%Q{echo "#{data}" >&1})
 
-          $ui.stdout.rewind
-          $ui.stdout.read.match(data).should_not be nil
+          @ui.stdout.rewind
+          @ui.stdout.read.match(data).should_not be nil
 
-          $ui.stderr.rewind
-          $ui.stderr.read.match(data).should be nil
+          @ui.stderr.rewind
+          @ui.stderr.read.match(data).should be nil
 
-          $ui.stdin.rewind
-          $ui.stdin.read.match(data).should be nil
+          @ui.stdin.rewind
+          @ui.stdin.read.match(data).should be nil
         end
 
       end
@@ -125,20 +133,20 @@ describe ZTK::Command do
 
         it "should capture STDERR and send it to the appropriate pipe" do
           subject.config do |config|
-            config.ui = $ui
+            config.ui = @ui
           end
           data = "Hello World @ #{Time.now.utc}"
 
           subject.exec(%Q{echo "#{data}" >&2})
 
-          $ui.stdout.rewind
-          $ui.stdout.read.match(data).should be nil
+          @ui.stdout.rewind
+          @ui.stdout.read.match(data).should be nil
 
-          $ui.stderr.rewind
-          $ui.stderr.read.match(data).should_not be nil
+          @ui.stderr.rewind
+          @ui.stderr.read.match(data).should_not be nil
 
-          $ui.stdin.rewind
-          $ui.stdin.read.match(data).should be nil
+          @ui.stdin.rewind
+          @ui.stdin.read.match(data).should be nil
         end
       end