rosendo 0.0.1

data/LICENSE

@@ -0,0 +1,16 @@
+Copyright (c) 2013 Sergio Gil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+# Rosendo [![Build Status](https://travis-ci.org/porras/rosendo.png)](https://travis-ci.org/porras/rosendo)
+
+Rosendo is a minimalistic and naive [Sinatra](http://sinatrarb.com) reimplementation, without any
+dependencies other than the ruby socket library. It's a learning exercise on the HTTP specs, web
+servers, and how not to write software. It contains a (stupidly simple) HTTP server, a (rather
+incomplete) HTTP parser and a (really oversimplified) DSL.
+
+**Rosendo is not intended for any production use. Specifically, *it's not intended as a Sinatra
+replacement*. It has much less features, for sure much more bugs, and probably much worse
+performance. It's just a learning exercise.**
+
+This ongoing exercise is a game, whose rules (invented by myself) consist in reimplementing a web
+framework (Sinatra is far better for this purpose than my other favorite framework Rails, for
+obvious reasons) from scratch, using just Ruby. I wanted to prevent myself from using anything from
+the standard library, but probably making this without the socket library would be too much, so
+that's the only allowed exception. Still, no webrick, no erb, no nothing, and obviously no gems.
+
+The rule doesn't apply to the tests though (I'm using minitest and Net::HTTP).
+
+The purpose of the game/exercise comes from a reflection about how much software we usually depend
+on when writing our applications (just run `bundle show` in your last Rails app if you don't believe
+me) and is double:
+
+1) Remember that the software we take for granted and like to whine about some times, it's actually
+great software we should thank for every minute we're using it. Trying to live without it for some
+time is a great way to achieve this.
+
+2) At the same time, demystifying it. Not everybody can write such good web servers like the ones we
+use everyday, but everybody can write the simplest one. And understanding a bit how they work is a
+great thing, even if you're not obviously going to write a web server every time you want to write a
+web app. The same is true for every other piece of the stack.
+
+## Usage
+
+Install it via Rubygems or Bundler, require it, and pretend it's Sinatra:
+
+    require 'rosendo'
+    
+    class MyApp < Rosendo::App
+      get "/" do
+        "Hello, World!"
+      end
+    end
+    
+    MyApp.run!(port: 2000)
+
+## Features
+
+### Sinatra features that Rosendo supports
+
+* Route mapping methods (`get`, `post`, ...)
+* Headers reading and setting
+* Basic params in URL (`/hello/:name`)
+* HTTP status code
+* Redirects
+* Params in query string
+
+### Sinatra features that Rosendo plans to support
+
+* Form params in request body
+* Templates
+
+### Sinatra features that Rosendo doesn't plan to support (for the moment)
+
+* Advanced route patterns (*, regular expressions, conditions, ...)
+* Filters
+* Helpers
+* Variables (`set` method)
+* Cookies
+* Sessions
+* Config blocks
+* Rack compliance
+* Streaming
+* Logging
+* *Classic* mode
+* Static files
+
+See [`example.rb`](https://github.com/porras/rosendo/blob/master/example.rb) for some supported things.
+
+[Rosendo](http://en.wikipedia.org/wiki/Rosendo_Mercado) is also the name of the most charismatic
+Spanish rock singer and songwriter ever.
+
+[![Rosendo Mercado](http://upload.wikimedia.org/wikipedia/commons/thumb/5/5a/Rosendo_-_11.jpg/320px-Rosendo_-_11.jpg)](http://en.wikipedia.org/wiki/Rosendo_Mercado)
+
+## License
+
+Released under the [MIT license](https://github.com/porras/rosendo/blob/master/LICENSE).

data/example.rb

@@ -0,0 +1,43 @@
+require './lib/rosendo'
+
+class Example < Rosendo::App
+  get '/' do
+    'Hola mundo'
+  end
+  
+  get '/wadus' do
+    'Hola wadus'
+  end
+  
+  get '/hello/:name/:surname' do
+    "#{params[:surname]}, #{params[:name]}"
+  end
+  
+  get '/berlin' do
+    'Hola Berlin'
+  end
+  
+  get '/headers' do
+    headers 'X-Wadus' => 'Wadus!!'
+    "Received headers: #{request.env.inspect}"
+  end
+  
+  get '/status/:code' do
+    status params[:code].to_i
+    "#{params[:code]} Invented Status"
+  end
+  
+  get '/redirect' do
+    redirect '/'
+  end
+  
+  get '/params' do
+    params.inspect
+  end
+  
+  get '/exception' do
+    raise 'Catacrocker'
+  end
+end
+
+Example.run!(port: 2000)

data/lib/rosendo.rb

@@ -0,0 +1,8 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rosendo/server'
+require 'rosendo/request'
+require 'rosendo/response'
+require 'rosendo/app'
+require 'rosendo/routes'
+require 'rosendo/dsl'

data/lib/rosendo/app.rb

@@ -0,0 +1,35 @@
+module Rosendo
+  class App
+    class << self
+      %w{GET POST PUT DELETE}.each do |method|
+        define_method method.downcase do |*args, &block|
+          routes.add(method, *args, &block)
+        end
+      end
+      
+      def run!(options = {})
+        Server.new(self, options).start
+      end
+      
+      def process(request, response)
+        if route = routes.for(request)
+          response.body = begin
+            route.call(request, response)
+          rescue Exception => e
+            response.status = 500
+            e.inspect + "\n\n" + e.backtrace.join("\n")
+          end
+        else
+          response.status = 404
+          response.body = "404 Not Found"
+        end
+      end
+      
+      private
+      
+      def routes
+        @routes ||= Routes.new
+      end
+    end
+  end
+end

data/lib/rosendo/dsl.rb

@@ -0,0 +1,24 @@
+module Rosendo
+  class DSL
+    attr_reader :request, :params
+    def initialize(request, response, params)
+      @request = request
+      @response = response
+      @params = params
+    end
+    
+    def headers(extra = {})
+      @response.headers.merge!(extra)
+    end
+    
+    def status(code)
+      @response.status = code
+    end
+    
+    def redirect(url, code = 302, content = "")
+      status code
+      headers 'Location' => url
+      content
+    end
+  end
+end

data/lib/rosendo/request.rb

@@ -0,0 +1,27 @@
+module Rosendo
+  class Request
+    attr_reader :method, :url, :headers
+    alias_method :env, :headers
+    def initialize(io)
+      @io = io
+      @method, @url = @io.gets.match(%r{(GET|POST|PUT|DELETE)\s(.+)\sHTTP/1\.1})[1..2]
+      @headers = read_headers
+    end
+
+    def params
+      {}
+    end
+
+    private
+    
+    def read_headers
+      {}.tap do |h|
+        while line = @io.gets.chomp
+          break if line.empty?
+          m = line.match(%r{^([\w\-]+):\s(.+)$})
+          h[m[1]] = m[2]
+        end
+      end
+    end
+  end
+end

data/lib/rosendo/response.rb

@@ -0,0 +1,34 @@
+module Rosendo
+  class Response
+    attr_accessor :status, :headers, :body
+    def initialize(io)
+      @io = io
+      @headers = {}
+    end
+    
+    def status
+      @status || 200
+    end
+    
+    def body
+      @body || ''
+    end
+    
+    def respond
+      @io.puts status_line
+      @io.puts header_lines
+      @io.puts
+      @io.write body # write instead of puts for no extra newline
+      @io.close
+    end
+
+    def status_line
+      "HTTP/1.1 #{status}"
+    end
+
+    def header_lines
+      {'Content-Length' => body.size}.merge(@headers).map { |k, v| "#{k}: #{v}" }.join("\n")
+    end
+
+  end
+end

data/lib/rosendo/routes.rb

@@ -0,0 +1,86 @@
+module Rosendo
+  class Routes
+    def initialize
+      @routes = []
+    end
+    
+    def <<(route)
+      @routes << route
+    end
+    
+    def for(request)
+      @routes.detect { |route| route.matches?(request) }
+    end
+    
+    def add(method, path, &block)
+      self << Route.new(method, path, &block)
+    end
+    
+    class Route
+      attr_reader :method, :path
+      def initialize(method, path, &block)
+        @method = method
+        @path = Path.new(path)
+        @block = block
+      end
+      
+      def matches?(request)
+        method == request.method &&
+        path.matches?(request.url)
+      end
+    
+      def call(request, response)
+        DSL.new(request, response, path.params(request.url)).instance_eval(&@block)
+      end
+      
+      class Path
+        def initialize(path)
+          @path = path
+          @regexp, @keys = parse
+        end
+        
+        def matches?(url)
+          url = URL.new(url)
+          url.path =~ @regexp
+        end
+        
+        def params(url)
+          url = URL.new(url)
+          match = url.path.match(@regexp)
+          {}.tap do |params|
+            @keys.each_with_index do |key, i|
+              params[key] = match[i + 1]
+            end
+          end.merge(url.query_params)
+        end
+        
+        def parse
+          keys = []
+          pattern = @path.gsub(/:(\w+)/) do |match|
+            keys << $1.to_sym
+            '(\w+)'
+          end
+          [Regexp.new("^#{pattern}$"), keys]
+        end
+        
+        class URL
+          attr_reader :url, :path, :query
+          def initialize(url)
+            @url = url
+            @path, @query = url.split('?')
+          end
+          
+          def query_params
+            return {} unless query
+            {}.tap do |params|
+              query.split('&').each do |pair|
+                k, v = pair.split('=')
+                params[k.to_sym] = v
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rosendo/server.rb

@@ -0,0 +1,37 @@
+require 'socket'
+
+module Rosendo
+  class Server
+    class Stop < Exception; end
+    
+    attr_reader :port, :out
+    def initialize(app, args = {})
+      @app = app
+      @port = args[:port] || '2000'
+      @out = args[:out] || STDOUT
+    end
+
+    def start
+      out.puts "== Rosendo is rocking the stage on #{port}"
+      out.puts ">> Listening on 0.0.0.0:#{port}, CTRL+C to stop"
+      
+      loop do
+        begin
+          client = server.accept
+          request = Request.new(client)
+          response = Response.new(client)
+          @app.process(request, response)
+          response.respond
+          out.puts "#{request.method} #{request.url} #{response.status} #{response.body.size}"
+        rescue Stop
+          server.close
+          out.puts "== Rosendo has left the building (everybody goes crazy)"
+        end
+      end
+    end
+
+    def server
+      @server ||= TCPServer.new(@port)
+    end
+  end
+end

data/test/integration/basic_test.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+require 'rosendo'
+
+class BasicTest < IntegrationTest
+  def test_hello_world
+    app do
+      get('/') { 'Hello, World!' }
+    end
+    
+    get '/'
+    
+    assert_equal(200, response.status)
+    assert_equal('Hello, World!', response.body)
+  end
+  
+  def test_simple_route
+    app do
+      get('/wadus') { 'Wadus' }
+    end
+    
+    get '/wadus'
+    
+    assert_equal(200, response.status)
+    assert_equal('Wadus', response.body)
+  end
+  
+  def test_not_found
+    app do
+      get('/') { 'Hello' }
+    end
+    
+    get '/foo'
+    
+    assert_equal(404, response.status)
+    assert_equal('404 Not Found', response.body)
+  end
+  
+  def test_content_size
+    app do
+      get('/') { 'a' * rand(1000) }
+    end
+    
+    get '/'
+    
+    assert_equal(response.body.size, response.headers['content-length'][0].to_i)
+  end
+  
+  def test_params_in_url
+    app do
+      get('/hello/:name/:surname') { "Hola, #{params[:name].capitalize} #{params[:surname].capitalize}"}
+    end
+    
+    get '/hello/rosendo/mercado'
+    
+    assert_equal(200, response.status)
+    assert_equal('Hola, Rosendo Mercado', response.body)
+  end
+  
+  def test_read_headers
+    app do
+      get('/headers') { request.env['X-Wadus'] }
+    end
+    
+    get '/headers', 'X-Wadus' => 'Wadus'
+    
+    assert_equal(200, response.status)
+    assert_equal('Wadus', response.body)
+  end
+  
+  def test_set_headers
+    app do
+      get('/headers') do
+        headers('X-Wadus' => 'Wadus')
+        'Header set'
+      end
+    end
+    
+    get '/headers'
+    
+    assert_equal(200, response.status)
+    assert_equal('Header set', response.body)
+    assert_equal(['Wadus'], response.headers['x-wadus'])  # header names are case insensitive per RFC,
+                                                          # and Net::HTTP seems to implement this simply
+                                                          # downcasing them. Also, it returns a list
+  end
+  
+  def test_status_code
+    app do
+      get('/status/:code') do
+        status params[:code].to_i
+        "#{params[:code]} Invented Status"
+      end
+    end
+    
+    get '/status/234'
+    
+    assert_equal(234, response.status)
+    assert_equal('234 Invented Status', response.body)
+  end
+  
+  def test_redirect
+    app do
+      get('/') { redirect '/home' }
+    end
+    
+    get '/'
+    
+    assert_equal(302, response.status)
+    assert_equal(['/home'], response.headers['location'])
+  end
+  
+  def test_params
+    app do
+      get('/params') { "a: #{params[:a]}; b: #{params[:b]}" }
+    end
+    
+    get '/params?a=AAA&b=BBB'
+    
+    assert_equal(200, response.status)
+    assert_equal("a: AAA; b: BBB", response.body)
+  end
+  
+  def test_exception
+    app do
+      get('/exception') { raise 'Catacrocker' }
+    end
+    
+    get '/exception'
+    
+    assert_equal(500, response.status)
+    assert_match('Catacrocker', response.body)
+    assert_match(__FILE__, response.body)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,60 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'net/http'
+require 'uri'
+
+module TestHelper
+  module IntegrationHelper
+    PORT = 2600
+    BASE_URL = "http://localhost:#{PORT}"
+    
+    def app(&block)
+      Thread.current[:app] = Thread.new do
+        Class.new(Rosendo::App, &block).run!(port: PORT, out: File.open(File::NULL, "w"))
+      end
+      sleep (ENV['WAIT'] && ENV['WAIT'].to_f) || 0.001
+    end
+    
+    def get(path, headers = {})
+      uri = URI.parse(BASE_URL + path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      response = http.get(path, headers)
+      @last_response = Response.new(response)
+    end
+    
+    def response
+      @last_response
+    end
+    
+    class Response
+      def initialize(response)
+        @response = response
+      end
+      
+      def body
+        @response.body
+      end
+      
+      def status
+        @response.code.to_i
+      end
+      
+      def headers
+        @response.to_hash
+      end
+    end
+  end
+end
+
+class UnitTest < MiniTest::Unit::TestCase
+  include TestHelper
+end
+
+class IntegrationTest < UnitTest
+  include IntegrationHelper
+  
+  def teardown
+    return unless app = Thread.current[:app]
+    app.raise Rosendo::Server::Stop
+  end
+end

data/test/unit/sample_test.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class SampleTest < UnitTest
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: rosendo
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sergio Gil
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-03-24 00:00:00 Z
+dependencies: []
+
+description: 
+email: sgilperez@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- LICENSE
+- example.rb
+- lib/rosendo/app.rb
+- lib/rosendo/dsl.rb
+- lib/rosendo/request.rb
+- lib/rosendo/response.rb
+- lib/rosendo/routes.rb
+- lib/rosendo/server.rb
+- lib/rosendo.rb
+- test/integration/basic_test.rb
+- test/test_helper.rb
+- test/unit/sample_test.rb
+homepage: http://github.com/porras/rosendo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Minimalistic and naive Sinatra reimplementation, without any dependencies other than the ruby socket library
+test_files: []
+
+has_rdoc: