svutil 0.9.4 → 0.9.5

data/lib/svutil.rb

@@ -6,5 +6,5 @@ require 'svutil/log'
 require 'svutil/process_manager'
 
 module SVUtil
-  VERSION = '0.9.4'
+  VERSION = '0.9.5'
 end

data/lib/svutil/config.rb

@@ -4,9 +4,11 @@ require 'ostruct'
 require 'pp'
 
 module SVUtil
-  class Defaults
-    attr_reader :attrs
+  def self.config
+    Config.config_class
+  end
 
+  class Defaults
     def initialize
       @attrs = {}
     end
@@ -24,39 +26,43 @@ module SVUtil
       end
   end
 
+  # TODO: We could make Config a module so that it cannot be instantiated (see http://dalibornasevic.com/posts/9-ruby-singleton-pattern-again)
   class Config
-    attr_writer :config_file
-    attr_reader :attrs
+      
+    class << self
+      attr_writer :config_file
+      attr_reader :attrs
+      attr_reader :defaults
+      # Used mainly for testing
+      attr_accessor :option_source
 
-    def initialize
-      @cli_options = {}
-      @attrs = if self.class.defaults
-        self.class.defaults.attrs.clone
-      else
-        {}
+      attr_accessor :cli_options
+      attr_accessor :cli_option_handlers
+
+      def clear_all
+        @attrs = {}
       end
-    end
 
-    def set(options = {})
-      if block_given?
-        yield self
+      def set(options = {})
+        @attrs ||= {}
+        if block_given?
+          yield self
+        end
+        self.validate
       end
-      self.validate
-    end
 
-    def config_file
-      @config_file ||= "settings"
-    end
+      def defaults(&block)
+        @defaults ||= Defaults.new
+        yield @defaults
+      end
 
-    # TODO: Put in module and extend
-    class << self
-      attr_reader :cli_option_handlers
-      attr_reader :validate_block
+      def config_file
+        @config_file ||= "settings"
+      end
 
-      def defaults
-        @defaults ||= Defaults.new
-        yield @defaults if block_given?
-        return @defaults
+      def set_cli_option(option, value)
+        @cli_options ||= {}
+        @cli_options[option.to_s] = value
       end
 
       def handle_options(&block)
@@ -67,101 +73,102 @@ module SVUtil
       def validator(&block)
         @validate_block = block
       end
-    end
 
-    def set_cli_option(option, value)
-      @cli_options ||= {}
-      @cli_options[option.to_s] = value
-    end
-
-    def validate
-      # TODO: Check file perms
-      if ((pid_file.nil? or pid_file.empty? or File.directory?(pid_file)) && self.daemon)
-        err("PID file must be a writable file")
+      def validate
+	      # TODO: Check file perms
+        if ((pid_file.nil? or pid_file.empty? or File.directory?(pid_file)) && self.daemon)
+          err("PID file must be a writable file")
+        end
+        # TODO: Validate the writability of the log file
+        @validate_block.call(self) unless @validate_block.nil?
+        true
       end
-      # TODO: Validate the writability of the log file
-      self.instance_exec(self, &self.class.validate_block) unless self.class.validate_block.nil?
-      true
-    end
-
-    def init(test_options = nil)
-      set do |c|
-        self.config_provided_on_cli = false
-        OptionParser.new do |opts|
-          opts.on("-f", "--config [filename]", "Config file to use (default 'settings')") do |filename|
-            self.config_file = filename.strip
-            self.config_provided_on_cli = true
-          end
-          opts.on("-d", "--daemon", "Run in the background as a daemon") do
-            set_cli_option(:daemon, true)
-          end
-          opts.on("-l", "--debug-log [log-file]", "Debug Log File") do |log|
-            set_cli_option(:log_file, log)
-          end
-          opts.on("-T", "--trace", "Display backtrace on errors") do
-            set_cli_option(:trace, true)
-          end
-          opts.on("-P", "--pid [pid-file]", "PID File") do |pid|
-            set_cli_option(:pid_file, pid)
-          end
-          # Handle CLI passed options
-          (self.class.cli_option_handlers || []).each do |handler|
-            self.instance_exec(opts, &handler)
-          end
-        end.parse!(test_options || ARGV)
 
+      def init
+        set do |c|
+          self.config_provided_on_cli = false
+          OptionParser.new do |opts|
+            opts.on("-f", "--config [filename]", "Config file to use (default 'settings')") do |filename|
+              self.config_file = filename.strip
+              self.config_provided_on_cli = true
+            end
+            opts.on("-d", "--daemon", "Run in the background as a daemon") do
+              set_cli_option(:daemon, true)
+            end
+            opts.on("-l", "--debug-log [log-file]", "Debug Log File") do |log|
+              set_cli_option(:log_file, log)
+            end
+            opts.on("-T", "--trace", "Display backtrace on errors") do
+              set_cli_option(:trace, true)
+            end
+            opts.on("-P", "--pid [pid-file]", "PID File") do |pid|
+              set_cli_option(:pid_file, pid)
+            end
+            # Handle CLI passed options
+            (cli_option_handlers || []).each do |handler|
+              handler.call(opts)
+            end
+          end.parse!(self.option_source || ARGV)
 
-        # Process the config file
-        if (self.config_file && File.exists?(self.config_file)) || self.config_provided_on_cli
-          load_config_file
-        end
+          # Process the config file
+          if (self.config_file && File.exists?(self.config_file)) || self.config_provided_on_cli
+            load_config_file
+          end
 
-        # Finally apply any CLI options
-        (@cli_options || {}).each do |(k,v)|
-          @attrs[k.to_s] = v
+          # Finally apply any CLI options
+          (cli_options || {}).each do |(k,v)|
+            c.send("#{k}=", v)
+          end
         end
       end
-    end
 
-    private
-      def method_missing(method_id, *args)
-        if method_id.to_s =~ /=$/
-          @attrs[method_id.to_s[0...-1]] = args.first
-        else
-          value = @attrs[method_id.to_s]
+      private
+        def method_missing(method_id, *args)
+          @defaults ||= Defaults.new
+          @attrs ||= {}
+          if method_id.to_s =~ /=$/
+            @attrs[method_id.to_s[0...-1]] = args.first
+          else
+            value = @attrs[method_id.to_s]
+            if !value && @defaults
+              @defaults.default_for(method_id.to_s)
+            else
+              value
+            end
+          end
         end
-      end
 
-      def load_config_file
-        contents = ""
-        File.open(config_file, "r") { |file| contents << file.read }
-        contents.split("\n").each_with_index do |line, index|
-          pair = line.split("=")
-          if pair.size != 2
-            err("Invalid config file '#{config_file}'. Syntax error at line #{index + 1}")
+        def load_config_file
+          contents = ""
+          File.open(config_file, "r") { |file| contents << file.read }
+          contents.split("\n").each_with_index do |line, index|
+            pair = line.split("=")
+            if pair.size != 2
+              err("Invalid config file '#{config_file}'. Syntax error at line #{index + 1}")
+            end
+            self.send("#{pair[0].strip}=", pair[1].strip)
           end
-          self.send("#{pair[0].strip}=", pair[1].strip)
         end
-      end
 
-      # TODO: This should be moved out to a Validator class
-      def err(message)
-        Log.error(message)
-        exit 1
-      end
+        # TODO: This should be moved out to a Validator class
+        def err(message)
+          STDERR.puts(message)
+          exit 1
+        end
 
-      def subclasses_of(*superclasses) #:nodoc:
-        subclasses = []
-        superclasses.each do |sup|
-          ObjectSpace.each_object(Class) do |k|
-            if superclasses.any? { |superclass| k < superclass } &&
-              (k.name.nil? || k.name.empty? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
-              subclasses << k
+        def subclasses_of(*superclasses) #:nodoc:
+          subclasses = []
+          superclasses.each do |sup|
+            ObjectSpace.each_object(Class) do |k|
+              if superclasses.any? { |superclass| k < superclass } &&
+               	(k.name.nil? || k.name.empty? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+  	            subclasses << k
+              end
             end
+            subclasses.uniq!
           end
-          subclasses.uniq!
+          subclasses
         end
-        subclasses
-      end
+    end
   end
 end

data/lib/svutil/process_manager.rb

@@ -22,6 +22,7 @@ module SVUtil
 
     def start
       begin
+        # TODO: Daemonize will call exit in the main process resulting in an unexpected log entry (even though it forks)
         daemonize if @config.daemon
         write_pid_file
         @server_instance.run

data/test/test_config.rb

@@ -3,7 +3,6 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper.rb')
 class CustomConfig < SVUtil::Config
   defaults do |c|
     c.foo = 'bar'
-    c.manager = 'daniel'
   end
 end
 
@@ -11,75 +10,77 @@ class TestConfig < Test::Unit::TestCase
   include SVUtil
 
   def setup
-    @custom_config = CustomConfig.new
   end
   
   def test_set
-    assert !@custom_config.my_symbol
-    @custom_config.my_symbol = 'abc'
-    assert_equal 'abc', @custom_config.my_symbol
-    @custom_config.my_var = 10
-    assert_equal 10, @custom_config.my_var
+    assert !CustomConfig.my_symbol
+    CustomConfig.my_symbol = 'abc'
+    assert_equal 'abc', CustomConfig.my_symbol
+    CustomConfig.my_var = 10
+    assert_equal 10, CustomConfig.my_var
   end
 
   def test_set_with_block
-    @custom_config.expects(:validate).times(1)
-    @custom_config.set do |c|
+    CustomConfig.expects(:validate).times(1)
+    CustomConfig.set do |c|
       c.another = 'abc'
       c.some_var = 123
       c.foobar = true
     end
-    assert_equal 'abc', @custom_config.another
-    assert_equal 123, @custom_config.some_var
-    assert @custom_config.foobar
+    assert_equal 'abc', CustomConfig.another
+    assert_equal 123, CustomConfig.some_var
+    assert CustomConfig.foobar
   end
 
   def test_standard_cli_options
-    @custom_config = CustomConfig.new
-    @custom_config.expects(:validate).times(1)
-    #@custom_config.option_source = [ "-f", "test/settings", "-d", "-l", "debug", "-T" ]
-    @custom_config.init([ "-f", "test/settings", "-d", "-l", "debug", "-T" ])
-    assert_equal "test/settings", @custom_config.config_file
-    assert_equal "debug", @custom_config.log_file
-    assert @custom_config.daemon
-    assert @custom_config.trace
+    CustomConfig.expects(:validate).times(1)
+    CustomConfig.option_source = [ "-f", "test/settings", "-d", "-l", "debug", "-T" ]
+    CustomConfig.init
+    assert_equal "test/settings", CustomConfig.config_file
+    assert_equal "debug", CustomConfig.log_file
+    assert CustomConfig.daemon
+    assert CustomConfig.trace
   end
 
   def test_config_file
-    @custom_config.expects(:validate).times(1)
-    @custom_config.config_file = "test/settings"
-    @custom_config.init
-    assert_equal 'bar', @custom_config.foo
+    CustomConfig.expects(:validate).times(1)
+    CustomConfig.config_file = "test/settings"
+    CustomConfig.init
+    assert_equal 'bar', CustomConfig.foo
   end
 
   def test_load_config_file
-    @custom_config.expects(:load_config_file).times(1)
-    @custom_config.config_file = "test/settings"
-    @custom_config.init
-    assert_equal 'bar', @custom_config.foo
+    CustomConfig.expects(:load_config_file).times(1)
+    CustomConfig.config_file = "test/settings"
+    CustomConfig.init
+    assert_equal 'bar', CustomConfig.foo
   end
 
   def test_validations_on_cli_with_no_config_file
-    @custom_config.expects(:validate).times(1)
-    @custom_config.config_file = nil
-    @custom_config.init
+    CustomConfig.expects(:validate).times(1)
+    CustomConfig.config_file = nil
+    CustomConfig.init
   end
 
   # Command Line wins!
   def test_file_overide
-    @custom_config.expects(:validate).times(1)
-    @custom_config.config_file = "test/settings"
-    @custom_config.init([ "-l", "logfile_set_on_cli" ])
-    assert_equal "logfile_set_on_cli", @custom_config.log_file
+    CustomConfig.expects(:validate).times(1)
+    CustomConfig.config_file = "test/settings"
+    CustomConfig.option_source = [ "-l", "logfile_set_on_cli" ]
+    CustomConfig.init
+    assert_equal "logfile_set_on_cli", CustomConfig.log_file
   end
 
   def test_defaults
-    assert_equal 'daniel', @custom_config.manager
-    @custom_config.manager = 'james'
-    assert_equal 'james', @custom_config.manager
+    CustomConfig.defaults do |c|
+      c.manager = 'daniel'
+    end
+    assert_equal 'daniel', CustomConfig.manager
+    CustomConfig.manager = 'james'
+    assert_equal 'james', CustomConfig.manager
   end
 
   def test_custom_defaults
-    assert_equal 'bar', @custom_config.foo
+    assert_equal 'bar', CustomConfig.foo
   end
 end

data/test/test_config_handle_options.rb

@@ -15,18 +15,19 @@ class TestConfigHandleOptions < Test::Unit::TestCase
   include SVUtil
 
   def setup
-    @my_config = MyConfig.new
   end
   
   def test_handle_options
-    @my_config.init([ "-P", "foo", "-x", "12345", "-Q" ])
-    assert @my_config.pid_file = "foo"
-    assert @my_config.x = '1234'
-    assert @my_config.restless
+    MyConfig.option_source = [ "-P", "foo", "-x", "12345", "-Q" ]
+    MyConfig.init
+    assert MyConfig.pid_file = "foo"
+    assert MyConfig.x = '1234'
+    assert MyConfig.restless
   end
 
   def test_built_in_options
-    @my_config.init([ "-d", "-P", "foo" ])
-    assert @my_config.daemon
+    MyConfig.option_source = [ "-d", "-P", "foo" ]
+    MyConfig.init
+    assert MyConfig.daemon
   end
 end

data/test/test_process_manager.rb

@@ -13,25 +13,23 @@ class TestProcesManager < Test::Unit::TestCase
     @klass = mock
     @klass.stubs(:new).returns(@instance)
     @klass.stubs(:instance_of?).with(Class).returns(true)
+    ServerConfig.clear_all
   end
   
   def test_initialize
-    config = ServerConfig.new
-    ProcessManager.new(@klass, config)
+    ProcessManager.new(@klass, ServerConfig)
   end
 
   def test_initialize_and_start_with_server_instance
-    config = ServerConfig.new
-    pm = ProcessManager.new(@instance, config)
+    pm = ProcessManager.new(@instance, ServerConfig)
     @instance.expects(:run)
     assert_exit { pm.start }
   end
 
   # TODO: Could probably test this better by actually forking
   def test_start_as_daemon
-    config = ServerConfig.new
-    config.daemon = true
-    pm = ProcessManager.new(@klass, config)
+    ServerConfig.daemon = true
+    pm = ProcessManager.new(@klass, ServerConfig)
     pm.expects(:daemonize)
     pm.expects(:write_pid_file)
     pm.expects(:shutdown)
@@ -40,9 +38,8 @@ class TestProcesManager < Test::Unit::TestCase
   end
 
   def test_start_with_trace
-    config = ServerConfig.new
-    config.trace = true
-    pm = ProcessManager.new(@klass, config)
+    ServerConfig.trace = true
+    pm = ProcessManager.new(@klass, ServerConfig)
     pm.expects(:write_pid_file)
     @instance.expects(:run).raises(Exception)
     Log.expects(:error).times(2)
@@ -50,8 +47,7 @@ class TestProcesManager < Test::Unit::TestCase
   end
 
   def test_shutdown
-    config = ServerConfig.new
-    pm = ProcessManager.new(@klass, config)
+    pm = ProcessManager.new(@klass, ServerConfig)
     pm.expects(:write_pid_file)
     @instance.expects(:run)
     assert_exit { pm.start }
@@ -63,9 +59,8 @@ class TestProcesManager < Test::Unit::TestCase
   end
 
   def test_shutdown_with_trace
-    config = ServerConfig.new
-    config.trace = true
-    pm = ProcessManager.new(@klass, config)
+    ServerConfig.trace = true
+    pm = ProcessManager.new(@klass, ServerConfig)
     pm.expects(:write_pid_file)
     @instance.expects(:run)
     assert_exit { pm.start }
@@ -77,6 +72,5 @@ class TestProcesManager < Test::Unit::TestCase
     assert_exit { pm.send(:shutdown) }
   end
 
-
   # TODO: Test all of the exceptions
 end

data/test/test_validations.rb

@@ -10,18 +10,17 @@ class TestValidations < Test::Unit::TestCase
   include SVUtil
 
   def setup
-    @validated_config = ValidatedConfig.new
   end
   
   def test_custom_validation_error
-    @validated_config.expects(:err).times(1)
-    @validated_config.output_dir = nil
-    @validated_config.validate
+    ValidatedConfig.expects(:err).times(1)
+    ValidatedConfig.output_dir = nil
+    ValidatedConfig.validate
   end
   
   def test_custom_validation
-    @validated_config.expects(:err).never
-    @validated_config.output_dir = "foo"
-    assert @validated_config.validate
+    ValidatedConfig.expects(:err).never
+    ValidatedConfig.output_dir = "foo"
+    assert ValidatedConfig.validate
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: svutil
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-01-04 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: newgem
-  requirement: &70131061952480 !ruby/object:Gem::Requirement
+  requirement: &70183734200680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 1.5.3
   type: :development
   prerelease: false
-  version_requirements: *70131061952480
+  version_requirements: *70183734200680
 - !ruby/object:Gem::Dependency
   name: hoe
-  requirement: &70131061951260 !ruby/object:Gem::Requirement
+  requirement: &70183734199780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.12'
   type: :development
   prerelease: false
-  version_requirements: *70131061951260
+  version_requirements: *70183734199780
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70131057661900 !ruby/object:Gem::Requirement
+  requirement: &70183729865820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +43,7 @@ dependencies:
         version: '3.10'
   type: :development
   prerelease: false
-  version_requirements: *70131057661900
+  version_requirements: *70183729865820
 description: A simple managed process builder for Ruby projects
 email:
 - daniel@netfox.com