lydia 0.1.3 → 0.1.4

data/lib/lydia/halted.rb

@@ -6,4 +6,4 @@ module Lydia
       super
     end
   end
-end
+end

data/lib/lydia/helpers.rb

@@ -3,17 +3,17 @@ module Lydia
     def content_type(content)
       @response.header['Content-Type'] = content
     end
-    
+
     def redirect(target, status = 302)
       [status, target]
     end
-    
+
     def params
       @request.params
     end
-    
+
     def send_file(_path, _mime_type = nil)
-      raise NotImplementedError.new
+      raise(NotImplementedError, 'Send file not yet implemented.')
     end
   end
-end
+end

data/lib/lydia/not_found.rb

@@ -1,4 +1,4 @@
 module Lydia
-  class NotFound < StandardError 
+  class NotFound < StandardError
   end
 end

data/lib/lydia/request.rb

@@ -1,6 +1,6 @@
 require 'rack/request'
 
 module Lydia
-  class Request < Rack::Request 
+  class Request < Rack::Request
   end
-end
+end

data/lib/lydia/response.rb

@@ -2,46 +2,58 @@ require 'rack/response'
 require 'json'
 
 module Lydia
-  class Response < Rack::Response    
+  class Response < Rack::Response
     def initialize(*)
       super
       headers['Content-Type'] = 'text/html' if headers['Content-Type'].nil?
     end
-    
+
     def build(input)
-      case input.class.to_s
-        when 'String'
-          write input
-        when 'Array'
-          @status = input.first
-          write input.last.is_a?(Array) ? input.last[0] : input.last
-          headers.merge!(input[1]) if input.count == 3        
-        when 'Fixnum'
-          @status = input
-        when 'Hash'
-          headers['Content-Type'] = 'application/json'
-          write input.to_json        
-        else
-          if input.respond_to?(:each)
-            write input
-          else  
-            raise ArgumentError.new("#{input.class} is not a valid allowed return type")
-          end
+      input_class = input.class.to_s.downcase
+      if %w(string array fixnum hash).include?(input_class)
+        send("build_#{input_class}", input)
+      else
+        build_default(input)
       end
       finish
     end
-    
+
     def finish(&block)
       @block = block
-
       if [204, 205, 304].include?(status.to_i)
-        headers.delete 'Content-Length'
-        headers.delete 'Content-Type'
+        headers.delete('Content-Length')
+        headers.delete('Content-Type')
         close
         [status.to_i, header, []]
       else
         [status.to_i, header, @body]
       end
-    end    
+    end
+
+    private
+
+    def build_string(input)
+      write(input)
+    end
+
+    def build_array(input)
+      @status, *, body = input
+      write(body.is_a?(Array) ? body[0] : body)
+      headers.merge!(input[1]) if input.count == 3
+    end
+
+    def build_fixnum(input)
+      @status = input
+    end
+
+    def build_hash(input)
+      headers['Content-Type'] = 'application/json'
+      write(input.to_json)
+    end
+
+    def build_default(input)
+      return write(input) if input.respond_to?(:each)
+      raise(ArgumentError, "#{input.class} is not a valid allowed return type")
+    end
   end
 end

data/lib/lydia/route.rb

@@ -1,9 +1,9 @@
 module Lydia
-  class Route    
+  class Route
     attr_reader :regexp, :params, :request_method, :namespace, :pattern, :options, :block
-    
-    WILDCARD_REGEX = /\/\*(.*)/.freeze
-    NAMED_SEGMENTS_REGEX = /\/([^\/]*):([^:$\/]+)/.freeze
+
+    WILDCARD_REGEX = %r{\/\*(.*)}
+    NAMED_SEGMENTS_REGEX = %r{\/([^\/]*):([^:$\/]+)}
 
     def initialize(request_method, namespace, pattern, options = {}, &block)
       @request_method = request_method
@@ -11,27 +11,35 @@ module Lydia
       @pattern = pattern
       @options = options
       @block = block
-      if pattern.is_a? String
-        path = (namespace || '') + pattern
-        if path.match(WILDCARD_REGEX)
-          result = path.gsub(WILDCARD_REGEX, '(?:/(.*)|)')
-        elsif path.match(NAMED_SEGMENTS_REGEX)
-          result = path.gsub(NAMED_SEGMENTS_REGEX, '/\1(?<\2>[^.$/]+)')
-        else
-          result = path
-        end
-        @regexp = Regexp.new("\\A#{result}\\z")
-      elsif pattern.is_a?(Regexp)
-        @regexp = Regexp.new((namespace || '') + pattern.to_s)
-      else
-        raise ArgumentError.new('Pattern must be a string or a regex')
-      end
+      @regexp = init_regexp
     end
 
     def match?(env)
-      match = @regexp.match("#{env['PATH_INFO']}")
-      @params = Hash[match.names.map(&:to_sym).zip(match.captures)] if match && match.names.size
+      match = @regexp.match((env['PATH_INFO']).to_s)
+      if match && match.names.size
+        @params = Hash[match.names.map(&:to_sym).zip(match.captures)]
+      end
       match
     end
-  end 
+
+    private
+
+    def init_regexp
+      return regexp_from_string if @pattern.is_a? String
+      return Regexp.new((@namespace || '') + @pattern.to_s) if @pattern.is_a?(Regexp)
+      raise(ArgumentError, 'Pattern must be a string or a regex')
+    end
+
+    def regexp_from_string
+      path = (@namespace || '') + @pattern
+      result = if path.match(WILDCARD_REGEX)
+        path.gsub(WILDCARD_REGEX, '(?:/(.*)|)')
+      elsif path.match(NAMED_SEGMENTS_REGEX)
+        path.gsub(NAMED_SEGMENTS_REGEX, '/\1(?<\2>[^.$/]+)')
+      else
+        path
+      end
+      Regexp.new("\\A#{result}\\z")
+    end
+  end
 end

data/lib/lydia/router.rb

@@ -8,20 +8,20 @@ require 'rack/response'
 module Lydia
   class Router
     include StandardPages
-    
+
     attr_reader :request, :response, :env
-    
-    class << self      
+
+    class << self
       def routes
         @routes ||= Hash.new { |h, k| h[k] = [] }
       end
-      
+
       %w(HEAD GET PATCH PUT POST DELETE OPTIONS).each do |request_method|
         define_method(request_method.downcase) do |pattern, options = {}, &block|
           routes[request_method] << Route.new(request_method, @namespace, pattern, options, &block)
         end
       end
-      
+
       def namespace(pattern, _options = {})
         prev_namespace = @namespace ||= ''
         @namespace += pattern
@@ -29,58 +29,57 @@ module Lydia
         @namespace = prev_namespace
       end
     end
-    
+
     def next_route
       throw :next_route
-    end  
-    
+    end
+
     def halt(input = nil)
-      raise Halted.new(input || halted)
+      raise(Halted.new(input || halted), 'Halt')
     end
-    
+
     def call(env)
       dup._call(env)
     end
-    
+
     def _call(env)
       @env = env
       @request = new_request(env)
       @response = new_response
       process
     end
-    
+
     def new_request(env)
       Rack::Request.new(env)
     end
-    
+
     def new_response(body = [], status = 200, header = {})
       Rack::Response.new(body, status, header)
     end
-    
+
     def process
       dispatch(env)
-      rescue NotFound
-        not_found(env)
-      rescue Halted => exception
-        exception.content
-      rescue StandardError => exception
-        internal_server_error(env, exception)
+    rescue NotFound
+      not_found(env)
+    rescue Halted => exception
+      exception.content
+    rescue StandardError => exception
+      internal_server_error(env, exception)
     end
-    
+
     def routes
       self.class.routes
     end
-    
+
     def dispatch(env)
       routes[env['REQUEST_METHOD']].each do |route|
-        if route.match?(env)
-          @request.params.merge!(route.params) if route.params
-          catch(:next_route) do
-            return instance_eval(&route.block)
-          end
+        next unless route.match?(env)
+        @request.params.merge!(route.params) if route.params
+        catch(:next_route) do
+          return instance_eval(&route.block)
         end
       end
-      raise NotFound
-    end  
+      raise(NotFound, 'Not found')
+    end
   end
-end
+end

data/lib/lydia/standard_pages.rb

@@ -1,18 +1,21 @@
-module Lydia  
+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]]
+      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]]      
+      [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]]            
+      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/version.rb

@@ -1,3 +1,3 @@
 module Lydia
-  VERSION = "0.1.3"
+  VERSION = '0.1.4'.freeze
 end

data/lydia.gemspec

@@ -9,12 +9,14 @@ Gem::Specification.new do |spec|
   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.summary       = 'Lightweight, fast and easy to use small ruby web framework.'
+  spec.description   = '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.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
   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) }
@@ -26,7 +28,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rack-test'
   spec.add_development_dependency 'haml'
-  
-  spec.add_dependency 'rack', '~> 1.6.4'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec'
+
+  spec.add_dependency 'rack', '~> 2.0.1'
   spec.add_dependency 'tilt'
 end

data/spec/application_spec.rb

@@ -4,7 +4,7 @@ require 'rack/response'
 require 'erb'
 require 'lydia/application'
 
-describe "Application" do
+describe 'Application' do
   include Rack::Test::Methods
 
   class API < Lydia::Application
@@ -12,30 +12,30 @@ describe "Application" do
       'Api call'
     end
   end
-  
-  class TestApplication < Lydia::Application        
+
+  class TestApplication < Lydia::Application
     use Rack::Lint
 
     map '/api' do
       run API.new
     end
-    
+
     get '/response' do
       respond_to?(:response).to_s
-    end     
-    
+    end
+
     get '/empty' do
     end
-    
+
     get '/rack_response' do
       Rack::Response.new(['Rack response'])
     end
   end
-  
+
   def app
     TestApplication.new
   end
-  
+
   context 'Composition' do
     it 'GET /api/users' do
       get '/api/users'
@@ -43,24 +43,24 @@ describe "Application" do
       expect(last_response.body).to eq('Api call')
     end
   end
-  
-  context 'Response' do  
+
+  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('')      
+      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')      
+      expect(last_response.body).to eq('Rack response')
     end
   end
-end
+end