duck_test 0.1.4

data/lib/duck_test/frame_work/queue.rb

@@ -0,0 +1,221 @@
+module DuckTest
+  module FrameWork
+
+    # Queue is responsible to managing and triggering events after being notified via a listener.
+    class Queue
+      include DuckTest::ConfigHelper
+      include LoggerHelper
+
+      # Boolean flag used to force the queue to empty and run any pending regardless of the current state of autorun.
+      attr_accessor :force_run
+
+      # Holds the time when a queue event was last triggered.  This value is a factor when calculating if the queue should be processed.
+      attr_accessor :last_queue_event
+
+      # Latency is the amount of time that should pass between each time the event queue is processed.  The default value is: 0.15, however,
+      # you can use any valid float number.  Use this value in conjuction with {#speed} to fine tune the overall behavior of the queue.
+      #
+      #   set_latency(10)    # wait 10 seconds since the last time the queue event was triggered.  Regardless of the setting of {#speed}.
+      #
+      attr_accessor :latency
+
+      # A {http://ruby-doc.org/core-1.9.3/Mutex.html Mutex} used when working on data items related specifically to the Queue.
+      attr_accessor :lock
+
+      # A boolean flag used to determine if it is ok to process and run the set of tests currently in the queue.
+      # Depending on settings and the number of tests being run, the queue loop may need to wait for the queue_event_block to complete it's previous run.
+      # This flag helps control that situation.
+      attr_accessor :ok_to_run
+
+      # An Array representing the list of files that have changed and need to be processed.
+      attr_accessor :queue
+
+      # The block to execute when after the queue has been processed and a list of runnable test files is ready to be run.
+      attr_accessor :queue_event_block
+
+      # A {http://ruby-doc.org/core-1.9.3/Mutex.html Mutex} used when working on data items related specifically executing the queue event.
+      attr_accessor :queue_event_lock
+
+      # A float number indicating how fast the queue should run.  The thread processing the queue will sleep for the value set by speed.
+      # The default value is 0.15, however, you can use any valid float number.  Use this value in conjuction with {#latency} to fine tune the overall behavior of the queue.
+      # The higher the number, the slower the speed since the thread containing the loop that checks the queue uses speed as the time to sleep between each interation of the loop.
+      #
+      #   set_speed(5)    # sleep 5 seconds between each interation of the loop.
+      #
+      attr_accessor :speed
+
+      # A boolean indicating if the queue should stop processing and have the thread end it's loop.
+      attr_accessor :stop
+
+      # A reference to the thread object responsible for processing the queue.
+      attr_accessor :thread
+
+      # A running total of the total number of files that have been processed by the queue during the lifetime of a Queue session.
+      attr_accessor :total_ran
+
+      alias :force_run? :force_run
+      alias :ok_to_run? :ok_to_run
+      alias :stop? :stop
+
+      ##################################################################################
+      def initialize
+
+        super
+
+        self.force_run = false
+        self.last_queue_event = Time.now
+        self.latency = 0.65
+        self.lock = Mutex.new
+        self.queue = []
+        self.queue_event_block = nil
+        self.queue_event_lock = Mutex.new
+        self.speed = 0.65 #25
+        self.stop = false
+        self.total_ran = 0
+
+      end
+
+      ##################################################################################
+      # Sets the block to execute when the queue has runnable test files ready to be run.
+      # The value of this block is actually set by {FileManager}.
+      # @return [NilClass]
+      def queue_event(&block)
+        if block_given?
+          self.queue_event_block = block
+          self.ok_to_run = true
+        end
+
+        return nil
+      end
+
+      ##################################################################################
+      # Executes {#queue_event_block} and passes the list of runnable test files to it.
+      # A thread lock is obtained and {#ok_to_run} is set to false prior to executing the block.
+      # {#ok_to_run} is set back to true after the block completes execution.
+      # @param [Array] list A list of full file specs pointing to runnable test files.
+      # @return [NilClass]
+      def run(list = [])
+
+        self.queue_event_lock.synchronize do
+
+          self.ok_to_run = false
+
+          unless self.queue_event_block.blank?
+            self.queue_event_block.call QueueEvent.new(self, list)
+          end
+
+          self.ok_to_run = true
+
+        end
+
+        return nil
+      end
+
+      ##################################################################################
+      # Starts the queue thread which is the controlling body of the Queue class.
+      # @return [NilClass]
+      def start
+
+        self.thread = Thread.new do
+
+          begin
+
+            until self.stop do
+
+              sleep(self.speed)
+
+              if self.autorun? || self.force_run?
+                if self.ok_to_run?
+                  buffer = []
+                  self.lock.synchronize do
+                    self.force_run = false
+                    if ((Time.now - self.last_queue_event) >= self.latency)
+                      length = self.queue.length
+                      length.times {|x| buffer.push(self.queue.pop)}
+                      self.total_ran += buffer.length
+                    end
+                  end
+
+                  if (buffer.length > 0)
+                    self.run(buffer)
+                  end
+                else
+                  ducklog.console "Waiting on runner.  Files in queue: (#{self.queue.length})  Total ran during session: (#{self.total_ran})"
+                end
+              end
+
+            end
+
+          rescue Exception => e
+            ducklog.exception e
+          end
+
+        end
+
+        return nil
+      end
+
+      ##################################################################################
+      # Adds a file_spec to the list of runnable test files that need to be run.  It prevents duplicates by
+      # checking to see if the file_spec is already in the queue.
+      # @param [String] file_spec The full file specification of the file or directory on which the event occured.
+      # @return [NilClass]
+      def push(file_spec)
+
+        self.lock.synchronize do
+
+          if self.autorun? && !self.queue.include?(file_spec)
+            self.queue.push(file_spec)
+          end
+
+          self.last_queue_event = Time.now
+
+        end
+
+        return nil
+      end
+
+      ##################################################################################
+      # Safely resets the queue to an empty Array.
+      # @return [NilClass]
+      def reset
+        self.lock.synchronize do
+          self.queue = []
+        end
+        return nil
+      end
+
+      ##################################################################################
+      # Safely sets the value of {#speed}
+      # @return [NilClass]
+      def set_speed(value)
+        self.lock.synchronize do
+          self.speed = value unless value.blank?
+        end
+        return nil
+      end
+
+      ##################################################################################
+      # Safely sets the value of {#latency}
+      # @return [NilClass]
+      def set_latency(value)
+        self.lock.synchronize do
+          self.latency = value unless value.blank?
+        end
+        return nil
+      end
+
+      ##################################################################################
+      # Returns the total number of tests in the queue waiting to run.
+      # @return [Number]
+      def tests_pending
+        value = 0
+        self.lock.synchronize do
+          value = self.queue.length
+        end
+        return value
+      end
+
+    end
+  end
+end

data/lib/duck_test/frame_work/queue_event.rb

@@ -0,0 +1,29 @@
+module DuckTest
+  module FrameWork
+
+    # A QueueEvent is triggered when directories / files have changed and contains a list of the files that have changed.
+    class QueueEvent
+
+      # See {#initialize}
+      attr_accessor :source
+
+      # See {#initialize}
+      attr_accessor :files
+
+      ##################################################################################
+      # Initialize a new QueueEvent
+      # @param [Object] source    A reference to the calling object.
+      # @param [Array] files      A list of files that have changed and require action.
+      # @return [QueueEvent]
+      def initialize(source, files)
+        super()
+
+        self.source = source
+        self.files = files.uniq
+
+        return self
+      end
+
+    end
+  end
+end

data/lib/duck_test/frame_work/rspec/base.rb

@@ -0,0 +1,17 @@
+module DuckTest
+  # ...
+  module FrameWork
+
+    # ...
+    module RSpec
+
+      autoload :FrameWork, 'duck_test/frame_work/rspec/frame_work'
+
+      # ...
+      module Base
+      end
+
+    end
+
+  end
+end

data/lib/duck_test/frame_work/rspec/frame_work.rb

@@ -0,0 +1,30 @@
+module DuckTest
+  module FrameWork
+    module RSpec
+
+      # Testing Framework for RSpec
+      class FrameWork < DuckTest::FrameWork::Base
+
+        ##################################################################################
+        # This is a hack to override run_fork in order to set the rspec global variable rspec_start_time.
+        # The report at the end of the run of the specs was reporting incorrect duration since rspec_start_time
+        # is set when the gem loads.  This is a good place to start looking if incorrect results start happenning again.
+        def run_fork(non_runnable_files, runnable_files, force_run = false)
+          $rspec_start_time = Time.now
+          super(non_runnable_files, runnable_files, force_run)
+        end
+
+        ##################################################################################
+        # Does the work of actually running the tests.
+        def run_tests
+
+          ::RSpec::Core::Runner.run([])
+
+          puts ::IRB.CurrentContext.io.prompt
+
+        end
+
+      end
+    end
+  end
+end

data/lib/duck_test/frame_work/test_unit/base.rb

@@ -0,0 +1,14 @@
+module DuckTest
+  module FrameWork
+    # ...
+    module TestUnit
+
+      autoload :FrameWork, 'duck_test/frame_work/test_unit/frame_work'
+
+      # ...
+      module Base
+      end
+
+    end
+  end
+end

data/lib/duck_test/frame_work/test_unit/frame_work.rb

@@ -0,0 +1,33 @@
+module DuckTest
+  module FrameWork
+    module TestUnit
+
+      ##################################################################################
+      # FrameWork for running Test::Unit tests
+      class FrameWork < DuckTest::FrameWork::Base
+
+        ##################################################################################
+        # Does the work of actually running the tests.
+        def run_tests
+
+          if defined?(::Test::Unit::Runner)
+            ducklog.console "Running tests using: Test::Unit::Runner"
+            ::Test::Unit::Runner.new.run([])
+
+          elsif defined?(::MiniTest::Unit)
+            ducklog.console "Running tests using: MiniTest::Unit"
+            ::MiniTest::Unit.new.run([])
+
+          else
+            ducklog.console "Cannot run tests.  Unable to determine which test runner to use."
+
+          end
+
+          puts ::IRB.CurrentContext.io.prompt
+
+        end
+
+      end
+    end
+  end
+end

data/lib/duck_test/frame_work/watch_config.rb

@@ -0,0 +1,69 @@
+module DuckTest
+  module FrameWork
+
+
+    # A WatchConfig represents a single watch definition including attributes such as pattern, filter sets, mappings, etc.
+    #
+    #  DuckTest.config do
+    #  
+    #    runnable "**/*"    # this would represent a WatchConfig object.
+    #    
+    #  end
+    class WatchConfig
+      include DuckTest::ConfigHelper
+
+      # See {DuckTest::ConfigHelper#autorun}
+      attr_accessor :autorun
+
+      # See {#initialize}
+      attr_accessor :filter_set
+
+      # See {#initialize}
+      attr_accessor :maps
+
+      # See {#initialize}
+      attr_accessor :pattern
+
+      # See {#initialize}
+      attr_accessor :runnable
+
+      alias :autorun? :autorun
+      alias :runnable? :runnable
+
+      ##################################################################################
+      # Initialize a new WatchConfig
+      # @param [Hash] options                                           An options Hash containing values used to initialize the object.
+      # @option options [Symbol] :autorun                               See {DuckTest::ConfigHelper#autorun}
+      # @option options [String] :watch_basedir                         See {DuckTest::ConfigHelper#watch_basedir}
+      # @option options [DuckTest::FrameWork::FilterSet] :filter_set    See {DuckTest::FrameWork::FilterSet}
+      # @option options [Array] :maps                                   See {DuckTest::FrameWork::Map}
+      # @option options [String] :pattern                               See {DuckTest::Config#watch}
+      # @option options [Boolean] :runnable                             Boolean indicating if the files watch by this WatchConfig are runnable test files.
+      # @option options [String] :runnable_basedir                      See {DuckTest::ConfigHelper#runnable_basedir}
+      # @return [WatchConfig]
+      def initialize(options = {})
+        super()
+
+        self.autorun = options[:autorun]
+        self.autorun = false if self.autorun.nil?
+
+        self.watch_basedir = options[:watch_basedir]
+
+        self.filter_set = options[:filter_set] unless options[:filter_set].blank?
+        self.filter_set = FilterSet.new(options) if self.filter_set.blank?
+
+        self.maps = options[:maps] unless options[:maps].blank?
+        self.maps = [] if self.maps.blank?
+
+        self.pattern = options[:pattern]
+        self.runnable = options[:runnable]
+        self.runnable = false if self.runnable.nil?
+
+        self.runnable_basedir = options[:runnable_basedir]
+
+        return self
+      end
+
+    end
+  end
+end

data/lib/duck_test/gem/helper.rb

@@ -0,0 +1,107 @@
+# once upon a time, I had a series of tasks and gemspecs to build different versions for different platforms.
+# I made a decision to adandon all of those different gems and simply notify the developer to edit their Gemfile.
+# however, i kept this code in case i need to go back down that path...
+require "yaml"
+
+module DuckTest
+  # ...
+  module Gem
+
+    ##################################################################################
+    # ...
+    class Helper
+
+      ##################################################################################
+      # ...
+      def initialize
+        super
+      end
+
+      ##################################################################################
+      # ...
+      def base_dir
+        @base_dir ||= File.expand_path(".")
+        return @base_dir
+      end
+
+      # ...
+      def base_dir=(value)
+        @base_dir = File.expand_path(value)
+      end
+
+      ##################################################################################
+      # ...
+      def output_gem_spec(name, pkg = "")
+        Dir[File.join(self.base_dir, pkg, "#{name}*.gem")].sort_by{|f| File.mtime(f)}.last
+      end
+
+      ##################################################################################
+      # ...
+      def build(gem_spec, output_gem_spec)
+        %x(gem build -V '#{gem_spec}.gemspec')
+        output_file_spec = self.output_gem_spec(output_gem_spec)
+        file_name = File.basename(output_file_spec)
+        FileUtils.mkdir_p(File.join(self.base_dir, 'pkg'))
+        FileUtils.mv(output_file_spec, 'pkg')
+        puts "#{file_name} built to pkg/#{file_name}"
+      end
+
+      ##################################################################################
+      # ...
+      def install(gem_spec, output_gem_spec)
+        self.build(gem_spec, output_gem_spec)
+        output_file_spec = self.output_gem_spec(output_gem_spec, "pkg")
+        puts "Installing gem: #{output_file_spec}"
+        %x(gem install '#{output_file_spec}')
+        puts "   Install complete."
+      end
+
+      ##################################################################################
+      # ...
+      def release(gem_spec, output_gem_spec)
+        if File.exist?(File.expand_path("~/.gem/credentials"))
+          self.build(gem_spec, output_gem_spec)
+          output_file_spec = self.output_gem_spec(output_gem_spec, "pkg")
+          puts "Releasing gem: #{output_file_spec}"
+          %x(gem push '#{output_file_spec}')
+          puts "   Release complete."
+        else
+          raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
+        end
+      end
+
+      ##################################################################################
+      # ...
+      def local(gem_spec, output_gem_spec)
+        config_file_spec = File.expand_path("~/.gem/gemserverlocal")
+
+        if File.exist?(config_file_spec)
+
+          yaml = YAML.load_file(config_file_spec)
+
+          if yaml && yaml["path"]
+
+            path = yaml["path"]
+
+            self.build(gem_spec, output_gem_spec)
+            output_file_spec = self.output_gem_spec(output_gem_spec, 'pkg')
+
+            puts "Locally releasing gem: #{output_file_spec}"
+            FileUtils.mkdir_p(File.join(path, 'gems'))
+            FileUtils.cp(output_file_spec, File.join(path, 'gems'))
+
+            %x(gem generate_index --directory #{path})
+            puts "   Local release complete."
+
+          else
+            raise "~/.gem/gemserverlocal file exists, however, path: /path/to/repo is missing.  please add a path to the root of a local gem server"
+          end
+        else
+          raise "~/.gem/gemserverlocal file is missing.  Please create the file and include path: /path/to/repo to the root of a local gem server"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/duck_test/logger.rb

@@ -0,0 +1,127 @@
+module DuckTest
+
+  # Conveinence methods providing access to the Logger class.
+  module LoggerHelper
+    # ...
+    def ducklog
+      return Logger.ducklog
+    end
+  end
+
+  # Custom Logger
+  class Logger < ActiveSupport::BufferedLogger
+
+    SYSTEM = 6
+
+    ##################################################################################
+    # Instance of DuckTest::Logger
+    def self.ducklog
+      dir = defined?(Rails) ? Rails.root : "."
+      return @@ducklog ||= self.new("#{dir}/log/ducktest.log", INFO)
+    end
+    
+    ##################################################################################
+    # Converts a Symbol to a valid log level and vise versa.
+    # @return [Object] The return value is based on the argument :key.
+    #                    - If you pass a Symbol, you get a log level.
+    #                    - If you pass a log level, you get a Symbol.
+    def self.to_severity(key)
+      values = {debug: DEBUG, info: INFO, warn: WARN, error: ERROR, fatal: FATAL, unknown: UNKNOWN, system: SYSTEM}
+      value = values.map.find {|value| value[key.kind_of?(Symbol) ? 0 : 1].eql?(key)}
+      return value.blank? ? nil : value[key.kind_of?(Symbol) ? 1 : 0]
+    end
+
+    ##################################################################################
+    # Sets the logging level for the ducklog.
+    # @param [Symbol, Number] key A value representing the desired logging level.  Can be a Symbol such as :debug, :info, etc.
+    #                 or an ActiveSupport::BufferedLogger Constant DEBUG, INFO, etc.
+    # @return [Number]
+    def self.log_level=(key)
+      key = key.blank? ? "" : key.to_sym
+      value = self.to_severity(key)
+
+      unless value.blank?
+        @@log_level = value
+        value = value.eql?(SYSTEM) ? DEBUG : value
+        self.ducklog.level = value
+      end
+
+    end
+
+    ##################################################################################
+    # Gets the current logging level for the ducklog.
+    # @return [Number]
+    def self.log_level
+      @@log_level ||= self.ducklog.level
+      return @@log_level
+    end
+
+    ##################################################################################
+    # ...
+    def console(msg = nil, progname = nil, &block)
+      STDOUT.puts msg
+      add(INFO, "#{Config.framework_name.to_s.rjust(15)}: #{msg}", progname, &block)
+      return nil
+    end
+
+    ##################################################################################
+    # ...
+    def exception(exception, progname = nil, &block)
+      STDOUT.puts %(ERROR!! ducktest.log for: #{exception})
+      #if self.class.log_level.eql?(DEBUG)
+        exception.backtrace.each {|x| STDOUT.puts x}
+      #end
+      add(ERROR, "#{Config.framework_name.to_s.rjust(15)}: #{exception.to_s}", progname, &block)
+      exception.backtrace.each {|x| add(ERROR, x, progname, &block)}
+      return nil
+    end
+
+    ##################################################################################
+    # ...
+    def debug(msg = nil, progname = nil, &block)
+      add(DEBUG, "#{Config.framework_name.to_s.rjust(15)}: #{msg}", progname, &block)
+      return nil
+    end
+
+    ##################################################################################
+    # ...
+    def info(msg = nil, progname = nil, &block)
+      add(INFO, "#{Config.framework_name.to_s.rjust(15)}: #{msg}", progname, &block)
+      return nil
+    end
+
+    ##################################################################################
+    # ...
+    def system(msg = nil, progname = nil, &block)
+      if self.class.log_level.eql?(SYSTEM)
+        add(DEBUG, "#{Config.framework_name.to_s.rjust(15)}: #{msg}", progname, &block)
+      end
+      return nil
+    end
+
+  end
+end
+
+# could be useful for adding colored logging later.
+# CLEAR   = "\e[0m"
+# BOLD    = "\e[1m"
+#
+# # Colors
+# BLACK   = "\e[30m"
+# RED     = "\e[31m"
+# GREEN   = "\e[32m"
+# YELLOW  = "\e[33m"
+# BLUE    = "\e[34m"
+# MAGENTA = "\e[35m"
+# CYAN    = "\e[36m"
+# WHITE   = "\e[37m"
+#
+# #############################################################################################
+# def color(text, color, bold=false)
+#   color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+#   bold  = bold ? BOLD : ""
+#   return "#{bold}#{color}#{text}#{CLEAR}"
+# end
+#
+#   puts "Database Name: #{color(database, CYAN, true)}"
+#   puts "    User Name: #{color(user_name, CYAN, true)}"

data/lib/duck_test/option_parser.rb

@@ -0,0 +1,30 @@
+# this is unfinished code that was not implemented
+# the original idea was to alter OptionParser class to grab and remove
+# arguments from the CLI prior to the console loading fully as it will
+# puke with an error if a user passes invalid arguments.
+# the desire was to somehow grab a CLI arg from a user and set the session
+# to load while still allowing the user to use the standard rails command
+
+# like: rails c test
+
+# i would have like to do something like: rails c test --duck=rspec
+
+# then, remove the argument from ARGV and let rails c test continue
+# the test of the idea actually worked, however, i never actually coded a solution, because,
+# i thought it might make the gem to brittle to use.  I may decide to implement it at a later
+# date after more thought.  for now, the current solution was to simply create an executable
+# that grabs the args and fire up the console.
+
+# class OptionParser
+# 
+#   alias_method :my_parse!, :parse!
+# 
+#   def parse!(x)
+# 
+#     value = ARGV.find {|item| item =~ /^--duck/ || item =~ /^-duck/}
+#     ARGV.delete_if {|item| item =~ /^--duck/ || item =~ /^-duck/}
+# 
+#     my_parse!(x)
+#   end
+# 
+# end