eldr 0.0.2

data/lib/eldr/route.rb

@@ -0,0 +1,92 @@
+module Eldr
+  class Route
+    attr_accessor :name, :app, :capture, :order, :options, :handler
+    attr_accessor :before_filters, :after_filters, :to
+
+    def initialize(verb: :get, path: '/', name: nil, options: {}, handler: nil, app: nil)
+      @path, @verb = path, verb.to_s.upcase
+
+      @app            = app
+      @capture        = {}
+      @before_filters = []
+      @after_filters  = []
+      @name           = name
+
+      merge_with_options!(options)
+
+      @handler   = handler
+      @handler ||= @to
+    end
+
+    def call(env, app: nil)
+      # TODO: Investigate
+      # maybe if we passed this around between methods it would be more perfomant
+      # than setting the accessor?
+      @app = app
+
+      app.class.before_filters[:all].each { |filter| app.instance_exec(env, &filter) } if app
+      @before_filters.each                { |filter| app.instance_exec(env, &filter) }
+
+      resp = response(env)
+
+      app.class.after_filters[:all].each { |filter| app.instance_exec(env, &filter) } if app
+      @after_filters.each                { |filter| app.instance_exec(env, &filter) }
+
+      resp
+    end
+
+    def response(env)
+      if @handler.is_a? Proc
+        app.instance_exec(env, &@handler)
+      elsif @handler.is_a? String
+        rails_style_response(env)
+      else
+        @handler.call(env)
+      end
+    end
+
+    def rails_style_response(env)
+      controller, method = @handler.split('#')
+
+      obj = Object.const_get(controller).new
+
+      if method
+        obj.send(method.to_sym, env)
+      else
+        obj.call(env)
+      end
+    end
+
+    def merge_with_options!(options)
+      @options = {} unless @options
+      options.each_pair do |key, value|
+        accessor?(key) ? __send__("#{key}=", value) : (@options[key] = value)
+      end
+    end
+
+    def accessor?(key)
+      respond_to?("#{key}=") && respond_to?(key)
+    end
+
+    def matcher
+      @matcher ||= Matcher.new(path, capture: @capture)
+    end
+
+    def match(pattern)
+      matcher.match(pattern)
+    end
+
+    def path(*args)
+      return @path if args.empty?
+      params = args[0]
+      params.delete(:captures)
+      matcher.expand(params)
+    end
+
+    def params(pattern)
+      params   = matcher.handler.params(pattern)
+      params ||= {}
+      params
+    end
+  end
+end

data/lib/eldr/version.rb

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

data/lib/eldr.rb

@@ -0,0 +1 @@
+require_relative 'eldr/app'

data/spec/app_spec.rb

@@ -0,0 +1,194 @@
+describe Eldr::App do
+  it 'has methods for all the http verbs' do
+    %w(DELETE GET HEAD OPTIONS PATCH POST PUT).each do |verb|
+      expect(Eldr::App.respond_to? verb.downcase.to_sym).to eq(true)
+    end
+  end
+
+  describe '.inherited' do
+    it 'inherits middleware' do
+      bob = Class.new(Eldr::App)
+      middleware = Class.new
+      expect(bob.builder.middleware.length).to eq(0)
+
+      bob.use middleware
+      expect(bob.builder.middleware.length).to eq(1)
+
+      # TODO Check that is is the actual class we wanted
+      inherited = Class.new(bob)
+      expect(inherited.builder.middleware.length).to eq(1)
+    end
+
+    it 'inherits configuration' do
+      bob = Class.new(Eldr::App)
+      bob.set(:bob, 'what about him?')
+
+      inherited = Class.new(bob)
+      expect(inherited.configuration.bob).to eq('what about him?')
+    end
+  end
+
+  describe '.new' do
+    it 'returns a new instance of Eldr::Builder' do
+      expect(Eldr::App.new).to be_instance_of Eldr::Builder
+    end
+  end
+
+  describe '.set' do
+    it 'sets configurations values' do
+      bob = Class.new(Eldr::App)
+      bob.set(:bob, 'what about him?')
+
+      expect(bob.config.bob).to eq('what about him?')
+    end
+  end
+
+  describe '.before' do
+    it 'adds a before filter' do
+      bob = Class.new(Eldr::App)
+      bob.before {}
+      bob.before(:cats) { }
+      expect(bob.before_filters[:all].length).to eq(1)
+      expect(bob.before_filters[:cats].length).to eq(1)
+    end
+  end
+
+  describe '.after' do
+    it 'adds an before filter' do
+      bob = Class.new(Eldr::App)
+      bob.after {}
+      bob.after(:cats) { }
+      expect(bob.after_filters[:all].length).to eq(1)
+      expect(bob.after_filters[:cats].length).to eq(1)
+    end
+  end
+
+  describe '.add' do
+    it 'adds a route to self.routes' do
+      bob = Class.new(Eldr::App)
+      expect(bob.routes[:get].length).to eq(0)
+      bob.add(verb: :get, path: '/', handler: proc {})
+      expect(bob.routes[:get].length).to eq(1)
+    end
+  end
+
+  describe '.call' do
+    let(:env) do
+      Rack::MockRequest.env_for('/', {:method => :get})
+    end
+
+    it 'creates a new builder instance runs in and returns a response' do
+      bob = Class.new(Eldr::App)
+      expect(bob.call(env)).to eq([404, {}, [""]])
+    end
+  end
+
+  describe '#recognize' do
+    let(:resp_proc) { proc { [200, {}, ['Hello Bob!']] } }
+    subject(:app) do
+      bob = Class.new(Eldr::App)
+      bob.get '/cats', resp_proc
+      bob._new
+    end
+
+    let(:env) do
+      Rack::MockRequest.env_for('/cats', {:method => :get})
+    end
+
+    it 'recognizes and returns a route for a given pattern' do
+      expect(app.recognize(env).first.handler).to eq(resp_proc)
+    end
+  end
+
+  describe '#call' do
+    subject(:app) do
+      Class.new(Eldr::App)
+    end
+
+    let(:env) do
+      Rack::MockRequest.env_for('/cats', {:method => :get})
+    end
+
+    it 'duplicates and runs call! on the duplicate' do
+      expect_any_instance_of(app).to receive(:call!)
+      app._new.call(env)
+    end
+  end
+
+  describe '#call!' do
+    subject(:app) do
+      bob = Class.new(Eldr::App)
+      bob.get '/cats/:id', name: :cats do
+        [200, {}, ['Hello Bob!']]
+      end
+
+      bob.get '/defer' do
+        throw :pass
+      end
+
+      bob.get '/defer' do
+        [200, {}, ['Hello From Deferred!']]
+      end
+
+      class Error < StandardError
+        def call(_env)
+          [500, {}, ['']]
+        end
+      end
+
+      bob.get '/error' do
+        raise Error
+      end
+
+      bob._new
+    end
+
+    let(:env) do
+      Rack::MockRequest.env_for('/cats/bob', {:method => :get})
+    end
+
+    let(:env_defer) do
+      Rack::MockRequest.env_for('/defer', {:method => :get})
+    end
+
+    let(:env_error) do
+      Rack::MockRequest.env_for('/error', {:method => :get})
+    end
+
+    let(:env_error) do
+      Rack::MockRequest.env_for('/error', {:method => :get})
+    end
+
+    let(:env_not_found) do
+      Rack::MockRequest.env_for('/god', {:method => :get})
+    end
+
+    it 'sets eldr.route' do
+      app.call!(env)
+      expect(app.env['eldr.route'].name).to eq(:cats)
+    end
+
+    it 'sets eldr.params' do
+      app.call!(env)
+      expect(app.env['eldr.params']['id']).to eq('bob')
+    end
+
+    context 'when passing/deferring' do
+      it 'calls the next matching route' do
+        expect(app.call!(env_defer).to_a[2].first).to eq('Hello From Deferred!')
+      end
+    end
+
+    context 'when raising an error' do
+      it 'catches the error and returns a response' do
+        expect(app.call!(env_error).first).to eq(500)
+      end
+    end
+
+    context 'when route does not exist' do
+      it 'returns a 404' do
+        expect(app.call!(env_not_found).first).to eq(404)
+      end
+    end
+  end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,11 @@
+describe Eldr::Builder do
+  describe '#use' do
+    it 'supports passing an array of middleware' do
+      builder = Eldr::Builder.new
+      builder.use Class.new
+      builder_2 = Eldr::Builder.new
+      builder_2.use builder.middleware
+      expect(builder_2.middleware).to eq(builder.middleware)
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,29 @@
+describe Eldr::Configuration do
+  describe '#initialize' do
+    it 'sets defaults' do
+      expect(Eldr::Configuration.new().lock).to eq(false)
+    end
+  end
+
+  describe '#set' do
+    let(:config) { Eldr::Configuration.new }
+
+    it 'sets a configuration value in #table' do
+      config.set(:bob, 'what about him?')
+      expect(config.bob).to eq('what about him?')
+    end
+  end
+
+  describe '#method_missing' do
+    let(:config) { Eldr::Configuration.new }
+
+    it 'returns a value from #table' do
+      config.set(:bob, 'what about him?')
+      expect(config.bob).to eq('what about him?')
+    end
+
+    it 'returns nil as a default' do
+      expect(config.franklin).to eq(nil)
+    end
+  end
+end

data/spec/examples/action_objects_spec.rb

@@ -0,0 +1,18 @@
+describe "ActionObjectsExample" do
+  let(:app) do
+    path = File.expand_path("../../examples/action_objects.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /cats/bob' do
+    it 'returns bob' do
+      response = rt.get '/cats/bob'
+      expect(response.body).to eq('Found cat named Bob!')
+    end
+  end
+
+end

data/spec/examples/builder_spec.rb

@@ -0,0 +1,16 @@
+describe 'BuilderExample' do
+  let(:app) do
+    path = File.expand_path("../../examples/builder.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /' do
+    it 'does some counting using middleware' do
+      expect(rt.get('/').body).to eq('1')
+    end
+  end
+end

data/spec/examples/custom_response_spec.rb

@@ -0,0 +1,17 @@
+describe 'CustomResponseExample' do
+  let(:app) do
+    path = File.expand_path("../../examples/custom_response.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /' do
+    it 'returns hello world' do
+      response = rt.get '/'
+      expect(response.body).to eq('Hello World Custom!')
+    end
+  end
+end

data/spec/examples/errors_spec.rb

@@ -0,0 +1,18 @@
+describe 'ErrorsExample' do
+  let(:app) do
+    path = File.expand_path("../../examples/errors.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /' do
+    it 'returns an error' do
+      response = rt.get '/'
+      expect(response.body).to eq('Bad Data')
+      expect(response.status).to eq(500)
+    end
+  end
+end

data/spec/examples/example_app_spec.rb

@@ -0,0 +1,98 @@
+describe "ExampleApp" do
+  it 'does not pollute the base class with routes' do
+    expect(Eldr::App.routes[:get].length).to eq(0)
+  end
+
+  let(:app) do
+    path = File.expand_path("../../examples/app.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /posts' do
+    it 'returns a 200 status' do
+      response = rt.get '/posts'
+      expect(response.status).to eq(200)
+    end
+  end
+
+  describe 'POST /posts' do
+    it 'returns a 201 status' do
+      response = rt.post '/posts'
+      expect(response.status).to eq(201)
+    end
+  end
+
+  describe 'PUT /posts' do
+    it 'returns a 200 status' do
+      response = rt.put '/posts'
+      expect(response.status).to eq(200)
+    end
+  end
+
+  describe 'DELETE /posts' do
+    it 'returns a 201 status' do
+      response = rt.delete '/posts'
+      expect(response.status).to eq(201)
+    end
+  end
+
+  describe 'GET /state' do
+    it 'does not maintain state between requests' do
+      response = rt.get '/state'
+      expect(response.body).to eq('1')
+
+      response = rt.get '/state'
+      expect(response.body).to eq('1')
+    end
+  end
+
+  describe 'before and after filters GET /' do
+    it 'comes out in the correct order' do
+      order = []
+
+      cats = Class.new(Eldr::App)
+      cats.after { order << :after }
+      cats.before { order << :before }
+
+      cats.get'/' do
+        order << :action
+        Rack::Response.new("Cats!", 200)
+      end
+
+      app_a = cats.new
+
+      app_b = Rack::Builder.new do
+        run app_a
+      end
+
+      rt2 = Rack::Test::Session.new(app_b)
+      rt2.get '/'
+      expect(order).to eq([:before, :action, :after])
+    end
+  end
+
+  describe 'GET /raises-an-error' do
+    it 'returns a 404 status' do
+      response = rt.get '/raises-an-error'
+      expect(response.status).to eq(404)
+    end
+  end
+
+  describe 'GET /defer' do
+    it 'defers a route' do
+      response = rt.get '/deferred'
+      expect(response.body).to eq('Deferred!')
+    end
+  end
+
+  describe 'GET /posts/:id' do
+    it 'returns a posts id' do
+      response = rt.get '/posts/bob'
+      expect(response.body).to eq('bob')
+    end
+  end
+end

data/spec/examples/hello_world_spec.rb

@@ -0,0 +1,17 @@
+describe 'HelloWorldExample' do
+  let(:app) do
+    path = File.expand_path("../../examples/hello_world.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /' do
+    it 'returns hello world' do
+      response = rt.get '/'
+      expect(response.body).to eq('Hello World!')
+    end
+  end
+end

data/spec/examples/inheritance_spec.rb

@@ -0,0 +1,23 @@
+describe 'InheritedApp' do
+  let(:app) do
+    path = File.expand_path("../../examples/inheritance.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /' do
+    it 'counts using counter middleware' do
+      response = rt.get '/'
+      expect(response.body).to eq('1')
+    end
+  end
+
+  describe '.configuration#bob' do
+    it 'returns "what about him?"' do
+      expect(app.configuration.bob).to eq('what about him?')
+    end
+  end
+end

data/spec/examples/multiple_apps_spec.rb

@@ -0,0 +1,31 @@
+describe 'MultipleAppsExample' do
+  let(:app) do
+    path = File.expand_path("../../examples/multiple_apps.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /' do
+    it 'returns hello world' do
+      response = rt.get '/'
+      expect(response.body).to eq('Hello World EXAMPLE!')
+    end
+  end
+
+  describe 'GET /cats' do
+    it 'returns cats' do
+      response = rt.get '/cats'
+      expect(response.body).to eq('Hello Cats!')
+    end
+  end
+
+  describe 'GET /dogs' do
+    it 'returns dogs' do
+      response = rt.get '/dogs'
+      expect(response.body).to eq('Hello Dogs!')
+    end
+  end
+end

data/spec/examples/rails_style_routing_spec.rb

@@ -0,0 +1,17 @@
+describe 'RailsStyleRoutingExample' do
+  let(:app) do
+    path = File.expand_path("../../examples/rails_style_routing.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /cats' do
+    it 'returns a greeting from cats' do
+      response = rt.get '/cats'
+      expect(response.body).to eq('Hello from all the Cats!')
+    end
+  end
+end

data/spec/examples/rendering_templates_spec.rb

@@ -0,0 +1,26 @@
+describe 'RenderingTemplatesExample' do
+  let(:app) do
+    path = File.expand_path("../../examples/rendering_templates.ru", File.dirname(__FILE__))
+    Rack::Builder.parse_file(path).first
+  end
+
+  let(:rt) do
+    Rack::Test::Session.new(app)
+  end
+
+  describe 'GET /cats' do
+    it "should return a template" do
+      response = rt.get '/cats'
+      file_path = File.expand_path("../../examples/views/cats.slim", File.dirname(__FILE__))
+      expect(response.body).to eq Tilt.new(file_path).render()
+    end
+  end
+
+  describe 'GET /no-template' do
+    it 'returns 404' do
+      response = rt.get '/no-template'
+      expect(response.status).to eq(404)
+      expect(response.body).to eq('Template Not Found')
+    end
+  end
+end

data/spec/matcher_spec.rb

@@ -0,0 +1,21 @@
+describe Eldr::Matcher do
+  describe '#match' do
+    let(:matcher) { Eldr::Matcher.new('/cats/:id') }
+
+    context 'when pattern matches' do
+      it 'returns MatchData' do
+        expect(matcher.match('/cats/bob')).to be_instance_of MatchData
+      end
+
+      it 'returns the splats' do
+        expect(matcher.match('/cats/bob')[:id]).to eq('bob')
+      end
+    end
+
+    context 'when pattern does not match' do
+      it 'returns nil' do
+        expect(matcher.match('/dogs/bob')).to be_nil
+      end
+    end
+  end
+end

data/spec/readme_definitions.yml

@@ -0,0 +1,28 @@
+has_hook: true
+links_to_badges: true
+has_simple_example: true
+are_rack_apps: true
+installation_instructions: true
+features_list: true
+has_quickstart: true
+quickstart:
+  has_rundown: true
+  templates: true
+  helpers: true
+  rails_style_routing: true
+  rails_style_responses: true
+  rails_style_requests: true
+  extensions: true
+  builder: true
+  redirects: true
+  handlers:
+    call: true
+    any_object: true
+    action_objects: true
+    action_objects_example: true
+  testing: true
+has_rack_loop: true
+mentions_examples_folder: true
+has_help: true
+has_license: true
+has_contributing: true