sanford 0.11.1 → 0.12.0

data/lib/sanford/cli.rb

@@ -23,7 +23,7 @@ module Sanford
       rescue CLIRB::HelpExit
         @kernel.puts help
       rescue CLIRB::VersionExit
-        @kernel.puts "sanford #{Sanford::VERSION}"
+        @kernel.puts Sanford::VERSION
       rescue CLIRB::Error, Sanford::ConfigFile::InvalidError => exception
         @kernel.puts "#{exception.message}\n\n"
         @kernel.puts help
@@ -40,8 +40,9 @@ module Sanford
 
     def run!(*args)
       @cli.parse!(args)
-      command          = @cli.args.pop || 'run'
-      config_file_path = @cli.args.pop || 'config.sanford'
+      config_file_path, command = @cli.args
+      config_file_path ||= 'config.sanford'
+      command ||= 'run'
       server = Sanford::ConfigFile.new(config_file_path).server
       case(command)
       when 'run'
@@ -58,9 +59,9 @@ module Sanford
     end
 
     def help
-      "Usage: sanford [CONFIG_FILE] [COMMAND]\n" \
-      "Commands: run, start, stop, restart" \
-      "#{@cli}"
+      "Usage: sanford [CONFIG_FILE] [COMMAND] [options]\n\n" \
+      "Commands: run, start, stop, restart\n" \
+      "Options: #{@cli}"
     end
 
   end

data/lib/sanford/route.rb

@@ -17,7 +17,13 @@ module Sanford
     end
 
     def run(request, server_data)
-      SanfordRunner.new(self.handler_class, request, server_data).run
+      SanfordRunner.new(self.handler_class, {
+        :request => request,
+        :params  => request.params,
+        :logger  => server_data.logger,
+        :router  => server_data.router,
+        :template_source => server_data.template_source
+      }).run
     end
 
     private

data/lib/sanford/runner.rb

@@ -1,5 +1,11 @@
+# need to define class immediately b/c of circular requires:
+# - runner -> router -> route -> sanford_runner -> runner
+module Sanford; end
+class Sanford::Runner; end
+
 require 'sanford-protocol'
 require 'sanford/logger'
+require 'sanford/router'
 require 'sanford/template_source'
 
 module Sanford
@@ -9,17 +15,28 @@ module Sanford
     ResponseArgs = Struct.new(:status, :data)
 
     attr_reader :handler_class, :handler
-    attr_reader :request, :params, :logger, :template_source
+    attr_reader :request, :params, :logger, :router, :template_source
 
-    def initialize(handler_class)
+    def initialize(handler_class, args = nil)
       @handler_class = handler_class
       @handler = @handler_class.new(self)
+
+      a = args || {}
+      @request         = a[:request]
+      @params          = a[:params] || {}
+      @logger          = a[:logger] || Sanford::NullLogger.new
+      @router          = a[:router] || Sanford::Router.new
+      @template_source = a[:template_source] || Sanford::NullTemplateSource.new
     end
 
     def run
       raise NotImplementedError
     end
 
+    def render(path, locals = nil)
+      self.template_source.render(path, self.handler, locals || {})
+    end
+
     # It's best to keep what `halt` and `catch_halt` return in the same format.
     # Currently this is a `ResponseArgs` object. This is so no matter how the
     # block returns (either by throwing or running normally), you get the same

data/lib/sanford/sanford_runner.rb

@@ -2,19 +2,7 @@ require 'sanford/runner'
 
 module Sanford
 
-  class SanfordRunner < Sanford::Runner
-
-    def initialize(handler_class, request, server_data)
-      @request         = request
-      @params          = @request.params
-      @logger          = server_data.logger
-      @template_source = server_data.template_source
-
-      super(handler_class)
-    end
-
-    # call the handler init and the handler run - if the init halts, run won't
-    # be called.
+  class SanfordRunner < Runner
 
     def run
       build_response do

data/lib/sanford/server.rb

@@ -172,11 +172,6 @@ module Sanford
         self.configuration.template_source(*args)
       end
 
-      def build_template_source(path, &block)
-        block ||= proc{ }
-        self.template_source TemplateSource.new(path).tap(&block)
-      end
-
     end
 
     class Connection
@@ -266,9 +261,10 @@ module Sanford
 
       def to_hash
         super.merge({
+          :init_procs  => self.init_procs,
           :error_procs => self.error_procs,
-          :routes => self.routes,
-          :template_source => self.template_source
+          :router => self.router,
+          :routes => self.routes
         })
       end
 

data/lib/sanford/server_data.rb

@@ -10,24 +10,29 @@ module Sanford
     attr_reader :name
     attr_reader :ip, :port
     attr_reader :pid_file
-    attr_reader :logger, :verbose_logging
     attr_reader :receives_keep_alive
-    attr_reader :error_procs
-    attr_reader :routes
-    attr_reader :template_source
+    attr_reader :verbose_logging, :logger, :template_source
+    attr_reader :init_procs, :error_procs
+    attr_reader :router, :routes
 
     def initialize(args = nil)
       args ||= {}
-      @name = args[:name]
-      @ip   = args[:ip]
-      @port = args[:port]
+      @name     = args[:name]
+      @ip       = args[:ip]
+      @port     = args[:port]
       @pid_file = args[:pid_file]
-      @logger = args[:logger]
-      @verbose_logging = !!args[:verbose_logging]
+
       @receives_keep_alive = !!args[:receives_keep_alive]
+
+      @verbose_logging = !!args[:verbose_logging]
+      @logger          = args[:logger]
+      @template_source = args[:template_source]
+
+      @init_procs  = args[:init_procs]  || []
       @error_procs = args[:error_procs] || []
+
+      @router = args[:router]
       @routes = build_routes(args[:routes] || [])
-      @template_source = args[:template_source]
     end
 
     def route_for(name)

data/lib/sanford/service_handler.rb

@@ -37,23 +37,18 @@ module Sanford
 
       def inspect
         reference = '0x0%x' % (self.object_id << 1)
-        "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
+        "#<#{self.class}:#{reference} @request=#{request.inspect}>"
       end
 
       private
 
       # Helpers
 
-      def render(path, options = nil)
-        options ||= {}
-        source = options['source'] || @sanford_runner.template_source
-        source.render(path, self, options['locals'] || {})
-      end
-
-      def halt(*args); @sanford_runner.halt(*args); end
-      def request;     @sanford_runner.request;     end
-      def params;      @sanford_runner.params;      end
-      def logger;      @sanford_runner.logger;      end
+      def render(*args); @sanford_runner.render(*args); end
+      def halt(*args);   @sanford_runner.halt(*args);   end
+      def request;       @sanford_runner.request;       end
+      def params;        @sanford_runner.params;        end
+      def logger;        @sanford_runner.logger;        end
 
       def run_callback(callback)
         (self.class.send("#{callback}_callbacks") || []).each do |callback|

data/lib/sanford/template_engine.rb

@@ -1,14 +1,16 @@
 require 'pathname'
+require 'sanford/logger'
 
 module Sanford
 
   class TemplateEngine
 
-    attr_reader :source_path, :opts
+    attr_reader :source_path, :logger, :opts
 
     def initialize(opts = nil)
       @opts = opts || {}
       @source_path = Pathname.new(@opts['source_path'].to_s)
+      @logger = @opts['logger'] || Sanford::NullLogger.new
     end
 
     def render(path, service_handler, locals)

data/lib/sanford/template_source.rb

@@ -1,3 +1,4 @@
+require 'sanford/logger'
 require 'sanford/template_engine'
 
 module Sanford
@@ -10,9 +11,12 @@ module Sanford
 
     attr_reader :path, :engines
 
-    def initialize(path)
+    def initialize(path, logger = nil)
       @path = path.to_s
-      @default_opts = { 'source_path' => @path }
+      @default_opts = {
+        'source_path' => @path,
+        'logger'      => logger || Sanford::NullLogger.new
+      }
       @engines = Hash.new{ |h,k| Sanford::NullTemplateEngine.new(@default_opts) }
     end
 
@@ -25,6 +29,10 @@ module Sanford
       @engines[input_ext.to_s] = engine_class.new(engine_opts)
     end
 
+    def engine_for?(template_name)
+      @engines.keys.include?(get_template_ext(template_name))
+    end
+
     def render(template_path, service_handler, locals)
       engine = @engines[get_template_ext(template_path)]
       engine.render(template_path, service_handler, locals)

data/lib/sanford/test_runner.rb

@@ -1,14 +1,12 @@
 require 'sanford-protocol'
-require 'sanford/logger'
 require 'sanford/runner'
 require 'sanford/service_handler'
-require 'sanford/template_source'
 
 module Sanford
 
   InvalidServiceHandlerError = Class.new(StandardError)
 
-  class TestRunner < Sanford::Runner
+  class TestRunner < Runner
 
     attr_reader :response
 
@@ -17,14 +15,15 @@ module Sanford
         raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a"\
                                           " Sanford::ServiceHandler"
       end
-      args = (args || {}).dup
-      @request         = args.delete(:request)
-      @params          = args.delete(:params) || {}
-      @logger          = args.delete(:logger) || Sanford::NullLogger.new
-      @template_source = args.delete(:template_source) ||
-                         Sanford::NullTemplateSource.new
 
-      super(handler_class)
+      args = (args || {}).dup
+      super(handler_class, {
+        :request => args.delete(:request),
+        :params  => args.delete(:params),
+        :logger  => args.delete(:logger),
+        :router  => args.delete(:router),
+        :template_source => args.delete(:template_source)
+      })
       args.each{ |key, value| @handler.send("#{key}=", value) }
 
       return_value = catch(:halt){ @handler.init; nil }

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

data/sanford.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("dat-tcp",          ["~> 0.5"])
   gem.add_dependency("ns-options",       ["~> 1.1"])
-  gem.add_dependency("sanford-protocol", ["~> 0.9"])
+  gem.add_dependency("sanford-protocol", ["~> 0.10"])
 
-  gem.add_development_dependency("assert", ["~> 2.11"])
+  gem.add_development_dependency("assert", ["~> 2.12"])
 end

data/test/support/app_server.rb

@@ -1,6 +1,6 @@
 require 'pathname'
-require 'sanford'
 require 'sanford-protocol'
+require 'sanford'
 
 if !defined?(ROOT_PATH)
   ROOT_PATH = Pathname.new(File.expand_path('../../..', __FILE__))
@@ -40,8 +40,9 @@ class AppServer
     service 'custom_error', 'CustomError'
   end
 
-  build_template_source ROOT_PATH.join('test/support').to_s do |s|
+  Sanford::TemplateSource.new(ROOT_PATH.join('test/support').to_s).tap do |s|
     s.engine 'erb', AppERBEngine
+    template_source s
   end
 
   error do |exception, server_data, request|

data/test/unit/cli_tests.rb

@@ -1,10 +1,23 @@
 require 'assert'
 require 'sanford/cli'
 
+require 'sanford/server'
+
 class Sanford::CLI
 
   class UnitTests < Assert::Context
     desc "Sanford::CLI"
+    setup do
+      @cli_class = Sanford::CLI
+    end
+    subject{ @cli_class }
+
+    should have_imeths :run
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
     setup do
       @kernel_spy = KernelSpy.new
       @file_path = Factory.file_path
@@ -14,48 +27,43 @@ class Sanford::CLI
       @config_file = FakeConfigFile.new(@server)
       Assert.stub(Sanford::ConfigFile, :new).with(@file_path){ @config_file }
 
+      @process_spy = ProcessSpy.new
+      @process_signal_spy = ProcessSignalSpy.new
+
       @cli = Sanford::CLI.new(@kernel_spy)
     end
     subject{ @cli }
 
-    should have_cmeths :run
     should have_imeths :run
 
   end
 
-  class CommandTests < UnitTests
+  class DefaultsTests < InitTests
     setup do
-      @process_spy = ProcessSpy.new
-      @process_signal_spy = ProcessSignalSpy.new
-    end
-
-  end
-
-  class DefaultsTests < CommandTests
-    desc "with no command or file path"
-    setup do
-      file_path = 'config.sanford'
-      Assert.stub(Sanford::ConfigFile, :new).with(file_path){ @config_file }
+      Assert.stub(Sanford::ConfigFile, :new).with('config.sanford'){ @config_file }
       Assert.stub(Sanford::Process, :new).with(@server, :daemonize => false) do
         @process_spy
       end
+    end
 
-      @cli.run
+    should "default the command when its not provided" do
+      subject.run(@file_path)
+      assert_true @process_spy.run_called
     end
 
-    should "have defaulted the command and file path" do
+    should "default the command and file path when they aren't provided" do
+      subject.run
       assert_true @process_spy.run_called
     end
 
   end
 
-  class RunTests < CommandTests
+  class RunTests < InitTests
     desc "with the run command"
     setup do
       Assert.stub(Sanford::Process, :new).with(@server, :daemonize => false) do
         @process_spy
       end
-
       @cli.run(@file_path, 'run')
     end
 
@@ -65,7 +73,7 @@ class Sanford::CLI
 
   end
 
-  class StartTests < CommandTests
+  class StartTests < InitTests
     desc "with the start command"
     setup do
       Assert.stub(Sanford::Process, :new).with(@server, :daemonize => true) do
@@ -81,7 +89,7 @@ class Sanford::CLI
 
   end
 
-  class StopTests < CommandTests
+  class StopTests < InitTests
     desc "with the stop command"
     setup do
       Assert.stub(Sanford::ProcessSignal, :new).with(@server, 'TERM') do
@@ -97,7 +105,7 @@ class Sanford::CLI
 
   end
 
-  class RestartTests < CommandTests
+  class RestartTests < InitTests
     desc "with the restart command"
     setup do
       Assert.stub(Sanford::ProcessSignal, :new).with(@server, 'USR2') do
@@ -113,7 +121,7 @@ class Sanford::CLI
 
   end
 
-  class InvalidCommandTests < UnitTests
+  class InvalidCommandTests < InitTests
     desc "with an invalid command"
     setup do
       @command = Factory.string

data/test/unit/route_tests.rb

@@ -36,22 +36,32 @@ class Sanford::Route
   class RunTests < UnitTests
     desc "when run"
     setup do
-      @route.validate!
-      @request = Factory.string
-      @server_data = Sanford::ServerData.new
+      @runner_spy = SanfordRunnerSpy.new
+      Assert.stub(Sanford::SanfordRunner, :new) do |*args|
+        @runner_spy.build(*args)
+        @runner_spy
+      end
 
-      @runner_spy = RunnerSpy.new(Factory.text)
-      Assert.stub(Sanford::SanfordRunner, :new).with(
-        @route.handler_class,
-        @request,
-        @server_data
-      ){ @runner_spy }
+      @request = OpenStruct.new('params' => 'some-params')
+      @server_data = Sanford::ServerData.new
 
+      @route.validate!
       @response = @route.run(@request, @server_data)
     end
     subject{ @response }
 
     should "build and run a sanford runner" do
+      assert_equal @route.handler_class, @runner_spy.handler_class
+
+      exp_args = {
+        :request => @request,
+        :params  => @request.params,
+        :logger  => @server_data.logger,
+        :router  => @server_data.router,
+        :template_source => @server_data.template_source
+      }
+      assert_equal exp_args, @runner_spy.args
+
       assert_true @runner_spy.run_called
     end
 
@@ -75,18 +85,34 @@ class Sanford::Route
 
   TestHandler = Class.new
 
-  class RunnerSpy
-    attr_reader :response, :run_called
+  class SanfordRunnerSpy
 
-    def initialize(response)
-      @response = response
+    attr_reader :run_called
+    attr_reader :handler_class, :args
+    attr_reader :request, :params, :logger, :router, :template_source
+    attr_reader :response
+
+    def initialize
       @run_called = false
     end
 
+    def build(handler_class, args)
+      @handler_class, @args = handler_class, args
+
+      @request = args[:request]
+      @params  = args[:params]
+      @logger  = args[:logger]
+      @router  = args[:router]
+      @template_source = args[:template_source]
+
+      @response = Factory.string
+    end
+
     def run
       @run_called = true
       @response
     end
+
   end
 
 end

data/test/unit/runner_tests.rb

@@ -1,7 +1,9 @@
 require 'assert'
 require 'sanford/runner'
 
-require 'sanford/server_data'
+require 'sanford/logger'
+require 'sanford/router'
+require 'sanford/template_source'
 require 'sanford/service_handler'
 
 class Sanford::Runner
@@ -10,7 +12,6 @@ class Sanford::Runner
     desc "Sanford::Runner"
     setup do
       @handler_class = TestServiceHandler
-
       @runner_class = Sanford::Runner
     end
     subject{ @runner_class }
@@ -20,12 +21,13 @@ class Sanford::Runner
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @runner = @runner_class.new(@handler_class)
+      source = FakeTemplateSource.new
+      @runner = @runner_class.new(@handler_class, :template_source => source)
     end
     subject{ @runner }
 
     should have_readers :handler_class, :handler
-    should have_readers :request, :params, :logger, :template_source
+    should have_readers :request, :params, :logger, :router, :template_source
     should have_imeths :run
     should have_imeths :halt
 
@@ -34,11 +36,30 @@ class Sanford::Runner
       assert_instance_of @handler_class, subject.handler
     end
 
-    should "not set its request, params, logger or template source" do
-      assert_nil subject.request
-      assert_nil subject.params
-      assert_nil subject.logger
-      assert_nil subject.template_source
+    should "default its settings" do
+      runner = @runner_class.new(@handler_class)
+      assert_nil runner.request
+      assert_equal ::Hash.new, runner.params
+      assert_kind_of Sanford::NullLogger, runner.logger
+      assert_kind_of Sanford::Router, runner.router
+      assert_kind_of Sanford::NullTemplateSource, runner.template_source
+    end
+
+    should "not implement its run method" do
+      assert_raises(NotImplementedError){ subject.run }
+    end
+
+    should "use the template source to render" do
+      path = 'template.json'
+      locals = { 'something' => Factory.string }
+      exp = subject.template_source.render(path, subject.handler, locals)
+      assert_equal exp, subject.render(path, locals)
+    end
+
+    should "default its locals to an empty hash when rendering" do
+      path = Factory.file_path
+      exp = subject.template_source.render(path, subject.handler, {})
+      assert_equal exp, subject.render(path)
     end
 
     should "throw halt with response args using `halt`" do
@@ -67,14 +88,16 @@ class Sanford::Runner
       assert_equal data, result.data
     end
 
-    should "raise a not implemented error when run" do
-      assert_raises(NotImplementedError){ subject.run }
-    end
-
   end
 
   class TestServiceHandler
     include Sanford::ServiceHandler
   end
 
+  class FakeTemplateSource
+    def render(path, service_handler, locals)
+      [path.to_s, service_handler.class.to_s, locals]
+    end
+  end
+
 end

data/test/unit/sanford_runner_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'sanford/sanford_runner'
 
-require 'sanford/server_data'
+require 'sanford/runner'
 require 'sanford/service_handler'
 
 class Sanford::SanfordRunner
@@ -10,14 +10,6 @@ class Sanford::SanfordRunner
     desc "Sanford::SanfordRunner"
     setup do
       @handler_class = TestServiceHandler
-      @request = Sanford::Protocol::Request.new(Factory.string, {
-        :something => Factory.string
-      })
-      @server_data = Sanford::ServerData.new({
-        :logger => Factory.string,
-        :template_source => Factory.string
-      })
-
       @runner_class = Sanford::SanfordRunner
     end
     subject{ @runner_class }
@@ -31,16 +23,11 @@ class Sanford::SanfordRunner
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @runner = @runner_class.new(@handler_class, @request, @server_data)
+      @runner = @runner_class.new(@handler_class)
     end
     subject{ @runner }
 
-    should "know its request, params, logger and template source" do
-      assert_equal @request, subject.request
-      assert_equal @request.params, subject.params
-      assert_equal @server_data.logger, subject.logger
-      assert_equal @server_data.template_source, subject.template_source
-    end
+    should have_imeths :run
 
   end
 
@@ -77,8 +64,9 @@ class Sanford::SanfordRunner
   class RunHaltInBeforeTests < UnitTests
     desc "running a handler that halts in a before callback"
     setup do
-      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'before')
-      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'before'
+      }).tap(&:run)
       @handler = runner.handler
     end
     subject{ @handler }
@@ -97,8 +85,9 @@ class Sanford::SanfordRunner
   class RunHandlerHaltInitTests < UnitTests
     desc "running a handler that halts in init"
     setup do
-      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'init')
-      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'init'
+      }).tap(&:run)
       @handler = runner.handler
     end
     subject{ @handler }
@@ -117,8 +106,9 @@ class Sanford::SanfordRunner
   class RunHandlerHaltRunTests < UnitTests
     desc "running a handler that halts in run"
     setup do
-      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'run')
-      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'run'
+      }).tap(&:run)
       @handler = runner.handler
     end
     subject{ @handler }
@@ -137,8 +127,9 @@ class Sanford::SanfordRunner
   class RunHandlerHaltAfterTests < UnitTests
     desc "running a handler that halts in a after callback"
     setup do
-      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'after')
-      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'after'
+      }).tap(&:run)
       @handler = runner.handler
     end
     subject{ @handler }
@@ -162,23 +153,13 @@ class Sanford::SanfordRunner
     attr_reader :init_call_order, :run_call_order
     attr_reader :response_data
 
-    before do
-      @first_before_call_order = next_call_order
-      halt_if('before')
-    end
+    before{ @first_before_call_order = next_call_order; halt_if('before') }
     before{ @second_before_call_order = next_call_order }
 
-    after do
-      @first_after_call_order = next_call_order
-      halt_if('after')
-    end
+    after{ @first_after_call_order = next_call_order; halt_if('after') }
     after{ @second_after_call_order = next_call_order }
 
-    def init!
-      @init_call_order = next_call_order
-      halt_if('init')
-    end
-
+    def init!; @init_call_order = next_call_order; halt_if('init'); end
     def run!
       @run_call_order = next_call_order
       halt_if('run')
@@ -187,11 +168,7 @@ class Sanford::SanfordRunner
 
     private
 
-    def next_call_order
-      @order ||= 0
-      @order += 1
-    end
-
+    def next_call_order; @order ||= 0; @order += 1; end
     def halt_if(value)
       halt Factory.integer if params['halt'] == value
     end

data/test/unit/server_data_tests.rb

@@ -8,25 +8,35 @@ class Sanford::ServerData
   class UnitTests < Assert::Context
     desc "Sanford::ServerData"
     setup do
-      @name = Factory.string
-      @ip = Factory.string
-      @port = Factory.integer
+      @name     = Factory.string
+      @ip       = Factory.string
+      @port     = Factory.integer
       @pid_file = Factory.file_path
-      @logger = Factory.string
-      @verbose_logging = Factory.boolean
+
       @receives_keep_alive = Factory.boolean
-      @error_procs = [ proc{ } ]
-      @route = Sanford::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
+
+      @verbose_logging = Factory.boolean
+      @logger          = Factory.string
+      @template_source = Factory.string
+
+      @init_procs  = [ proc{} ]
+      @error_procs = [ proc{} ]
+
+      @router = Factory.string
+      @route  = Sanford::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
 
       @server_data = Sanford::ServerData.new({
-        :name => @name,
-        :ip => @ip,
-        :port => @port,
+        :name     => @name,
+        :ip       => @ip,
+        :port     => @port,
         :pid_file => @pid_file,
-        :logger => @logger,
-        :verbose_logging => @verbose_logging,
         :receives_keep_alive => @receives_keep_alive,
+        :verbose_logging => @verbose_logging,
+        :logger          => @logger,
+        :template_source => @template_source,
+        :init_procs  => @init_procs,
         :error_procs => @error_procs,
+        :router => @router,
         :routes => [ @route ]
       })
     end
@@ -35,20 +45,27 @@ class Sanford::ServerData
     should have_readers :name
     should have_readers :ip, :port
     should have_readers :pid_file
-    should have_readers :logger, :verbose_logging
     should have_readers :receives_keep_alive
-    should have_readers :error_procs
-    should have_readers :routes
+    should have_readers :verbose_logging, :logger, :template_source
+    should have_readers :init_procs, :error_procs
+    should have_readers :router, :routes
 
     should "know its attributes" do
-      assert_equal @name, subject.name
-      assert_equal @ip, subject.ip
-      assert_equal @port, subject.port
+      assert_equal @name,     subject.name
+      assert_equal @ip,       subject.ip
+      assert_equal @port,     subject.port
       assert_equal @pid_file, subject.pid_file
-      assert_equal @logger, subject.logger
-      assert_equal @verbose_logging, subject.verbose_logging
+
       assert_equal @receives_keep_alive, subject.receives_keep_alive
+
+      assert_equal @verbose_logging, subject.verbose_logging
+      assert_equal @logger,          subject.logger
+      assert_equal @template_source, subject.template_source
+
+      assert_equal @init_procs,  subject.error_procs
       assert_equal @error_procs, subject.error_procs
+
+      assert_equal @router, subject.router
     end
 
     should "build a routes lookup hash" do
@@ -73,10 +90,17 @@ class Sanford::ServerData
       assert_nil server_data.ip
       assert_nil server_data.port
       assert_nil server_data.pid_file
-      assert_nil server_data.logger
-      assert_false server_data.verbose_logging
+
       assert_false server_data.receives_keep_alive
+
+      assert_false server_data.verbose_logging
+      assert_nil   server_data.logger
+      assert_nil   server_data.template_source
+
+      assert_equal [], server_data.init_procs
       assert_equal [], server_data.error_procs
+
+      assert_nil       server_data.router
       assert_equal({}, server_data.routes)
     end
 

data/test/unit/server_tests.rb

@@ -23,8 +23,7 @@ module Sanford::Server
     should have_imeths :receives_keep_alive
     should have_imeths :verbose_logging, :logger
     should have_imeths :init, :error
-    should have_imeths :router
-    should have_imeths :template_source, :build_template_source
+    should have_imeths :router, :template_source
 
     should "know its configuration" do
       config = subject.configuration
@@ -117,20 +116,6 @@ module Sanford::Server
       assert_equal new_template_source, subject.template_source
     end
 
-    should "allow setting its template source with a path and block" do
-      new_path = Factory.string
-      yielded = nil
-      subject.build_template_source(new_path){ |s| yielded = s }
-      assert_equal new_path, subject.configuration.template_source.path
-      assert_equal subject.configuration.template_source, yielded
-    end
-
-    should "allow setting its template source with only a path" do
-      new_path = Factory.string
-      subject.build_template_source(new_path)
-      assert_equal new_path, subject.configuration.template_source.path
-    end
-
   end
 
   class InitTests < UnitTests
@@ -448,13 +433,12 @@ module Sanford::Server
       assert_equal subject.router.routes, subject.routes
     end
 
-    should "include its routes, error procs and template source in its hash" do
+    should "include its init/error procs and router/routes in its `to_hash`" do
       config_hash = subject.to_hash
+      assert_equal subject.init_procs, config_hash[:init_procs]
       assert_equal subject.error_procs, config_hash[:error_procs]
+      assert_equal subject.router, config_hash[:router]
       assert_equal subject.routes, config_hash[:routes]
-      template_source = subject.template_source
-      assert_instance_of template_source.class, config_hash[:template_source]
-      assert_equal template_source.path, config_hash[:template_source].path
     end
 
     should "call its init procs when validated" do

data/test/unit/service_handler_tests.rb

@@ -144,9 +144,9 @@ module Sanford::ServiceHandler
     should have_imeths :init, :init!, :run, :run!
 
     should "know its request, params and logger" do
-      assert_equal @runner.request, subject.request
-      assert_equal @runner.params, subject.params
-      assert_equal @runner.logger, subject.logger
+      assert_equal @runner.request, subject.public_request
+      assert_equal @runner.params,  subject.public_params
+      assert_equal @runner.logger,  subject.public_logger
     end
 
     should "call `init!` and its before/after init callbacks using `init`" do
@@ -170,36 +170,21 @@ module Sanford::ServiceHandler
     should "have a custom inspect" do
       reference = '0x0%x' % (subject.object_id << 1)
       expected = "#<#{subject.class}:#{reference} " \
-                 "@request=#{subject.request.inspect}>"
+                 "@request=#{@runner.request.inspect}>"
       assert_equal expected, subject.inspect
     end
 
-    should "demeter its runner's halt" do
-      code = Factory.integer
-      result = subject.halt(code)
-      assert_includes [ code ], @runner.halt_calls
-    end
-
-    should "use the runner template source to render the template by default" do
+    should "delegate its runner's `render` method" do
       path = Factory.file_path
       locals = { 'something' => Factory.string }
-      result = subject.render(path, 'locals' => locals)
-      assert_equal [ path, TestServiceHandler.to_s, locals ], result
-    end
-
-    should "default its locals to an empty hash using `render`" do
-      path = Factory.file_path
-      result = subject.render(path)
-      assert_equal [ path, TestServiceHandler.to_s, {} ], result
+      result = subject.render(path, locals)
+      assert_equal [path, locals], @runner.render_calls.last
     end
 
-    should "allow passing a source to its options using `render`" do
-      path = Factory.file_path
-      source_class = Class.new do
-        def render(path, service_handler, locals); path; end
-      end
-      result = subject.render(path, 'source' => source_class.new)
-      assert_equal path, result
+    should "delegate its runner's `halt` method" do
+      code = Factory.integer
+      result = subject.halt(code)
+      assert_equal [code], @runner.halt_calls.last
     end
 
     should "raise a not implemented error when `run!` by default" do
@@ -220,7 +205,7 @@ module Sanford::ServiceHandler
     # these methods are made public so they can be tested, they are being tested
     # because they are used by classes that mixin this, essentially they are
     # "public" to classes that use the mixin
-    public :render, :halt, :request, :params, :logger
+    public :render, :halt
 
     before_init{ @first_before_init_call_order = next_call_order }
     before_init{ @second_before_init_call_order = next_call_order }
@@ -242,6 +227,18 @@ module Sanford::ServiceHandler
       @run_call_order = next_call_order
     end
 
+    def public_request
+      request
+    end
+
+    def public_params
+      params
+    end
+
+    def public_logger
+      logger
+    end
+
     private
 
     def next_call_order
@@ -251,26 +248,17 @@ module Sanford::ServiceHandler
   end
 
   class FakeRunner
-    attr_accessor :request, :params, :logger, :template_source
-    attr_reader :halt_calls
+    attr_accessor :request, :params, :logger
+    attr_reader :render_calls, :halt_calls
 
     def initialize
       @request = Factory.string
       @params = Factory.string
       @logger = Factory.string
-      @template_source = FakeTemplateSource.new
     end
 
-    def halt(*args)
-      @halt_calls ||= []
-      @halt_calls << args
-    end
-  end
-
-  class FakeTemplateSource
-    def render(path, service_handler, locals)
-      [path.to_s, service_handler.class.to_s, locals]
-    end
+    def render(*args); @render_calls ||= []; @render_calls << args; end
+    def halt(*args);   @halt_calls   ||= []; @halt_calls   << args; end
   end
 
 end

data/test/unit/template_engine_tests.rb

@@ -2,6 +2,7 @@ require 'assert'
 require 'sanford/template_engine'
 
 require 'pathname'
+require 'sanford/logger'
 require 'test/support/factory'
 
 class Sanford::TemplateEngine
@@ -17,7 +18,7 @@ class Sanford::TemplateEngine
     end
     subject{ @engine }
 
-    should have_readers :source_path, :opts
+    should have_readers :source_path, :logger, :opts
     should have_imeths :render
 
     should "default its source path" do
@@ -29,6 +30,16 @@ class Sanford::TemplateEngine
       assert_equal Pathname.new(@source_path.to_s), engine.source_path
     end
 
+    should "default its logger" do
+      assert_instance_of Sanford::NullLogger, subject.logger
+    end
+
+    should "allow custom loggers" do
+      logger = 'a-logger'
+      engine = Sanford::TemplateEngine.new('logger' => logger)
+      assert_equal logger, engine.logger
+    end
+
     should "default the opts if none given" do
       exp_opts = {}
       assert_equal exp_opts, Sanford::TemplateEngine.new.opts

data/test/unit/template_source_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'sanford/template_source'
 
+require 'sanford/logger'
 require 'sanford/template_engine'
 
 class Sanford::TemplateSource
@@ -19,12 +20,13 @@ class Sanford::TemplateSource
   class InitTests < Assert::Context
     setup do
       @source_path = ROOT_PATH.join('test/support').to_s
-      @source = Sanford::TemplateSource.new(@source_path)
+      @logger = 'a-logger'
+      @source = Sanford::TemplateSource.new(@source_path, @logger)
     end
     subject{ @source }
 
     should have_readers :path, :engines
-    should have_imeths :engine, :render
+    should have_imeths :engine, :engine_for?, :render
 
     should "know its path" do
       assert_equal @source_path.to_s, subject.path
@@ -44,20 +46,34 @@ class Sanford::TemplateSource
       assert_kind_of @test_engine, subject.engines['test']
     end
 
-    should "register with the source path as a default option" do
+    should "register with default options" do
       subject.engine 'test', @test_engine
-      exp_opts = { 'source_path' => subject.path }
+      exp_opts = {
+        'source_path' => subject.path,
+        'logger'      => @logger
+      }
       assert_equal exp_opts, subject.engines['test'].opts
 
+      source = Sanford::TemplateSource.new(@source_path)
+      source.engine 'test', @test_engine
+      assert_kind_of Sanford::NullLogger, source.engines['test'].opts['logger']
+
       subject.engine 'test', @test_engine, 'an' => 'opt'
       exp_opts = {
         'source_path' => subject.path,
-        'an' => 'opt'
+        'logger'      => @logger,
+        'an'          => 'opt'
       }
       assert_equal exp_opts, subject.engines['test'].opts
 
-      subject.engine 'test', @test_engine, 'source_path' => 'something'
-      exp_opts = { 'source_path' => 'something' }
+      subject.engine('test', @test_engine, {
+        'source_path' => 'something',
+        'logger'      => 'another'
+      })
+      exp_opts = {
+        'source_path' => 'something',
+        'logger'      => 'another'
+      }
       assert_equal exp_opts, subject.engines['test'].opts
     end
 
@@ -69,6 +85,13 @@ class Sanford::TemplateSource
       assert_kind_of Sanford::NullTemplateEngine, subject.engines['rb']
     end
 
+    should "know if it has an engine registered for a given template name" do
+      assert_false subject.engine_for?('test_template')
+
+      subject.engine 'test', @test_engine
+      assert_true subject.engine_for?('test_template')
+    end
+
   end
 
   class RenderTests < InitTests

data/test/unit/test_runner_tests.rb

@@ -7,12 +7,6 @@ class Sanford::TestRunner
     desc "Sanford::TestRunner"
     setup do
       @handler_class = TestServiceHandler
-      @request = Sanford::Protocol::Request.new(Factory.string, {})
-      @params = { :something => Factory.string }
-      @logger = Factory.string
-      @template_source = Factory.string
-      @handler_flag = Factory.boolean
-
       @runner_class = Sanford::TestRunner
     end
     subject{ @runner_class }
@@ -26,12 +20,13 @@ class Sanford::TestRunner
   class InitTests < UnitTests
     desc "when init"
     setup do
+      @params = { Factory.string => Factory.integer }
       @args = {
-        :request => @request,
-        :params => @params,
-        :logger => @logger,
-        :template_source => @template_source,
-        :flag => @handler_flag
+        :request => 'a-request',
+        :params  => @params,
+        :logger  => 'a-logger',
+        :router  => 'a-router',
+        :template_source => 'a-source'
       }
       @runner = @runner_class.new(@handler_class, @args)
     end
@@ -40,31 +35,23 @@ class Sanford::TestRunner
     should have_readers :response
     should have_imeths :run
 
-    should "know its attributes" do
-      assert_equal @request, subject.request
-      assert_equal @params, subject.params
-      assert_equal @logger, subject.logger
-      assert_equal @template_source, subject.template_source
-    end
-
-    should "write extra args to its service handler" do
-      assert_equal @handler_flag, subject.handler.flag
+    should "raise an invalid error when not passed a service handler" do
+      assert_raises(Sanford::InvalidServiceHandlerError) do
+        @runner_class.new(Class.new)
+      end
     end
 
-    should "not alter the args passed to it" do
-      assert_equal @request, @args[:request]
-      assert_equal @params, @args[:params]
-      assert_equal @logger, @args[:logger]
-      assert_equal @template_source, @args[:template_source]
-      assert_equal @handler_flag, @args[:flag]
+    should "super its standard attributes" do
+      assert_equal 'a-request',  subject.request
+      assert_equal @params,      subject.params
+      assert_equal 'a-logger',   subject.logger
+      assert_equal 'a-router',   subject.router
+      assert_equal 'a-source',   subject.template_source
     end
 
-    should "default its request, logger, params and template source" do
-      test_runner = @runner_class.new(@handler_class)
-      assert_nil test_runner.request
-      assert_equal({}, test_runner.params)
-      assert_instance_of Sanford::NullLogger, test_runner.logger
-      assert_instance_of Sanford::NullTemplateSource, test_runner.template_source
+    should "write any non-standard args on the handler" do
+      runner = @runner_class.new(@handler_class, :custom_value => 42)
+      assert_equal 42, runner.handler.custom_value
     end
 
     should "not have called its service handlers before callbacks" do
@@ -79,12 +66,6 @@ class Sanford::TestRunner
       assert_nil subject.response
     end
 
-    should "raise an invalid error when not passed a service handler" do
-      assert_raises(Sanford::InvalidServiceHandlerError) do
-        @runner_class.new(Class.new)
-      end
-    end
-
   end
 
   class RunTests < InitTests
@@ -169,7 +150,7 @@ class Sanford::TestRunner
 
     attr_reader :before_called, :after_called
     attr_reader :init_called, :run_called
-    attr_accessor :flag, :response
+    attr_accessor :custom_value, :response
 
     before{ @before_called = true }
     after{ @after_called = true }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sanford
 version: !ruby/object:Gem::Version 
-  hash: 49
+  hash: 47
   prerelease: 
   segments: 
   - 0
-  - 11
-  - 1
-  version: 0.11.1
+  - 12
+  - 0
+  version: 0.12.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-06-30 00:00:00 Z
+date: 2014-12-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -29,9 +29,9 @@ dependencies:
         - 0
         - 5
         version: "0.5"
-  version_requirements: *id001
   type: :runtime
   name: dat-tcp
+  version_requirements: *id001
   prerelease: false
 - !ruby/object:Gem::Dependency 
   requirement: &id002 !ruby/object:Gem::Requirement 
@@ -44,9 +44,9 @@ dependencies:
         - 1
         - 1
         version: "1.1"
-  version_requirements: *id002
   type: :runtime
   name: ns-options
+  version_requirements: *id002
   prerelease: false
 - !ruby/object:Gem::Dependency 
   requirement: &id003 !ruby/object:Gem::Requirement 
@@ -54,14 +54,14 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 25
+        hash: 31
         segments: 
         - 0
-        - 9
-        version: "0.9"
-  version_requirements: *id003
+        - 10
+        version: "0.10"
   type: :runtime
   name: sanford-protocol
+  version_requirements: *id003
   prerelease: false
 - !ruby/object:Gem::Dependency 
   requirement: &id004 !ruby/object:Gem::Requirement 
@@ -69,14 +69,14 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 21
+        hash: 27
         segments: 
         - 2
-        - 11
-        version: "2.11"
-  version_requirements: *id004
+        - 12
+        version: "2.12"
   type: :development
   name: assert
+  version_requirements: *id004
   prerelease: false
 description: Sanford TCP protocol server for hosting services
 email: 
@@ -184,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.29
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Sanford TCP protocol server for hosting services