cannon 0.0.2

data/lib/cannon/route.rb

@@ -0,0 +1,80 @@
+module Cannon
+  class Route
+    attr_reader :path, :actions, :redirect, :method
+
+    def initialize(app, method:, path:, actions: nil, redirect: nil)
+      @path = build_path(path)
+      @method, @app, @redirect = method.to_s.upcase, app, redirect
+      @actions = actions || []
+      @route_action = build_route_action(@actions.dup)
+    end
+
+    def add_route_action(action)
+      @route_action.last_action.callback = RouteAction.new(@app, action: action, callback: nil)
+    end
+
+    def matches?(request)
+      return false unless method == 'ALL' || request.method == method
+
+      matches = self.path.match(request.path)
+      if matches.nil?
+        false
+      else
+        @params.each_with_index { |key, index| request.params[key.to_sym] = matches.captures[index] }
+        true
+      end
+    end
+
+    def handle(request, response, finish_proc)
+      if redirect
+        response.permanent_redirect(redirect)
+      elsif @route_action
+        begin
+          @route_action.run(request, response, finish_proc)
+        rescue => error
+          Cannon.logger.error error.message
+          Cannon.logger.error error.backtrace.join("\n")
+          response.internal_server_error(title: error.message, content: error.backtrace.join('<br/>'))
+          finish_proc.call
+        end
+      end
+    end
+
+    def to_s
+      "Route: #{path}"
+    end
+
+  private
+
+    def build_path(path)
+      path = '/' + path unless path =~ /^\// # ensure path begins with '/'
+      @params = []
+
+      if path.include? ':'
+        param_path_to_regexp(path)
+      else
+        /^#{path.gsub('/', '\/')}$/
+      end
+    end
+
+    def param_path_to_regexp(path)
+      /^#{path.split('/').map { |part| normalize_path_part(part) }.join('\/')}$/
+    end
+
+    def normalize_path_part(part)
+      if part =~ /^:(.+)/
+        @params << $1
+        '([^\/]+)'
+      else
+        part
+      end
+    end
+
+    def build_route_action(actions, callback: nil)
+      return callback if actions.size < 1
+
+      route_action = RouteAction.new(@app, action: actions.pop, callback: callback)
+      build_route_action(actions, callback: route_action)
+    end
+  end
+end

data/lib/cannon/route_action.rb

@@ -0,0 +1,92 @@
+class RouteAction
+  include EventMachine::Deferrable
+
+  class << self
+    def controller(name, app)
+      controllers[name] ||= Object.const_get(name).new(app)
+    end
+
+    def controllers
+      @controllers ||= {}
+    end
+  end
+
+  attr_writer :callback
+
+  def initialize(app, action:, callback:)
+    @app, @action, @callback = app, action, callback
+  end
+
+  def last_action
+    @callback.nil? ? self : @callback.last_action
+  end
+
+  def run(request, response, finish_proc)
+    next_proc = -> do
+      if response.flushed?
+        fail
+        finish_proc.call
+      else
+        setup_callback
+        succeed(request, response, finish_proc)
+      end
+    end
+
+    if @action.is_a? Proc
+      run_inline_action(request, response, next_proc)
+    elsif @action.include? '#'
+      run_controller_action(request, response, next_proc)
+    else
+      run_bound_action(request, response, next_proc)
+    end
+  end
+
+private
+
+  def run_inline_action(request, response, next_proc)
+    Cannon.logger.debug 'Action: Inline'
+
+    if @action.arity == 2
+      @action.call(request, response)
+      next_proc.call
+    else
+      @action.call(request, response, next_proc)
+    end
+  end
+
+  def run_controller_action(request, response, next_proc)
+    controller, action = @action.split('#')
+
+    Cannon.logger.debug "Controller: #{controller}, Action: #{action}"
+
+    controller_instance = RouteAction.controller(controller, @app)
+    if controller_instance.method(action).arity == 2
+      controller_instance.send(action, request, response)
+      next_proc.call
+    else
+      controller_instance.send(action, request, response, next_proc)
+    end
+  end
+
+  def run_bound_action(request, response, next_proc)
+    Cannon.logger.debug "Action: #{@action}"
+
+    if @app.app_binding.method(@action).arity == 2
+      @app.app_binding.send(@action, request, response)
+      next_proc.call
+    else
+      @app.app_binding.send(@action, request, response, next_proc)
+    end
+  end
+
+  def setup_callback
+    set_deferred_status nil
+    callback do |request, response, finish_proc|
+      if @callback.nil?
+        finish_proc.call
+      else
+        @callback.run(request, response, finish_proc)
+      end
+    end
+  end
+end

data/lib/cannon/version.rb

@@ -0,0 +1,3 @@
+module Cannon
+  VERSION = '0.0.2'
+end

data/lib/cannon/views.rb

@@ -0,0 +1,28 @@
+require 'mustache'
+
+module Cannon
+  module Views
+    include PathCache
+
+    def view(filename, options = {})
+      reload_cache if outdated_cache?
+
+      file, content_type = *file_and_content_type("#{base_path}/#{filename}")
+      header('Content-Type', content_type)
+      send(Mustache.render(file, options), status: status)
+    end
+
+  protected
+
+    def initialize_views
+      self.cache = :views
+      self.base_path = build_view_path
+    end
+
+  private
+
+    def build_view_path
+      @app.config.view_path =~ /^\// ? @app.config.view_path : "#{Cannon.root}/#{@app.config.view_path}"
+    end
+  end
+end

data/spec/app_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe Cannon::App, :cannon_app do
+  context 'app is listening asynchronously' do
+    before(:each) { cannon_app.listen(port: 3030, async: true) }
+    after(:each) { cannon_app.stop }
+
+    it 'raises an error if trying to listen again before stopping' do
+      expect(-> { cannon_app.listen }).to raise_error(Cannon::AlreadyListening)
+    end
+
+    context 'app has been stopped' do
+      before(:each) { cannon_app.stop }
+
+      it 'does not raise an error' do
+        expect(-> { cannon_app.listen(async: true) }).to_not raise_error
+      end
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe 'Configuration' do
+  describe 'view_path' do
+    it 'can be relative', :cannon_app do
+      cannon_app.config.view_path = '../fixtures/views'
+      cannon_app.get('/') do |request, response|
+        response.view('test.html')
+      end
+      cannon_app.listen(async: true)
+      get '/'
+      expect(response.body).to eq('Test view content')
+    end
+
+    it 'can be absolute', :cannon_app do
+      cannon_app.config.view_path = Cannon.root + '/../fixtures/views'
+      cannon_app.get('/') do |request, response|
+        response.view('test.html')
+      end
+      cannon_app.listen(async: true)
+      get '/'
+      expect(response.body).to eq('Test view content')
+    end
+  end
+
+  describe 'public_path' do
+    it 'can be relative', :cannon_app do
+      cannon_app.config.public_path = '../fixtures/public'
+      cannon_app.listen(async: true)
+      get '/background.jpg'
+      expect(response.code).to be(200)
+    end
+
+    it 'can be absolute', :cannon_app do
+      cannon_app.config.public_path = Cannon.root + '/../fixtures/public'
+      cannon_app.listen(async: true)
+      get '/background.jpg'
+      expect(response.code).to be(200)
+    end
+  end
+end

data/spec/environments_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+RSpec.describe 'Cannon environment', :cannon_app do
+  context 'no environment specified' do
+    before(:each) { ENV['CANNON_ENV'] = nil }
+
+    it 'sets the environment to development' do
+      expect(cannon_app.env).to eq('development')
+    end
+  end
+
+  context 'environment specified' do
+    before(:each) { ENV['CANNON_ENV'] = 'strange' }
+
+    it 'sets the environment to the environment specified' do
+      expect(cannon_app.env).to eq('strange')
+    end
+  end
+
+  describe 'environment helper methods' do
+    before(:each) do
+      ENV['CANNON_ENV'] = 'carrots'
+
+      cannon_app.configure(:potatoes) {}
+      Cannon.configure(:celeries) {}
+      cannon_app.configure(:onions, :lettuce, :pickles)
+    end
+
+    it 'creates a helper method for current environment' do
+      expect(cannon_app.env.carrots?).to be(true)
+    end
+
+    it 'creates helper methods for single configured environments' do
+      expect(cannon_app.env.potatoes?).to be(false)
+      expect(cannon_app.env.celeries?).to be(false)
+    end
+
+    it 'creates helper methods for multi configured environments' do
+      expect(cannon_app.env.onions?).to be(false)
+      expect(cannon_app.env.lettuce?).to be(false)
+      expect(cannon_app.env.pickles?).to be(false)
+    end
+  end
+
+  describe 'environment specific config blocks' do
+    before(:each) do
+      ENV['CANNON_ENV'] = 'carrots'
+
+      cannon_app.configure(:potatoes) do |config|
+        config.view_path = 'potatoes_view_path'
+      end
+      cannon_app.configure(:carrots) do |config|
+        config.view_path = 'carrots_view_path'
+      end
+      Cannon.configure(:pickles) do |config|
+        config.public_path = 'pickles_view_path'
+      end
+      cannon_app.configure(:onions, :carrots) do |config|
+        config.public_path = 'shared_view_path'
+      end
+    end
+
+    it 'runs the configuration for the given environment' do
+      expect(Cannon.config.view_path).to eq('carrots_view_path')
+      expect(Cannon.config.public_path).to eq('shared_view_path')
+    end
+  end
+end

data/spec/features/action_types_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+def hi(request, response)
+  response.send('hi')
+end
+
+def how(request, response)
+  response.send(' how ')
+end
+
+def are_you(request, response)
+  response.send('are you?')
+end
+
+def first(request, response, next_proc)
+  EM.defer(
+    -> { sleep 0.1 },
+    ->(result) do
+      response.send('first')
+      next_proc.call
+    end
+  )
+end
+
+def second(request, response)
+  response.send(' second')
+end
+
+class World
+  def initialize(app)
+    @count = 0
+  end
+
+  def hello(request, response)
+    response.send('Hello World!')
+  end
+
+  def count(request, response)
+    response.send("count = #{@count}")
+    @count += 1
+  end
+
+  def first(request, response, next_proc)
+    EM.defer(
+      -> { sleep 0.1 },
+      ->(result) do
+        response.send('first')
+        next_proc.call
+      end
+    )
+  end
+
+  def second(request, response)
+    response.send(' second')
+  end
+end
+
+RSpec.describe 'Cannon app', :cannon_app do
+  before(:all) do
+    cannon_app.get('/1-2-simple', actions: ['first', 'second'])
+    cannon_app.get('/hi', action: 'hi')
+    cannon_app.get('/how', actions: ['hi', 'how', 'are_you'])
+
+    cannon_app.get('/hello', action: 'World#hello')
+    cannon_app.get('/count', action: 'World#count')
+    cannon_app.get('/1-2-controller', actions: ['World#first', 'World#second'])
+
+    cannon_app.get('/inline') do |request, response|
+      response.send('inline action')
+    end
+
+    cannon_app.get('/inline_chained') do |request, response|
+      response.send('first')
+    end.handle do |request, response|
+      response.send(' second')
+    end.handle do |request, response|
+      response.send(' third')
+    end
+
+    cannon_app.get('/1-2-inline') do |request, response, next_proc|
+      EM.defer(
+        -> { sleep 0.1 },
+        ->(result) do
+          response.send('first')
+          next_proc.call
+        end
+      )
+    end.handle do |request, response|
+      response.send(' second')
+    end
+
+
+    cannon_app.listen(async: true)
+  end
+
+  describe 'simple method' do
+    it 'handles single actions' do
+      get '/hi'
+      expect(response.code).to be(200)
+      expect(response.body).to eq('hi')
+    end
+
+    it 'handles an actions chain' do
+      get '/how'
+      expect(response.code).to be(200)
+      expect(response.body).to eq('hi how are you?')
+    end
+
+    it 'handles next_proc calls for deferred processing' do
+      get '/1-2-simple'
+      expect(response.body).to eq('first second')
+    end
+  end
+
+  describe 'inline' do
+    it 'handles single actions' do
+      get '/inline'
+      expect(response.code).to be(200)
+      expect(response.body).to eq('inline action')
+    end
+
+    it 'handles an actions chain' do
+      get '/inline_chained'
+      expect(response.body).to eq('first second third')
+    end
+
+    it 'handles next_proc calls for deferred processing' do
+      get '/1-2-inline'
+      expect(response.body).to eq('first second')
+    end
+  end
+
+  describe 'controller based' do
+    it 'handles simple actions' do
+      get '/hello'
+      expect(response.body).to eq('Hello World!')
+      expect(response.code).to eq(200)
+    end
+
+    it 'handles next_proc calls for deferred processing' do
+      get '/1-2-controller'
+      expect(response.body).to eq('first second')
+    end
+
+    it 'keeps the instantiation of the controller' do
+      get '/count'
+      expect(response.body).to eq('count = 0')
+      get '/count'
+      expect(response.body).to eq('count = 1')
+      get '/count'
+      expect(response.body).to eq('count = 2')
+    end
+  end
+end