deas 0.0.2 → 0.1.0

data/deas.gemspec

@@ -17,6 +17,12 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.0"])
+  gem.add_dependency("ns-options", ["~> 1.0"])
+  gem.add_dependency("rack",       ["~> 1.5"])
+  gem.add_dependency("sinatra",    ["~> 1.4"])
+
+  gem.add_development_dependency("assert",       ["~> 2.0"])
+  gem.add_development_dependency("assert-mocha", ["~> 1.0"])
+  gem.add_development_dependency("rack-test",    ["~> 0.6"])
 
 end

data/lib/deas/logger.rb

@@ -0,0 +1,23 @@
+module Deas
+
+  class RunnerLogger
+    attr_reader :summary, :verbose
+
+    def initialize(logger, verbose = true)
+      loggers = [ logger, Deas::NullLogger.new ]
+      loggers.reverse! if !verbose
+      @verbose, @summary = loggers
+    end
+
+  end
+
+  class NullLogger
+    require 'logger'
+
+    ::Logger::Severity.constants.each do |name|
+      define_method(name.downcase){|*args| } # no-op
+    end
+
+  end
+
+end

data/lib/deas/route.rb

@@ -0,0 +1,45 @@
+require 'deas/sinatra_runner'
+
+module Deas
+
+  class Route
+    attr_reader :method, :path, :handler_class_name, :handler_class
+
+    def initialize(method, path, handler_class_name)
+      @method = method
+      @path   = path
+      @handler_class_name = handler_class_name
+      @handler_class      = nil
+    end
+
+    def constantize!
+      @handler_class ||= constantize_name(handler_class_name)
+      raise(NoHandlerClassError.new(handler_class_name)) if !@handler_class
+    end
+
+    def runner(sinatra_call)
+      Deas::SinatraRunner.new(@handler_class, sinatra_call)
+    end
+
+    private
+
+    def constantize_name(class_name)
+      names = class_name.to_s.split('::').reject{|name| name.empty? }
+      klass = names.inject(Object) do |constant, name|
+        constant.const_get(name)
+      end
+      klass == Object ? false : klass
+    rescue NameError
+      false
+    end
+
+  end
+
+  class NoHandlerClassError < RuntimeError
+    def initialize(handler_class_name)
+      super "Deas couldn't find the view handler '#{handler_class_name}'. " \
+        "It doesn't exist or hasn't been required in yet."
+    end
+  end
+
+end

data/lib/deas/runner.rb

@@ -0,0 +1,30 @@
+module Deas
+
+  class Runner
+
+    attr_accessor :request, :response, :params, :logger, :session
+
+    def initialize(handler_class)
+      @handler_class = handler_class
+      @handler = @handler_class.new(self)
+    end
+
+    def halt(*args)
+      raise NotImplementedError
+    end
+
+    def render(*args)
+      raise NotImplementedError
+    end
+
+    def redirect(*args)
+      raise NotImplementedError
+    end
+
+    def redirect_to(*args)
+      raise NotImplementedError
+    end
+
+  end
+
+end

data/lib/deas/server.rb

@@ -0,0 +1,152 @@
+require 'ns-options'
+require 'ns-options/boolean'
+require 'pathname'
+require 'singleton'
+
+require 'deas/logger'
+require 'deas/route'
+
+module Deas
+
+  class Server
+    include Singleton
+
+    class Configuration
+      include NsOptions::Proxy
+
+      # Sinatra based options
+      option :env,  String,   :default => 'development'
+      option :root, Pathname, :default => proc{ File.dirname(Deas.config.routes_file) }
+
+      option :app_file,      Pathname, :default => proc{ Deas.config.routes_file }
+      option :public_folder, Pathname
+      option :views_folder,  Pathname
+
+      option :dump_errors,     NsOptions::Boolean, :default => false
+      option :method_override, NsOptions::Boolean, :default => true
+      option :sessions,        NsOptions::Boolean, :default => true
+      option :show_exceptions, NsOptions::Boolean, :default => false
+      option :static_files,    NsOptions::Boolean, :default => true
+
+      # Deas specific options
+      option :init_proc, Proc,   :default => proc{ }
+      option :logger,            :default => proc{ Deas::NullLogger.new }
+      option :verbose_logging,   :default => true
+
+      option :routes,          Array, :default => []
+      option :view_handler_ns, String
+
+      def initialize
+        # these are defaulted here because we want to use the Configuration
+        # instance `root`. If we define a proc above, we will be using the
+        # Configuration class `root`, which will not update these options as
+        # expected.
+        super({
+          :public_folder => proc{ self.root.join('public') },
+          :views_folder  => proc{ self.root.join('views') }
+        })
+      end
+
+      def runner_logger
+        Deas::RunnerLogger.new(self.logger, self.verbose_logging)
+      end
+    end
+
+    attr_reader :configuration
+
+    def initialize
+      @configuration = Configuration.new
+    end
+
+    def env(*args)
+      self.configuration.env *args
+    end
+
+    def root(*args)
+      self.configuration.root *args
+    end
+
+    def public_folder(*args)
+      self.configuration.public_folder *args
+    end
+
+    def views_folder(*args)
+      self.configuration.views_folder *args
+    end
+
+    def dump_errors(*args)
+      self.configuration.dump_errors *args
+    end
+
+    def method_override(*args)
+      self.configuration.method_override *args
+    end
+
+    def sessions(*args)
+      self.configuration.sessions *args
+    end
+
+    def show_exceptions(*args)
+      self.configuration.show_exceptions *args
+    end
+
+    def static_files(*args)
+      self.configuration.static_files *args
+    end
+
+    def init(&block)
+      self.configuration.init_proc = block
+    end
+
+    def logger(*args)
+      self.configuration.logger *args
+    end
+
+    def verbose_logging(*args)
+      self.configuration.verbose_logging *args
+    end
+
+    def view_handler_ns(*args)
+      self.configuration.view_handler_ns *args
+    end
+
+    def get(path, handler_class_name)
+      self.route(:get, path, handler_class_name)
+    end
+
+    def post(path, handler_class_name)
+      self.route(:post, path, handler_class_name)
+    end
+
+    def put(path, handler_class_name)
+      self.route(:put, path, handler_class_name)
+    end
+
+    def patch(path, handler_class_name)
+      self.route(:patch, path, handler_class_name)
+    end
+
+    def delete(path, handler_class_name)
+      self.route(:delete, path, handler_class_name)
+    end
+
+    def route(http_method, path, handler_class_name)
+      if self.view_handler_ns && !(handler_class_name =~ /^::/)
+        handler_class_name = "#{self.view_handler_ns}::#{handler_class_name}"
+      end
+      Deas::Route.new(http_method, path, handler_class_name).tap do |route|
+        self.configuration.routes.push(route)
+      end
+    end
+
+    def self.method_missing(method, *args, &block)
+      self.instance.send(method, *args, &block)
+    end
+
+    def self.respond_to?(*args)
+      super || self.instance.respond_to?(*args)
+    end
+
+  end
+
+end

data/lib/deas/sinatra_app.rb

@@ -0,0 +1,54 @@
+require 'sinatra/base'
+
+module Deas
+
+  module SinatraApp
+
+    def self.new(server_config)
+      server_config.init_proc.call
+      server_config.routes.each(&:constantize!)
+
+      Class.new(Sinatra::Base).tap do |app|
+
+        # built-in settings
+        app.set :environment, server_config.env
+        app.set :root,        server_config.root
+
+        app.set :app_file,      server_config.app_file
+        app.set :public_folder, server_config.public_folder
+        app.set :views,         server_config.views_folder
+
+        app.set :dump_errors,     server_config.dump_errors
+        app.set :logging,         false
+        app.set :method_override, server_config.method_override
+        app.set :sessions,        server_config.sessions
+        app.set :show_exceptions, server_config.show_exceptions
+        app.set :static,          server_config.static_files
+
+        # custom settings
+        app.set :logger,        server_config.logger
+        app.set :runner_logger, server_config.runner_logger
+
+        # routes
+        server_config.routes.each do |route|
+          # defines Sinatra routes like:
+          #   before('/'){ ... }
+          #   get('/'){ ... }
+          #   after('/'){ ... }
+          app.before(route.path) do
+            @runner = route.runner(self).setup
+          end
+          app.send(route.method, route.path) do
+            @runner.run
+          end
+          app.after(route.path) do
+            @runner.teardown
+          end
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/deas/sinatra_runner.rb

@@ -0,0 +1,119 @@
+require 'deas/runner'
+require 'deas/template'
+
+module Deas
+
+  class SinatraRunner < Runner
+
+    def initialize(handler_class, sinatra_call)
+      @sinatra_call  = sinatra_call
+      @handler_class = handler_class
+      @logger        = @sinatra_call.settings.logger
+      @runner_logger = @sinatra_call.settings.runner_logger
+      @params        = @sinatra_call.params
+      @request       = @sinatra_call.request
+      @response      = @sinatra_call.response
+      @session       = @sinatra_call.session
+      @time_taken    = nil
+      @started_at    = nil
+      super(handler_class)
+    end
+
+    def setup
+      @started_at = Time.now
+      log_verbose "===== Received request ====="
+      log_verbose "  Method:  #{@request.request_method.inspect}"
+      log_verbose "  Path:    #{@request.path.inspect}"
+      log_verbose "  Params:  #{@sinatra_call.params.inspect}"
+      log_verbose "  Handler: #{@handler_class}"
+      self
+    end
+
+    def run
+      run_callbacks @handler_class.before_callbacks
+      @handler.init
+      response_data = @handler.run
+      run_callbacks @handler_class.after_callbacks
+      response_data
+    end
+
+    # expects that `setup` has been run; this method is dependent on it
+    CODE_NAMES = {
+      200 => 'OK',
+      400 => 'BAD REQUEST' ,
+      401 => 'UNAUTHORIZED',
+      403 => 'FORBIDDEN',
+      404 => 'NOT FOUND',
+      408 => 'TIMEOUT',
+      500 => 'ERROR'
+    }
+    def teardown
+      @time_taken = RoundedTime.new(Time.now - @started_at)
+      @response.status.tap do |code|
+        response_display = [ code, CODE_NAMES[code.to_i] ].compact.join(', ')
+        log_verbose "===== Completed in #{@time_taken}ms " \
+                    "#{response_display} ====="
+      end
+      log_summary SummaryLine.new({
+        'status'  => @response.status,
+        'method'  => @request.request_method,
+        'path'    => @request.path,
+        'params'  => @params,
+        'time'    => @time_taken,
+        'handler' => @handler_class
+      })
+      self
+    end
+
+    def log_verbose(message, level = :info)
+      @runner_logger.verbose.send(level, "[Deas] #{message}")
+    end
+
+    def log_summary(message, level = :info)
+      @runner_logger.summary.send(level, "[Deas] #{message}")
+    end
+
+    # Helpers
+
+    def halt(*args)
+      @sinatra_call.halt(*args)
+    end
+
+    def render(name, options = nil, &block)
+      options ||= {}
+      options[:locals] = { :view => @handler }.merge(options[:locals] || {})
+      options[:layout] ||= @handler_class.layouts
+      Deas::Template.new(@sinatra_call, name, options).render(&block)
+    end
+
+    def redirect(*args)
+      @sinatra_call.redirect(*args)
+    end
+
+    def redirect_to(path, *args)
+      @sinatra_call.redirect(@sinatra_call.to(path), *args)
+    end
+
+    private
+
+    def run_callbacks(callbacks)
+      callbacks.each{|proc| @handler.instance_eval(&proc) }
+    end
+
+    module RoundedTime
+      ROUND_PRECISION = 2
+      ROUND_MODIFIER = 10 ** ROUND_PRECISION
+      def self.new(time_in_seconds)
+        (time_in_seconds * 1000 * ROUND_MODIFIER).to_i / ROUND_MODIFIER.to_f
+      end
+    end
+
+    module SummaryLine
+      def self.new(line_attrs)
+        attr_keys = %w{time status handler method path params}
+        attr_keys.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
+      end
+    end
+
+  end
+end

data/lib/deas/template.rb

@@ -0,0 +1,80 @@
+require 'rack'
+
+module Deas
+
+  class Template
+
+    def self.helpers(*helper_modules)
+      Deas::Template::RenderScope.class_eval{ include *helper_modules }
+    end
+
+    attr_reader :name, :options
+
+    def initialize(sinatra_call, name, options = nil)
+      @options = options || {}
+      @options[:scope] = RenderScope.new(sinatra_call)
+
+      @sinatra_call = sinatra_call
+      @name         = name.to_sym
+      (@options.delete(:layout) || @options.delete(:layouts) || []).tap do |l|
+        @layouts = l.compact.map(&:to_sym)
+      end
+    end
+
+    # builds Sinatra render-blocks like:
+    #
+    #   erb :main_layout do
+    #     erb :second_layout do
+    #       erb :user_index
+    #     end
+    #   end
+    #
+    def render(&block)
+      template_names = [ @layouts, @name ].flatten.reverse
+      top_render_proc = template_names.inject(block) do |render_proc, name|
+        proc{ @sinatra_call.erb(name, @options, &render_proc) }
+      end
+      top_render_proc.call
+    end
+
+    class RenderScope
+      def initialize(sinatra_call)
+        @sinatra_call = sinatra_call
+      end
+
+      def render(name, options = nil, &block)
+        Deas::Template.new(@sinatra_call, name, options || {}).render(&block)
+      end
+
+      def partial(name, locals = nil)
+        Deas::Partial.new(@sinatra_call, name, locals || {}).render
+      end
+
+      def escape_html(html)
+        Rack::Utils.escape_html(html)
+      end
+      alias :h :escape_html
+
+      def escape_url(path)
+        Rack::Utils.escape_path(path)
+      end
+      alias :u :escape_url
+
+    end
+
+  end
+
+  class Partial < Template
+
+    def initialize(sinatra_call, name, locals = nil)
+      options = { :locals => (locals || {}) }
+      name = begin
+        basename = File.basename(name.to_s)
+        name.to_s.sub(/#{basename}\Z/, "_#{basename}")
+      end
+      super sinatra_call, name, options
+    end
+
+  end
+
+end

data/lib/deas/test_helpers.rb

@@ -0,0 +1,15 @@
+require 'deas/test_runner'
+
+module Deas
+
+  module TestHelpers
+
+    module_function
+
+    def test_runner(handler_class, args = nil)
+      TestRunner.new(handler_class, args)
+    end
+
+  end
+
+end

data/lib/deas/test_runner.rb

@@ -0,0 +1,40 @@
+require 'deas/logger'
+require 'deas/runner'
+
+module Deas
+
+  class TestRunner < Runner
+
+    attr_reader :handler, :return_value
+
+    def initialize(handler_class, args = nil)
+      args = (args || {}).dup
+      @logger   = args.delete(:logger) || Deas::NullLogger.new
+      @params   = args.delete(:params) || {}
+      @request  = args.delete(:request)
+      @response = args.delete(:response)
+      @session  = args.delete(:session)
+
+      super(handler_class)
+      args.each{|key, value| @handler.send("#{key}=", value) }
+
+      @return_value = catch(:halt){ @handler.init; nil }
+    end
+
+    def run
+      @return_value ||= catch(:halt){ @handler.run }
+    end
+
+    # Helpers
+
+    def halt(*args)
+      throw(:halt, args)
+    end
+
+    def render(*args)
+      "test runner render"
+    end
+
+  end
+
+end

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/deas/view_handler.rb

@@ -0,0 +1,97 @@
+require 'deas/runner'
+
+module Deas
+
+  module ViewHandler
+
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    def initialize(runner)
+      @deas_runner = runner
+    end
+
+    def init
+      self.run_callback 'before_init'
+      self.init!
+      self.run_callback 'after_init'
+    end
+
+    def init!
+    end
+
+    def run
+      self.run_callback 'before_run'
+      data = self.run!
+      self.run_callback 'after_run'
+      data
+    end
+
+    def run!
+      raise NotImplementedError
+    end
+
+    def inspect
+      reference = '0x0%x' % (self.object_id << 1)
+      "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
+    end
+
+    protected
+
+    def before_init; end
+    def after_init;  end
+    def before_run;  end
+    def after_run;   end
+
+    # Helpers
+
+    def halt(*args);        @deas_runner.halt(*args);        end
+    def redirect(*args);    @deas_runner.redirect(*args);    end
+    def redirect_to(*args); @deas_runner.redirect_to(*args); end
+
+    def render(*args, &block)
+      @deas_runner.render(*args, &block)
+    end
+
+    def logger;   @deas_runner.logger;   end
+    def request;  @deas_runner.request;  end
+    def response; @deas_runner.response; end
+    def params;   @deas_runner.params;   end
+    def session;  @deas_runner.session;  end
+
+    def run_callback(callback)
+      self.send(callback.to_s)
+    end
+
+    module ClassMethods
+
+      def before(&block)
+        self.before_callbacks << block
+      end
+
+      def before_callbacks
+        @before_callbacks ||= []
+      end
+
+      def after(&block)
+        self.after_callbacks << block
+      end
+
+      def after_callbacks
+        @after_callbacks ||= []
+      end
+
+      def layout(*args)
+        @layouts = args unless args.empty?
+        @layouts
+      end
+      alias :layouts :layout
+
+    end
+
+  end
+
+end