sanford 0.9.0 → 0.10.0

data/Gemfile

@@ -5,5 +5,4 @@ gemspec
 gem 'rake'
 gem 'pry'
 
-gem 'bson'
-gem 'bson_ext', '~>1.7'
+gem 'bson_ext'

data/lib/sanford/config.rb

@@ -0,0 +1,28 @@
+require 'ns-options'
+require 'pathname'
+require 'sanford/logger'
+require 'sanford/runner'
+require 'sanford/template_source'
+
+module Sanford
+
+  class Config
+    include NsOptions::Proxy
+
+    option :services_file,  Pathname, :default => proc{ ENV['SANFORD_SERVICES_FILE'] }
+    option :logger,                   :default => proc{ Sanford::NullLogger.new }
+
+    attr_reader :template_source
+
+    def initialize
+      super
+      @template_source = NullTemplateSource.new
+    end
+
+    def set_template_source(path, &block)
+      @template_source = TemplateSource.new(path).tap{ |s| block.call(s) if block }
+    end
+
+  end
+
+end

data/lib/sanford/host.rb

@@ -25,7 +25,6 @@ module Sanford
       option :logger,                       :default => proc{ Sanford.config.logger }
       option :verbose_logging,              :default => true
       option :receives_keep_alive,          :default => false
-      option :runner,                       :default => proc{ Sanford.config.runner }
       option :error_procs,         Array,   :default => []
       option :init_procs,          Array,   :default => []
 
@@ -79,10 +78,6 @@ module Sanford
       self.configuration.receives_keep_alive *args
     end
 
-    def runner(*args)
-      self.configuration.runner *args
-    end
-
     def error(&block)
       self.configuration.error_procs << block
     end
@@ -111,7 +106,7 @@ module Sanford
 
     module ClassMethods
 
-      # the class level of a `Host` should just proxy it's methods down to it's
+      # the class level of a `Host` should just proxy its methods down to its
       # instance (it's a `Singleton`)
 
       # `name` is defined by all objects, so we can't rely on `method_missing`

data/lib/sanford/host_data.rb

@@ -1,4 +1,5 @@
 require 'sanford/service_handler'
+require 'sanford/sanford_runner'
 
 module Sanford
 
@@ -12,7 +13,7 @@ module Sanford
     # NOTE: The `name` attribute shouldn't be removed, it is used to identify
     # a `HostData`, particularly in error handlers
 
-    attr_reader :name, :logger, :verbose, :keep_alive, :runner, :error_procs
+    attr_reader :name, :logger, :verbose, :keep_alive, :error_procs
 
     def initialize(service_host, options = nil)
       service_host.configuration.init_procs.each(&:call)
@@ -24,7 +25,6 @@ module Sanford
       @logger      = configuration[:logger]
       @verbose     = configuration[:verbose_logging]
       @keep_alive  = configuration[:receives_keep_alive]
-      @runner      = configuration[:runner]
       @error_procs = configuration[:error_procs]
 
       @handlers = service_host.services.inject({}) do |h, (name, handler_class_name)|
@@ -37,7 +37,7 @@ module Sanford
     end
 
     def run(handler_class, request)
-      self.runner.new(handler_class, request, self.logger).run
+      SanfordRunner.new(handler_class, request, self.logger).run
     end
 
     protected

data/lib/sanford/hosts.rb

@@ -0,0 +1,38 @@
+require 'set'
+require 'sanford/host'
+
+module Sanford
+
+  class Hosts
+
+    def initialize(values = [])
+      @set = Set.new(values)
+    end
+
+    def method_missing(method, *args, &block)
+      @set.send(method, *args, &block)
+    end
+
+    def respond_to?(method)
+      super || @set.respond_to?(method)
+    end
+
+    # We want class names to take precedence over a configured name, so that if
+    # a user specifies a specific class, they always get it
+    def find(name)
+      find_by_class_name(name) || find_by_name(name)
+    end
+
+    private
+
+    def find_by_class_name(class_name)
+      @set.detect{|host_class| host_class.to_s == class_name.to_s }
+    end
+
+    def find_by_name(name)
+      @set.detect{|host_class| host_class.name == name.to_s }
+    end
+
+  end
+
+end

data/lib/sanford/runner.rb

@@ -16,7 +16,7 @@ module Sanford
 
     module InstanceMethods
 
-      attr_reader :handler_class, :request, :logger
+      attr_reader :handler_class, :request, :logger, :handler
 
       def initialize(handler_class, request, logger = nil)
         @handler_class, @request = handler_class, request
@@ -33,8 +33,7 @@ module Sanford
       end
 
       def run
-        response_args = catch_halt{ self.run!(@handler) }
-        Sanford::Protocol::Response.new(response_args.status, response_args.data)
+        build_response catch_halt{ self.run! }
       end
 
       def run!
@@ -56,6 +55,12 @@ module Sanford
         catch(:halt){ ResponseArgs.new(*block.call) }
       end
 
+      protected
+
+      def build_response(args)
+        Sanford::Protocol::Response.new(args.status, args.data) if args
+      end
+
     end
 
     module ClassMethods
@@ -69,14 +74,4 @@ module Sanford
 
   end
 
-  class DefaultRunner
-    include Sanford::Runner
-
-    def run!(handler)
-      handler.init
-      handler.run
-    end
-
-  end
-
 end

data/lib/sanford/sanford_runner.rb

@@ -0,0 +1,27 @@
+require 'sanford/runner'
+
+module Sanford
+
+  class SanfordRunner
+    include Sanford::Runner
+
+    # call the handler init and the handler run - if the init halts, run won't
+    # be called.
+
+    def run!
+      run_callbacks self.handler_class.before_callbacks
+      self.handler.init
+      response_args = self.handler.run
+      run_callbacks self.handler_class.after_callbacks
+      response_args
+    end
+
+    private
+
+    def run_callbacks(callbacks)
+      callbacks.each{|proc| self.handler.instance_eval(&proc) }
+    end
+
+  end
+
+end

data/lib/sanford/server.rb

@@ -89,7 +89,7 @@ module Sanford
       # packetizes our stream. This improves both latency and throughput.
       # TCP_CORK disables Nagle's algorithm, which is ideal for sporadic
       # traffic (like Telnet) but is less optimal for HTTP. Sanford is similar
-      # to HTTP, it doesn't receive sporadic packets, it has all it's data
+      # to HTTP, it doesn't receive sporadic packets, it has all its data
       # come in at once.
       # For more information: http://baus.net/on-tcp_cork
 

data/lib/sanford/service_handler.rb

@@ -54,6 +54,15 @@ module Sanford
 
       # Helpers
 
+      def render(path, options = nil)
+        options ||= {}
+        get_engine(path, options['source'] || Sanford.config.template_source).render(
+          path,
+          self,
+          options['locals'] || {}
+        )
+      end
+
       def run_handler(handler_class, params = nil)
         handler_class.run(params || {}, self.logger)
       end
@@ -69,23 +78,40 @@ module Sanford
         end
       end
 
+      private
+
+      def get_engine(path, source)
+        source.engines[File.extname(get_template(path, source))[1..-1] || '']
+      end
+
+      def get_template(path, source)
+        Dir.glob("#{Pathname.new(source.path).join(path.to_s)}.*").first.to_s
+      end
+
     end
 
     module ClassMethods
 
       def run(params = nil, logger = nil)
-        Sanford.config.runner.run(self, params || {}, logger)
+        SanfordRunner.run(self, params || {}, logger)
       end
 
+      def before_callbacks;      @before_callbacks      ||= []; end
+      def after_callbacks;       @after_callbacks       ||= []; end
       def before_init_callbacks; @before_init_callbacks ||= []; end
       def after_init_callbacks;  @after_init_callbacks  ||= []; end
       def before_run_callbacks;  @before_run_callbacks  ||= []; end
       def after_run_callbacks;   @after_run_callbacks   ||= []; end
 
+      def before(&block);      self.before_callbacks      << block; end
+      def after(&block);       self.after_callbacks       << block; end
       def before_init(&block); self.before_init_callbacks << block; end
       def after_init(&block);  self.after_init_callbacks  << block; end
       def before_run(&block);  self.before_run_callbacks  << block; end
       def after_run(&block);   self.after_run_callbacks   << block; end
+
+      def prepend_before(&block);      self.before_callbacks.unshift(block);      end
+      def prepend_after(&block);       self.after_callbacks.unshift(block);       end
       def prepend_before_init(&block); self.before_init_callbacks.unshift(block); end
       def prepend_after_init(&block);  self.after_init_callbacks.unshift(block);  end
       def prepend_before_run(&block);  self.before_run_callbacks.unshift(block);  end

data/lib/sanford/template_engine.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+
+module Sanford
+
+  class TemplateEngine
+
+    attr_reader :source_path, :opts
+
+    def initialize(opts = nil)
+      @opts = opts || {}
+      @source_path = Pathname.new(@opts['source_path'].to_s)
+    end
+
+    def render(path, service_handler, locals)
+      raise NotImplementedError
+    end
+
+  end
+
+  class NullTemplateEngine < TemplateEngine
+
+    def render(path, service_handler, locals)
+      template_file = self.source_path.join(path).to_s
+      unless File.exists?(template_file)
+        raise ArgumentError, "template file `#{template_file}` does not exist"
+      end
+      File.read(template_file)
+    end
+
+  end
+
+end

data/lib/sanford/template_source.rb

@@ -0,0 +1,30 @@
+require 'sanford/template_engine'
+
+module Sanford
+
+  class TemplateSource
+
+    attr_reader :path, :engines
+
+    def initialize(path)
+      @path = path.to_s
+      @default_opts = { 'source_path' => @path }
+      @engines = Hash.new{ |h,k| Sanford::NullTemplateEngine.new(@default_opts) }
+    end
+
+    def engine(input_ext, engine_class, registered_opts = nil)
+      engine_opts = @default_opts.merge(registered_opts || {})
+      @engines[input_ext.to_s] = engine_class.new(engine_opts)
+    end
+
+  end
+
+  class NullTemplateSource < TemplateSource
+
+    def initialize
+      super('')
+    end
+
+  end
+
+end

data/lib/sanford/test_runner.rb

@@ -9,20 +9,18 @@ module Sanford
   class TestRunner
     include Sanford::Runner
 
-    attr_reader :handler, :response
+    attr_reader :response
 
-    def initialize(handler_class, *args)
+    def initialize(handler_class, request_or_params, *args)
       if !handler_class.include?(Sanford::ServiceHandler)
         raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a"\
                                           " Sanford::ServiceHandler"
       end
-      super
+
+      super handler_class, build_request(request_or_params), *args
     end
 
     def init!
-      if !@request.kind_of?(Sanford::Protocol::Request)
-        @request = test_request(@request)
-      end
       @response = build_response catch(:halt){ @handler.init; nil }
     end
 
@@ -31,21 +29,25 @@ module Sanford
     # want to `run` at all.
 
     def run
-      @response ||= build_response(catch_halt{ @handler.run }).tap do |response|
+      @response ||= super.tap do |response|
         # attempt to serialize (and then throw away) the response data
         # this will error on the developer if BSON can't serialize their response
         Sanford::Protocol::BsonBody.new.encode(response.to_hash)
       end
     end
 
-    protected
+    def run!
+      self.handler.run
+    end
 
-    def test_request(params)
-      Sanford::Protocol::Request.new('name', params || {})
+    private
+
+    def build_request(req)
+      !req.kind_of?(Sanford::Protocol::Request) ? test_request(req) : req
     end
 
-    def build_response(response_args)
-      Sanford::Protocol::Response.new(response_args.status, response_args.data) if response_args
+    def test_request(params)
+      Sanford::Protocol::Request.new('name', params || {})
     end
 
   end

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/sanford.rb

@@ -1,29 +1,20 @@
-require 'ns-options'
-require 'pathname'
-require 'set'
-
 require 'sanford/version'
+require 'sanford/config'
+require 'sanford/hosts'
 require 'sanford/host'
-require 'sanford/logger'
-require 'sanford/runner'
-require 'sanford/server'
 require 'sanford/service_handler'
 
 ENV['SANFORD_SERVICES_FILE'] ||= 'config/services'
 
 module Sanford
 
-  def self.config
-    Sanford::Config
-  end
-
+  def self.config; @config ||= Config.new; end
   def self.configure(&block)
-    self.config.define(&block)
-    self.config
+    block.call(self.config)
   end
 
   def self.init
-    @hosts ||= Hosts.new
+    @hosts ||= Sanford::Hosts.new
     require self.config.services_file
   end
 
@@ -35,43 +26,4 @@ module Sanford
     @hosts
   end
 
-  module Config
-    include NsOptions::Proxy
-    option :services_file,  Pathname, :default => ENV['SANFORD_SERVICES_FILE']
-    option :logger,                   :default => Sanford::NullLogger.new
-    option :runner,                   :default => Sanford::DefaultRunner
-  end
-
-  class Hosts
-
-    def initialize(values = [])
-      @set = Set.new(values)
-    end
-
-    def method_missing(method, *args, &block)
-      @set.send(method, *args, &block)
-    end
-
-    def respond_to?(method)
-      super || @set.respond_to?(method)
-    end
-
-    # We want class names to take precedence over a configured name, so that if
-    # a user specifies a specific class, they always get it
-    def find(name)
-      find_by_class_name(name) || find_by_name(name)
-    end
-
-    private
-
-    def find_by_class_name(class_name)
-      @set.detect{|host_class| host_class.to_s == class_name.to_s }
-    end
-
-    def find_by_name(name)
-      @set.detect{|host_class| host_class.name == name.to_s }
-    end
-
-  end
-
 end

data/sanford.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("dat-tcp",           ["~> 0.4"])
   gem.add_dependency("ns-options",        ["~> 1.1"])
-  gem.add_dependency("sanford-protocol",  ["~> 0.7"])
+  gem.add_dependency("sanford-protocol",  ["~> 0.8"])
 
   gem.add_development_dependency("assert",        ["~> 2.10"])
   gem.add_development_dependency("assert-mocha",  ["~> 1.1"])

data/test/helper.rb

@@ -11,8 +11,17 @@ ENV['SANFORD_PROTOCOL_DEBUG'] = 'yes'
 
 require 'sanford'
 ROOT = File.expand_path('../..', __FILE__)
+
+MyTestEngine = Class.new(Sanford::TemplateEngine) do
+  def render(path, service_handler, locals)
+    [path.to_s, service_handler.class.to_s, locals]
+  end
+end
 Sanford.configure do |config|
   config.services_file = File.join(ROOT, 'test/support/services')
+  config.set_template_source File.join(ROOT, 'test/support') do |s|
+    s.engine 'test', MyTestEngine
+  end
 end
 Sanford.init
 

data/test/support/factory.rb

@@ -0,0 +1,6 @@
+require 'assert/factory'
+
+module Factory
+  extend Assert::Factory
+
+end

data/test/support/service_handlers.rb

@@ -24,10 +24,18 @@ module CallbackServiceHandler
 
   def self.included(receiver)
     receiver.class_eval do
+      attr_reader :before_called, :after_called
       attr_reader :before_init_called, :init_bang_called, :after_init_called
       attr_reader :before_run_called, :run_bang_called, :after_run_called
       attr_reader :second_before_init_called, :second_after_run_called
 
+      before do
+        @before_called = true
+      end
+      after do
+        @after_called = true
+      end
+
       before_init do
         @before_init_called = true
       end
@@ -117,6 +125,14 @@ class HaltingBehaviorServiceHandler
 
 end
 
+class RenderHandler
+  include Sanford::ServiceHandler
+
+  def run!
+    render 'test_template'
+  end
+end
+
 class RunOtherHandler
   include Sanford::ServiceHandler
 

data/test/support/template.json

@@ -0,0 +1 @@
+This is a json template for use in template engine tests.

data/test/system/request_handling_tests.rb

@@ -251,7 +251,7 @@ class RequestHandlingTests < Assert::Context
     end
   end
 
-  # Sending the server a protocol version that doesn't match it's version
+  # Sending the server a protocol version that doesn't match its version
   class WrongProtocolVersionTests < ForkedServerTests
     desc "when sent a request with a wrong protocol version"
 

data/test/unit/config_tests.rb

@@ -0,0 +1,56 @@
+require 'assert'
+require 'sanford/config'
+
+require 'ns-options/assert_macros'
+require 'ns-options/proxy'
+require 'sanford/logger'
+require 'sanford/runner'
+require 'sanford/template_source'
+require 'test/support/factory'
+
+class Sanford::Config
+
+  class UnitTests < Assert::Context
+    include NsOptions::AssertMacros
+
+    desc "Sanford::Config"
+    setup do
+      @config = Sanford::Config.new
+    end
+    subject{ @config }
+
+    should have_options :services_file, :logger
+    should have_readers :template_source
+    should have_imeths :set_template_source
+
+    should "be an NsOptions::Proxy" do
+      assert_includes NsOptions::Proxy, subject.class
+    end
+
+    should "default its services file" do
+      exp = Pathname.new(ENV['SANFORD_SERVICES_FILE'])
+      assert_equal exp, subject.services_file
+    end
+
+    should "default its logger to a NullLogger" do
+      assert_kind_of Sanford::NullLogger, subject.logger
+    end
+
+    should "have a null template source by default" do
+      assert_kind_of Sanford::NullTemplateSource, subject.template_source
+    end
+
+    should "set a new template source" do
+      path = '/path/to/app/assets'
+      block_called = false
+      subject.set_template_source(path) { |s| block_called = true}
+
+      assert_not_nil subject.template_source
+      assert_kind_of Sanford::TemplateSource, subject.template_source
+      assert_equal path, subject.template_source.path
+      assert_true block_called
+    end
+
+  end
+
+end

data/test/unit/host_data_tests.rb

@@ -1,8 +1,6 @@
 require 'assert'
 require 'sanford/host_data'
 
-require 'test/support/services'
-
 class Sanford::HostData
 
   class UnitTests < Assert::Context
@@ -16,7 +14,7 @@ class Sanford::HostData
     end
     subject{ @host_data }
 
-    should have_readers :name, :logger, :verbose, :keep_alive, :runner, :error_procs
+    should have_readers :name, :logger, :verbose, :keep_alive, :error_procs
     should have_imeths :handler_class_for, :run
 
     should "call the init procs" do
@@ -28,7 +26,6 @@ class Sanford::HostData
       assert_equal TestHost.configuration.logger.class,        subject.logger.class
       assert_equal TestHost.configuration.verbose_logging,     subject.verbose
       assert_equal TestHost.configuration.receives_keep_alive, subject.keep_alive
-      assert_equal TestHost.configuration.runner.class,        subject.runner.class
       assert_equal TestHost.configuration.error_procs,         subject.error_procs
     end