RubyGems - lydia - Versions diffs - 0.1.0 - Mend

lydia 0.1.0

Files changed (37) hide show

data/lib/lydia/standard_pages.rb ADDED Viewed

@@ -0,0 +1,18 @@
+module Lydia
+  module StandardPages
+    def not_found(env = nil)
+      message = "<html><body><h1>Not Found</h1><p>No route matches #{env['REQUEST_METHOD']} #{env['PATH_INFO']}</p></body></html>"
+      [404, {'Content-Type' => 'text/html', 'Content-Length' => message.length.to_s}, [message]]
+    end
+    def internal_server_error(_env = nil, exception = nil)
+      message = "<html><body><h1>Internal server error</h1><p>#{exception}</p></body></html>"
+      [500, {'Content-Type' => 'text/html', 'Content-Length' => message.length.to_s}, [message]]
+    end
+    def halted(_env = nil)
+      message = "<html><body><h1>Application halted</h1></body></html>"
+      [500, {'Content-Type' => 'text/html', 'Content-Length' => message.length.to_s}, [message]]
+    end
+  end
+end

data/lib/lydia/templates.rb ADDED Viewed

@@ -0,0 +1,10 @@
+require 'tilt'
+module Lydia
+  module Templates
+    def render(file, scope = nil, locals = {}, &block)
+      template = Tilt.new(file)
+      template.render(scope, locals, &block)
+    end
+  end
+end

data/lib/lydia/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Lydia
+  VERSION = "0.1.0"
+end

data/lydia.gemspec ADDED Viewed

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lydia/version'
+Gem::Specification.new do |spec|
+  spec.name          = 'lydia'
+  spec.version       = Lydia::VERSION
+  spec.authors       = ['Mirko Mignini']
+  spec.email         = ['mirko.mignini@gmail.com']
+  spec.summary       = %q{Lightweight, fast and easy to use small ruby web framework.}
+  spec.description   = %q{Lightweight, fast and easy to use small ruby web framework.}
+  spec.homepage      = 'https://github.com/MirkoMignini/lydia'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rack-test'
+  spec.add_dependency 'rack'
+  spec.add_dependency 'tilt'
+end

data/spec/application_spec.rb ADDED Viewed

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'rack/test'
+require 'rack/response'
+require 'erb'
+require 'lydia/application'
+describe "Application" do
+  include Rack::Test::Methods
+  class API < Lydia::Application
+    get '/users' do
+      'Api call'
+    end
+  end
+  class TestApplication < Lydia::Application
+    use Rack::Lint
+    map '/api' do
+      run API
+    end
+    get '/response' do
+      respond_to?(:response).to_s
+    end
+    get '/empty' do
+    end
+    get '/rack_response' do
+      Rack::Response.new(['Rack response'])
+    end
+  end
+  def app
+    TestApplication
+  end
+  context 'Composition' do
+    it 'GET /api/users' do
+      get '/api/users'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('Api call')
+    end
+  end
+  context 'Response' do
+    it 'Response is handled' do
+      get '/response'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('true')
+    end
+    it 'Returns empty' do
+      get '/empty'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('')
+    end
+    it 'Returns Rack::Response' do
+      get '/rack_response'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('Rack response')
+    end
+  end
+end

data/spec/delegator_spec.rb ADDED Viewed

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'rack/test'
+require 'lydia/delegator'
+extend Lydia::Delegator
+describe 'Delegator' do
+  include Rack::Test::Methods
+  class TestDelegator
+    extend Lydia::Delegator
+    get '/hello' do
+      'Hello world!'
+    end
+  end
+  def app
+    Lydia::Application.new
+  end
+  it 'Delegator initialize correctly' do
+    expect(1).to eq(1)
+  end
+  it 'Delegates to Application' do
+    get '/hello'
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq('Hello world!')
+  end
+end

data/spec/filters_spec.rb ADDED Viewed

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'rack/test'
+require 'lydia/application'
+describe "Filters" do
+  include Rack::Test::Methods
+  class TestFilters < Lydia::Application
+    before do
+      @filter = 'before'
+    end
+    after do
+      @filter = 'after'
+    end
+    get '/filter' do
+      @filter
+    end
+    redirect '/redirect', to: '/redirected'
+    get '/redirected' do
+      'redirected'
+    end
+    namespace '/namespace' do
+      before do
+        @filter_nested = 'before'
+      end
+      after do
+        @filter_nested = 'after'
+      end
+      redirect '/redirect', to: '/redirected'
+      get '/redirected' do
+        'redirected in namespace'
+      end
+      get '/filter' do
+        "#{@filter} #{@filter_nested}"
+      end
+    end
+  end
+  def app
+    TestFilters.new
+  end
+  context 'Before & after' do
+    context 'Root' do
+      it 'works without pattern' do
+        get '/filter'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('before')
+      end
+    end
+    context 'Namespace' do
+      it 'works without pattern' do
+        get '/namespace/filter'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('before before')
+      end
+    end
+  end
+  context 'Redirect' do
+    context 'Root' do
+      it 'redirects' do
+        get '/redirect'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('redirected')
+      end
+    end
+    context 'Namespace' do
+      it 'redirects' do
+        get '/namespace/redirect'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('redirected in namespace')
+      end
+    end
+  end
+end

data/spec/helpers_spec.rb ADDED Viewed

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'rack/test'
+require 'lydia/application'
+describe "Helpers" do
+  include Rack::Test::Methods
+  class TestHelpers < Lydia::Application
+    get '/content_type' do
+      content_type 'application/json'
+      'body'
+    end
+    get '/redirect' do
+      redirect '/new_url'
+    end
+    get '/params' do
+      params['key']
+    end
+  end
+  def app
+    TestHelpers.new
+  end
+  it 'responds to content_type' do
+    get '/content_type'
+    expect(last_response.status).to eq(200)
+    expect(last_response.header['Content-Type']).to eq('application/json')
+    expect(last_response.body).to eq('body')
+  end
+  it 'Handles redirect' do
+    get '/redirect'
+    expect(last_response.status).to eq(302)
+    expect(last_response.body).to eq('/new_url')
+  end
+  it 'responds to params' do
+    get '/params', {key: 'value'}
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq('value')
+  end
+end

data/spec/middleware_spec.rb ADDED Viewed

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'rack/test'
+require 'erb'
+require 'json'
+require 'lydia/application'
+describe "Middleware" do
+  include Rack::Test::Methods
+  class UpcaseMiddleware
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      result = @app.call(env)
+      result[2].body[0] = result[2].body[0].upcase
+      result
+    end
+  end
+  class TestMiddleware < Lydia::Application
+    use UpcaseMiddleware
+    get '/hello' do
+      'Hello world!'
+    end
+  end
+  def app
+    TestMiddleware.new
+  end
+  context 'Middleware stack' do
+    it 'is correctly handled' do
+      get '/hello'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('HELLO WORLD!')
+    end
+  end
+end

data/spec/response_spec.rb ADDED Viewed

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'lydia/response'
+describe 'Response' do
+  let (:response) { Lydia::Response.new }
+  context 'initialization' do
+    it 'is created' do
+      expect(response).to_not be_nil
+    end
+    it 'contains default content type' do
+      expect(response.headers).to include('Content-Type' => 'text/html')
+    end
+  end
+  context 'build' do
+    it 'responds to build' do
+      expect(response).to respond_to(:build)
+    end
+    it 'builds using a string (body)' do
+      body = 'Hello world!'
+      result = response.build(body)
+      expect(result).to_not be_nil
+      expect(result).to be_an(Array)
+      expect(result[0]).to eq(200)
+      expect(result[1]).to include('Content-Type' => 'text/html')
+      expect(result[1]).to include('Content-Length' => body.length.to_s)
+      expect(result[2].body).to be_an(Array)
+      expect(result[2].body[0]).to eq(body)
+    end
+    it 'builds using a fixnum (status)' do
+      status = 204
+      result = response.build(status)
+      expect(result).to_not be_nil
+      expect(result).to be_an(Array)
+      expect(result[0]).to eq(204)
+      expect(result[1]).to_not include('Content-Type')
+      expect(result[1]).to_not include('Content-Length')
+      expect(result[2]).to be_an(Array)
+      expect(result[2][0]).to be_nil
+    end
+    it 'builds using a hash (body)' do
+      body = {hello: 'world'}
+      result = response.build(body)
+      expect(result).to_not be_nil
+      expect(result).to be_an(Array)
+      expect(result[0]).to eq(200)
+      expect(result[1]).to include('Content-Type' => 'application/json')
+      expect(result[1]).to include('Content-Length' => body.to_json.length.to_s)
+      expect(result[2].body).to be_an(Array)
+      expect(result[2].body[0]).to eq(body.to_json)
+    end
+    it 'builds using an array of two (body is array)' do
+      body = [201, ['Body']]
+      result = response.build(body)
+      expect(result).to_not be_nil
+      expect(result).to be_an(Array)
+      expect(result[0]).to eq(201)
+      expect(result[1]).to include('Content-Type' => 'text/html')
+      expect(result[1]).to include('Content-Length' => body[1][0].length.to_s)
+      expect(result[2].body).to be_an(Array)
+      expect(result[2].body[0]).to eq(body[1][0])
+    end
+    it 'builds using an array of two (body is noy an array)' do
+      body = [201, 'Body']
+      result = response.build(body)
+      expect(result).to_not be_nil
+      expect(result).to be_an(Array)
+      expect(result[0]).to eq(201)
+      expect(result[1]).to include('Content-Type' => 'text/html')
+      expect(result[1]).to include('Content-Length' => body[1].length.to_s)
+      expect(result[2].body).to be_an(Array)
+      expect(result[2].body[0]).to eq(body[1])
+    end
+    it 'builds using an array of three' do
+      body = [201, {'Authentication' => '12345'}, 'Body']
+      result = response.build(body)
+      expect(result).to_not be_nil
+      expect(result).to be_an(Array)
+      expect(result[0]).to eq(201)
+      expect(result[1]).to include('Content-Type' => 'text/html')
+      expect(result[1]).to include('Content-Length' => body[2].length.to_s)
+      expect(result[1]).to include('Authentication' => '12345')
+      expect(result[2].body).to be_an(Array)
+      expect(result[2].body[0]).to eq(body[2])
+    end
+    class Stream
+      def each
+        10.times { |i| yield "#{i}" }
+      end
+    end
+    context 'Stream' do
+      it 'builds a valid stream object' do
+        stream = ''
+        Stream.new.each{ |i| stream += i }
+        expect(stream).to eq('0123456789')
+      end
+      it 'builds using an object that responds to :each' do
+        result = response.build(Stream.new)
+        expect(result).to_not be_nil
+        expect(result).to be_an(Array)
+        expect(result[0]).to eq(200)
+        expect(result[1]).to include('Content-Type' => 'text/html')
+        expect(result[1]).to include('Content-Length')
+        expect(result[2].body).to be_an(Array)
+        expect(result[2].body[0]).to_not be_nil
+      end
+    end
+    it 'returns ArgumentError if object is not allowed' do
+      expect {
+        response.build(nil)
+      }.to raise_error(ArgumentError)
+    end
+  end
+end