redcar 0.2.9dev

data/lib/logging/test/test_stats.rb

@@ -0,0 +1,274 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+module TestStats
+
+  class TestSampler < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @sampler = ::Logging::Stats::Sampler.new('test')
+    end
+
+    def test_reset
+      (1..10).each {|n| @sampler.sample n}
+
+      assert_equal 55,  @sampler.sum
+      assert_equal 385, @sampler.sumsq
+      assert_equal 10,  @sampler.num
+      assert_equal 1,   @sampler.min
+      assert_equal 10,  @sampler.max
+      assert_equal 10,  @sampler.last
+
+      @sampler.reset
+
+      assert_equal 0, @sampler.sum
+      assert_equal 0, @sampler.sumsq
+      assert_equal 0, @sampler.num
+      assert_equal 0, @sampler.min
+      assert_equal 0, @sampler.max
+      assert_nil @sampler.last
+    end
+
+    def test_coalesce
+      other = ::Logging::Stats::Sampler.new('other')
+      (1..5).each {|n| other.sample n}
+      (6..10).each {|n| @sampler.sample n}
+
+      assert_equal 5, @sampler.num
+
+      @sampler.coalesce other
+
+      assert_equal 55,  @sampler.sum
+      assert_equal 385, @sampler.sumsq
+      assert_equal 10,  @sampler.num
+      assert_equal 1,   @sampler.min
+      assert_equal 10,  @sampler.max
+      assert_equal 5,   @sampler.last
+
+      @sampler.coalesce ::Logging::Stats::Sampler.new('tmp')
+
+      assert_equal 55,  @sampler.sum
+      assert_equal 385, @sampler.sumsq
+      assert_equal 10,  @sampler.num
+      assert_equal 1,   @sampler.min
+      assert_equal 10,  @sampler.max
+      assert_equal 5,   @sampler.last
+    end
+
+    def test_sample
+      @sampler.sample 1
+
+      assert_equal 1, @sampler.sum
+      assert_equal 1, @sampler.sumsq
+      assert_equal 1, @sampler.num
+      assert_equal 1, @sampler.min
+      assert_equal 1, @sampler.max
+      assert_equal 1, @sampler.last
+
+      @sampler.sample 2
+
+      assert_equal 3, @sampler.sum
+      assert_equal 5, @sampler.sumsq
+      assert_equal 2, @sampler.num
+      assert_equal 1, @sampler.min
+      assert_equal 2, @sampler.max
+      assert_equal 2, @sampler.last
+    end
+
+    def test_to_s
+      (1..10).each {|n| @sampler.sample n}
+      assert_equal(
+        "[test]: SUM=55.000000, SUMSQ=385.000000, NUM=10, MEAN=5.500000, SD=3.027650, MIN=1.000000, MAX=10.000000",
+        @sampler.to_s
+      )
+    end
+
+    def test_to_a
+      (1..10).each {|n| @sampler.sample n}
+      assert_equal(
+        ['test', 55, 385, 10, 5.5, @sampler.sd, 1, 10],
+        @sampler.to_a
+      )
+    end
+
+    def test_to_hash
+      (1..10).each {|n| @sampler.sample n}
+      assert_equal(
+        {:name => 'test', :sum => 55, :sumsq => 385, :num => 10, :mean => 5.5, :sd => @sampler.sd, :min => 1, :max => 10},
+        @sampler.to_hash
+      )
+    end
+
+    def test_mean
+      assert_equal 0, @sampler.mean
+
+      @sampler.sample 10
+      assert_equal 10, @sampler.mean
+
+      @sampler.sample 20
+      assert_equal 15, @sampler.mean
+    end
+
+    def test_sd
+      assert_equal 0, @sampler.sd
+
+      @sampler.sample 1
+      assert_equal 0, @sampler.sd
+
+      @sampler.sample 2
+      assert_in_delta 0.707106781186548, @sampler.sd, 1e-10
+
+      @sampler.sample 3
+      assert_in_delta 1.0, @sampler.sd, 1e-10
+
+      @sampler.sample 4
+      assert_in_delta 1.29099444873581, @sampler.sd, 1e-10
+    end
+
+    def test_mark_and_tick
+      10.times do
+        @sampler.mark
+        sleep 0.01
+        @sampler.tick
+      end
+
+      assert_equal 10, @sampler.num
+      assert_in_delta 0.01, @sampler.mean, 1e-3
+    end
+  end  # class TestSampler
+
+  class TestTracker < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @tracker = ::Logging::Stats::Tracker.new
+      @stats = @tracker.stats
+    end
+
+    def test_coalesce
+      1.times {|n| @tracker.sample('foo', n)}
+      2.times {|n| @tracker.sample('bar', n)}
+      3.times {|n| @tracker.sample('baz', n)}
+
+      assert_equal %w[bar baz foo], @stats.keys.sort
+      assert_equal 1, @stats['foo'].num
+      assert_equal 2, @stats['bar'].num
+      assert_equal 3, @stats['baz'].num
+
+      # when other is empty, nothing should change in our tracker
+      other = ::Logging::Stats::Tracker.new
+      @tracker.coalesce other
+
+      assert_equal %w[bar baz foo], @stats.keys.sort
+      assert_equal 1, @stats['foo'].num
+      assert_equal 2, @stats['bar'].num
+      assert_equal 3, @stats['baz'].num
+
+      # now add some samples to other
+      4.times {|n| other.sample('buz', n)}
+      5.times {|n| other.sample('bar', n)}
+      @tracker.coalesce other
+
+      assert_equal %w[bar baz buz foo], @stats.keys.sort
+      assert_equal 1, @stats['foo'].num
+      assert_equal 7, @stats['bar'].num
+      assert_equal 3, @stats['baz'].num
+      assert_equal 4, @stats['buz'].num
+    end
+
+    def test_mark
+      assert @stats.empty?
+      @tracker.mark 'foo'
+      assert !@stats.empty?
+
+      sampler = @stats['foo']
+      assert_equal 0, sampler.num
+    end
+
+    def test_tick
+      assert @stats.empty?
+      @tracker.tick 'foo'
+      assert !@stats.empty?
+
+      sampler = @stats['foo']
+      assert_equal 1, sampler.num
+    end
+
+    def test_sample
+      assert @stats.empty?
+      @tracker.sample 'foo', 1
+      assert !@stats.empty?
+
+      sampler = @stats['foo']
+      assert_equal 1, sampler.num
+      assert_equal 1, sampler.last
+
+      @tracker.sample 'foo', 2
+      assert_equal 2, sampler.num
+      assert_equal 2, sampler.last
+      assert_equal 3, sampler.sum
+    end
+
+    def test_time
+      assert @stats.empty?
+      @tracker.time('foo') {sleep 0.05}
+      assert !@stats.empty?
+
+      sampler = @stats['foo']
+      assert_equal 1, sampler.num
+      assert_in_delta 0.05, sampler.sum, 1e-2
+
+      @tracker.time('foo') {sleep 0.05}
+      assert_equal 2, sampler.num
+      assert_in_delta 0.10, sampler.sum, 1e-2
+
+      assert_raise(RuntimeError) do
+        @tracker.time('foo') {raise 'Uh Oh!'}
+      end
+      assert_equal 3, sampler.num
+    end
+
+    def test_reset
+      1.times {|n| @tracker.sample('foo', n)}
+      2.times {|n| @tracker.sample('bar', n)}
+      3.times {|n| @tracker.sample('baz', n)}
+
+      assert_equal 1, @stats['foo'].num
+      assert_equal 2, @stats['bar'].num
+      assert_equal 3, @stats['baz'].num
+
+      @tracker.reset
+
+      assert_equal 0, @stats['foo'].num
+      assert_equal 0, @stats['bar'].num
+      assert_equal 0, @stats['baz'].num
+    end
+
+    def test_reentrant_synchronization
+      assert_nothing_raised do
+        @tracker.sync {
+          @tracker.sample('foo', Math::PI)
+          @tracker.reset
+        }
+      end
+    end
+
+    def test_periodically_run
+      @tracker.periodically_run(0.1) {
+        @tracker.tick 'foo'
+      }
+      sleep 0.5
+      @tracker.stop
+
+      assert(@stats['foo'].num > 1)
+    end
+  end  # class TestTracker
+
+end  # module TestStats
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/test_utils.rb

@@ -0,0 +1,116 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestUtils < Test::Unit::TestCase
+
+    def test_hash_getopt
+      opts = {
+        :foo => 'foo_value',
+        'bar' => 'bar_value',
+        'one' => '1',
+        :two => '2',
+        :three => 3.0
+      }
+
+      assert_equal('foo_value', opts.getopt(:foo))
+      assert_equal('foo_value', opts.getopt('foo'))
+      assert_equal(:foo_value, opts.getopt(:foo, :as => Symbol))
+
+      assert_equal('bar_value', opts.getopt(:bar))
+      assert_equal('bar_value', opts.getopt('bar'))
+
+      assert_equal('1', opts.getopt(:one))
+      assert_equal(1, opts.getopt('one', :as => Integer))
+      assert_instance_of(Float, opts.getopt('one', :as => Float))
+
+      assert_equal('2', opts.getopt(:two))
+      assert_equal(['2'], opts.getopt(:two, :as => Array))
+
+      assert_equal(3.0, opts.getopt(:three))
+      assert_equal('3.0', opts.getopt('three', :as => String))
+
+      assert_equal(nil, opts.getopt(:baz))
+      assert_equal('default', opts.getopt('baz', 'default'))
+      assert_equal(:default, opts.getopt(:key, 'default', :as => Symbol))
+      assert_equal(['default'], opts.getopt('key', 'default', :as => Array))
+
+      assert_equal(3.0, opts.getopt(:three, :as => Object))
+
+      assert_nil opts.getopt(:key, :as => Symbol)
+    end
+
+    def test_string_reduce
+      str = 'this is the foobar string'
+      len = str.length
+
+      r = str.reduce(len + 1)
+      assert_same str, r
+
+      r = str.reduce(len)
+      assert_same str, r
+
+      r = str.reduce(len - 1)
+      assert_equal 'this is the...bar string', r
+
+      r = str.reduce(len - 10)
+      assert_equal 'this i...string', r
+
+      r = str.reduce(4)
+      assert_equal 't...', r
+
+      r = str.reduce(3)
+      assert_equal '...', r
+
+      r = str.reduce(0)
+      assert_equal '...', r
+
+      assert_raises(ArgumentError) { str.reduce(-1) }
+
+      r = str.reduce(len - 1, '##')
+      assert_equal 'this is the##obar string', r
+
+      r = str.reduce(len - 10, '##')
+      assert_equal 'this is##string', r
+
+      r = str.reduce(4, '##')
+      assert_equal 't##g', r
+
+      r = str.reduce(3, '##')
+      assert_equal 't##', r
+
+      r = str.reduce(0, '##')
+      assert_equal '##', r
+    end
+
+    def test_logger_name
+      assert_equal 'Array', Array.logger_name
+
+      # some lines are commented out for compatibility with ruby 1.9
+
+      c = Class.new(Array)
+#     assert_equal '', c.name
+      assert_equal 'Array', c.logger_name
+
+      meta = class << Array; self; end
+#     assert_equal '', meta.name
+      assert_equal 'Array', meta.logger_name
+
+      m = Module.new
+#     assert_equal '', m.name
+      assert_equal 'anonymous', m.logger_name
+
+      c = Class.new(::Logging::Logger)
+#     assert_equal '', c.name
+      assert_equal 'Logging::Logger', c.logger_name
+      
+      meta = class << ::Logging::Logger; self; end
+#     assert_equal '', meta.name
+      assert_equal 'Logging::Logger', meta.logger_name
+    end
+
+  end  # class TestUtils
+end  # module TestLogging
+
+# EOF

data/lib/redcar.rb

@@ -0,0 +1,12 @@
+
+$:.push File.join(File.dirname(__FILE__))
+
+require 'rbconfig'
+
+if Config::CONFIG["RUBY_INSTALL_NAME"] == "jruby"
+  require 'redcar/boot'
+else
+  require 'redcar/runner'
+  runner = Redcar::Runner.new
+  runner.spin_up
+end

data/lib/redcar/boot.rb

@@ -0,0 +1,105 @@
+
+require 'java'
+
+$:.push(File.join(File.dirname(__FILE__), %w(.. little_plugger lib)))
+require 'little-plugger'
+
+$:.push(File.join(File.dirname(__FILE__), %w(.. logging lib)))
+require 'thread'
+require 'logging'
+
+$:.push(File.join(File.dirname(__FILE__), %w(.. freebase2 lib)))
+require 'freebase/freebase'
+
+require 'redcar/ruby_extensions'
+require 'redcar/usage'
+
+# ## Loading and Initialization
+#
+# Every feature in Redcar is written as a plugin. This module contains a few 
+# methods to bootstrap the plugins by loading the FreeBASE plugin handler.
+#
+# FreeBASE (kindly open sourced by the FreeRIDE project) will load Redcar in 
+# the following manner:
+#
+#   1. For each plugin load the file *plugin_name/lib/plugin_name.rb* and then
+#      run the method "load" on the class defined in plugin.yaml as the 
+#      "startup_module". The plugins will be loaded in an order respecting the
+#      "load_dependencies" in each plugin.yaml.
+#   2. Call the start method on each of the "startup_module" classes, respecting
+#      the "start_dependencies" in each plugin.yaml
+#
+# All Redcar initialization is done in these methods, "load" and "start" on 
+# every plugin class. Note that plugins are not required to define either of 
+# these methods.
+#
+# Once loaded, bin/redcar will start the gui pump, which will run 
+# Redcar.gui.start. This starts the GUI library's event loop and hands over 
+# control to the GUI.
+#
+# ## Application
+#
+# The top class of Redcar is a {Redcar::Application}, which handles the creation 
+# of Redcar::Windows. {Redcar::Application} is a good place to start
+# to see how the Redcar models are created. 
+#
+# {Redcar::ApplicationSWT} is the start point for the SWT GUI, which listens
+# for events from the Redcar::Application model and reflects them in the GUI.
+#
+# This structure of a model and a controller that listens to it is repeated for
+# each part of Redcar reflected in the GUI.
+#
+#   * Redcar::Window has Redcar::ApplicationSWT::Window
+#   * Redcar::Notebook has Redcar::ApplicationSWT::Notebook
+#   * Redcar::EditTab has Redcar::EditViewSWT::EditTab
+#
+# and so on.
+module Redcar
+  VERSION         = '0.3.0dev'
+  VERSION_MAJOR   = 0
+  VERSION_MINOR   = 3
+  VERSION_RELEASE = 0
+  
+  ROOT = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+
+  $FR_CODEBASE          = File.expand_path(File.join(File.dirname(__FILE__)) + "/../../")
+  $FR_PROJECT           = nil
+  $FREEBASE_APPLICATION = "Redcar"
+  
+  class << self
+    attr_reader :freebase_core
+  end
+  
+  def self.root
+    ROOT
+  end
+  
+  def self.start
+    @freebase_core = FreeBASE::Core.new(*freebase_core_args)
+    @freebase_core.startup
+  end
+  
+  def self.load
+    @freebase_core = FreeBASE::Core.new(*freebase_core_args)
+    @freebase_core.load_plugins
+  end
+  
+  def self.require
+    @freebase_core = FreeBASE::Core.new(*freebase_core_args)
+    @freebase_core.require_files
+  end
+  
+  def self.pump
+    @freebase_core.bus["/system/ui/messagepump"].call()
+  end
+  
+  private
+  
+  def self.freebase_core_args
+    ["properties.yaml", "config/default.yaml"]
+  end
+end
+
+usage = Redcar::Usage.new
+usage.version_requested
+usage.help_requested