golly-utils 0.0.1

data/lib/golly-utils/ruby_ext/hash_combinations.rb

@@ -0,0 +1,49 @@
+class Hash
+
+  # Given a hash where each value can be a single value or an array of potential values, this generate a hash for each
+  # combination of values across all keys.
+  #
+  # @return [Array<Hash>]
+  #
+  # @example
+  #   # Here key :a has 3 possible values, :b has 2, and :c and :d have only 1 each.
+  #   x = {a:%w[x y z], b:[1,2], c:'true', d:nil}
+  #
+  #   x.value_combinations
+  #   # will return:
+  #
+  #   [
+  #    {a:'x', b:1, c:'true', d:nil},
+  #    {a:'y', b:1, c:'true', d:nil},
+  #    {a:'z', b:1, c:'true', d:nil},
+  #    {a:'x', b:2, c:'true', d:nil},
+  #    {a:'y', b:2, c:'true', d:nil},
+  #    {a:'z', b:2, c:'true', d:nil},
+  #   ]
+  def value_combinations
+    collect_value_combinations [], {}, keys
+  end
+
+  private
+
+  def collect_value_combinations(results, tgt, remaining_keys)
+    if remaining_keys.empty?
+      results<< tgt
+    else
+      next_set_of_keys= remaining_keys[1..-1]
+      k= remaining_keys[0]
+      v= self[k]
+      if v.kind_of?(Enumerable)
+        v.each_entry {|v2|
+          tgt2= tgt.dup
+          tgt2[k]= v2
+          collect_value_combinations results, tgt2, next_set_of_keys
+        }
+      else
+        tgt[k]= v
+        collect_value_combinations results, tgt, next_set_of_keys
+      end
+    end
+    results
+  end
+end

data/lib/golly-utils/ruby_ext/pretty_error_messages.rb

@@ -0,0 +1,9 @@
+class StandardError
+
+  # Creates a string that provides more information (a backtrace) than the default `to_s` method.
+  #
+  # @return String
+  def to_pretty_s
+    "#{self.inspect}\n#{self.backtrace.map{|b| "  #{b}"}.join "\n"}"
+  end
+end

data/lib/golly-utils/ruby_ext/subclasses.rb

@@ -0,0 +1,17 @@
+class Class
+  def inherited other
+    super if defined? super
+  ensure
+    ( @subclasses ||= [] ).push(other).uniq!
+  end
+
+  # Returns a list of classes that extend this class, directly or indirectly (as in subclasses of subclasses).
+  #
+  # @return [Array<Class>]
+  def subclasses(include_subclassed_nodes = false)
+    @subclasses ||= []
+    classes= @subclasses.inject( [] ) {|list, subclass| list.push subclass, *subclass.subclasses }
+    classes.reject! {|c| classes.any?{|i| c != i and c.subclasses.include?(i) }} unless include_subclassed_nodes
+    classes
+  end
+end

data/lib/golly-utils/test/spec/deferrable_specs.rb

@@ -0,0 +1,85 @@
+module GollyUtils
+
+  # With this module you can create specs that don't start running until manually started elsewhere in another spec.
+  #
+  # This is only really useful when writing integration tests in spec format, where specs (aka examples) are not
+  # isolated tests but single components of a larger-scale test. This is especially the case when checking
+  # asynchronous events, or managing dependencies on state of an external entity.
+  #
+  # ### Usage:
+  # * Extend `GollyUtils::DeferrableSpecs`
+  # * Create specs/examples using `deferrable_spec`
+  # * In other specs/examples, call `start_deferred_test` to start deferred tests.
+  #
+  # @example
+  #     describe 'Integration test #2' do
+  #       extend GollyUtils::DeferrableSpecs
+  #
+  #       it("Register client, notices and default prefs") do
+  #         scenario.register_client
+  #         scenario.register_notification_groups
+  #         scenario.register_notices
+  #         scenario.set_default_preferences
+  #
+  #         start_deferred_test :email1
+  #         start_deferred_test :email2
+  #         start_deferred_test :mq
+  #       end
+  #
+  #       # Deferred until registration of client, notices and preferences are complete
+  #       deferrable_spec(:email1, "Sends emails (to unregistered contacts)") do
+  #         assert_sends_email ...
+  #       end
+  #
+  #       ...
+  #
+  #     end
+  module DeferrableSpecs
+    def self.extended(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+      base.instance_eval{ @deferrable_specs= {} }
+    end
+
+    module ClassMethods
+      attr_reader :deferrable_specs
+
+      def deferrable_spec(key, name, &block)
+        deferrable_specs[key]= {block: block}
+        class_eval <<-EOB
+          it(#{name.inspect}){ deferred_join #{key.inspect} }
+        EOB
+      end
+
+    end
+
+    module InstanceMethods
+
+      def start_deferred_tests(first_key,*other_keys)
+        ([first_key]+other_keys).flatten.uniq.each do |key|
+          raise "Unknown defferable test: #{key}" unless d= self.class.deferrable_specs[key]
+          raise "Test already started: #{key}" if d[:thread]
+          raise "Test block missing." unless b= d[:block]
+          s= self.dup
+          d[:thread]= Thread.new{ s.instance_eval &b }
+        end
+        true
+      end
+
+      alias start_deferred_test start_deferred_tests
+
+      def deferred_join(key)
+        raise "Unknown defferable test: #{key}" unless d= self.class.deferrable_specs[key]
+        if t= d[:thread]
+          t.join
+        else
+          #raise "Test hasn't started: #{key}"
+          warn "Deferrable spec #{key.inspect} wasn't deferred. Start it elsewhere with start_deferred_test #{key.inspect}"
+          raise "Test block missing." unless b= d[:block]
+          b.call
+        end
+      end
+
+    end
+  end
+end

data/lib/golly-utils/test/spec/within_time.rb

@@ -0,0 +1,56 @@
+module TestHelpers
+
+  # @example
+  #   within(5).seconds{ File.exists?(f).should == true }
+  # @see WithinTime
+  def within(timeout)
+    WithinTime.new(timeout)
+  end
+
+  # Re-runs a given block until it:
+  #
+  # * indicates success by returning `true`
+  # * fails by not returning `true` within a given time period.
+  #
+  # @see #within
+  class WithinTime
+    def initialize(timeout, sleep_time=0.1)
+      timeout= timeout.to_f
+      raise unless timeout > 0
+      @timeout= timeout
+
+      sleep_time= sleep_time.to_f
+      raise unless sleep_time > 0
+      @sleep_time= sleep_time
+    end
+    def ms     (&block) run    0.001, block end
+    def seconds(&block) run    1    , block end
+    def minutes(&block) run   60    , block end
+    def hours  (&block) run 3600    , block end
+    alias :msec   :ms
+    alias :second :seconds
+    alias :sec    :seconds
+    alias :minute :minutes
+    alias :min    :minutes
+    alias :hour   :hours
+    alias :hr     :hours
+    alias :hrs    :hours
+    protected
+    def run(factor_to_sec, block)
+      timeout= @timeout * factor_to_sec
+      sleep_time= @sleep_time * factor_to_sec
+      start= Time.now
+      while true
+
+        begin
+          block.call
+          return true
+        rescue RSpec::Expectations::ExpectationNotMetError => err
+          sleep sleep_time
+          raise err if (Time.now - start) > timeout
+        end
+
+      end
+    end
+  end
+end

data/lib/golly-utils/version.rb

@@ -0,0 +1,3 @@
+module GollyUtils
+  VERSION = "0.0.1"
+end

data/test/bootstrap/all.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+APP_ROOT = File.expand_path('../../..',__FILE__)
+require 'rubygems'
+require 'corvid/test/bootstrap/all'

data/test/bootstrap/spec.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+$coverage_name = 'specs'
+require_relative 'all'
+require 'corvid/test/bootstrap/spec'
+

data/test/bootstrap/unit.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+$coverage_name = 'unit tests'
+require_relative 'all'
+require 'corvid/test/bootstrap/unit'

data/test/spec/child_process_mock_target.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+raise 'no bro' unless ARGV.count == 1
+
+file= ARGV[0]
+raise "#{file} already exists." if File.exists?(file)
+$file= file
+
+#puts "Starting..."
+#puts "Delete #{file} to stop."
+#while true
+#  File.open(file,"a") {|fout| fout<< '.'}
+#  sleep 0.2
+#  break if !File.exists?(file)
+#end
+#
+#puts "File deleted by external process. Shutting down."
+
+at_exit { bye }
+#Kernel.trap('INT') { bye }
+def bye
+  puts "Bye!"
+  File.unlink $file if $file
+end
+
+puts "Starting..."
+File.write(file,"a")
+while sleep 0.1; end

data/test/spec/child_process_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require_relative '../bootstrap/spec'
+require 'tmpdir'
+require 'golly-utils/child_process'
+require 'golly-utils/test/spec/within_time'
+
+describe GollyUtils::ChildProcess do
+  after :each do
+    cp.shutdown
+  end
+
+  let(:cp){
+    described_class.new \
+      quiet: true,
+      start_command: "#{File.expand_path '../child_process_mock_target.rb', __FILE__} #{tmpfile}"
+  }
+  let(:tmpfile){
+    "#{Dir.tmpdir}/live_tester-#{Time.now.strftime '%Y%m%d%H%M%S%L'}-#{$$}.tmp"
+  }
+
+  it("shall start and stop server processes"){
+    cp.startup
+    within(2).seconds{ File.exists?(tmpfile).should == true }
+    cp.alive?.should == true
+    cp.shutdown.should == true
+    within(2).seconds{ File.exists?(tmpfile).should == false }
+    cp.alive?.should == false
+  }
+
+  it("shall do nothing when startup called and already started"){
+    cp.startup
+    (pid= cp.pid).should_not be_nil
+    cp.startup
+    cp.pid.should == pid
+  }
+
+  it("shall do nothing when shutdown called and not started"){
+    cp.alive?.should == false
+    cp.shutdown.should == true # mostly just asserting it doesn't fail
+  }
+end

data/test/unit/attr_declarative_test.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require_relative '../bootstrap/unit'
+require 'golly-utils/attr_declarative'
+
+class AttrDeclarativeTest < MiniTest::Unit::TestCase
+
+  class Abc
+    include GollyUtils::AttrDeclarative
+    attr_declarative :cow
+    attr_declarative :horse, default: 246
+  end
+
+  def test_acts_like_attribute
+    a= Abc.new
+    assert_nil a.cow
+    a.cow{ 12 }
+    assert_equal 12, a.cow
+  end
+
+  def test_default
+    a= Abc.new
+    assert_equal 246, a.horse
+    a.horse{ 'hehe' }
+    assert_equal 'hehe', a.horse
+  end
+
+  class Abc2 < Abc
+    cow{ 777 }
+  end
+  def test_subclasses_can_change_defaults
+    a= Abc2.new
+    assert_equal 777, a.cow
+    a.cow{ 12 }
+    assert_equal 12, a.cow
+    assert_equal 777, Abc2.new.cow
+    assert_nil Abc.new.cow
+  end
+
+  class Abc3 < Abc2; end
+  def test_subclasses_inherit_parents_declarations
+    assert_equal 777, Abc3.new.cow
+  end
+
+  class Dynamic < Abc
+    $cow= 123
+    cow{ $cow }
+  end
+  def test_class_declarations_arent_evaluated_until_needed
+    a= Dynamic.new
+    $cow= 456
+    assert_equal 456, a.cow
+  end
+
+end

data/test/unit/callbacks_test.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+require_relative '../bootstrap/unit'
+require 'golly-utils/callbacks'
+
+class CallbacksTest < MiniTest::Unit::TestCase
+
+  VALUES= []
+
+  def setup
+    VALUES.clear
+  end
+
+  class Base
+    include GollyUtils::Callbacks
+    define_callback :base
+    def self.record(v); CallbacksTest::VALUES << v end
+    def self.run
+      o= self.new
+      o.run
+      CallbacksTest::VALUES
+    end
+  end
+
+  class Omg < Base
+    define_callback :wow
+    def run
+      run_callback :wow
+    end
+  end
+  def test_none; assert_equal [], Omg.run; end
+
+  class Omg1 < Omg
+    wow{ record 1 }
+  end
+  def test_one; assert_equal [1], Omg1.run; end
+
+  class Omg2 < Omg
+    wow{ record 1 }
+    wow{ record 2 }
+  end
+  def test_multiple_callees_for_single_callback; assert_equal [1,2], Omg2.run; end
+
+  class Omg1H < Omg1
+    wow{ record 3 }
+  end
+  def test_callees_inherited; assert_equal [3,1], Omg1H.run; end
+
+  class Sweet < Omg1
+    define_callbacks :dude, :sweet
+    wow{ record 7 }
+    dude{ record 60 }
+    sweet{ record 100 }
+    dude{ record 50 }
+    def run
+      run_callback :wow
+      run_callback :base
+      self.class.record 666
+      run_callbacks :sweet, :dude
+    end
+  end
+  def test_everything; assert_equal [7,1,666,100,60,50], Sweet.run; end
+
+  class Fail < Base
+    def self.what; 135 end
+  end
+  def test_callbacks_dont_overwrite_class_methods
+    Fail.send :define_callback, :this_should_work
+    assert_equal 135, Fail.what
+    Fail.send :define_callback, :what
+    flunk 'Exception expected. Callbacks are supposed to raise an error a method with the callback name already exists.'
+  rescue => e
+    assert e.to_s['what'], "Error message doesn't include the conflicting method/callback name.\nErrMsg: #{e}"
+    assert_equal 135, Fail.what
+  end
+
+end