lydia 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf7ff0ab21d348d83cab7edbf2fc60dc0d2742fa
+  data.tar.gz: 9160af15569f5469cb8f02c30b44cbbe489e196e
+SHA512:
+  metadata.gz: 9a5fcbdeddb34ef8ab94d6408af99f37ddb2bd453196748e578612bb4e5cf821be42d1c074e7a65cc581dec33c8e46315ceeeee00cadb24bf3bf4c638700d9af
+  data.tar.gz: 2415bbd84f8af49363d86877ab5750984594b3581303d32f21a14699ba865e3331fc57bed6690c84db3900f25e991b24a2662ba0e499a5d70ec684523309ab1c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - rbx-2
+  - jruby
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lydia.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Mirko Mignini
+
+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,56 @@
+[![Build Status](https://travis-ci.org/MirkoMignini/lydia.svg)](https://travis-ci.org/MirkoMignini/lydia)
+[![Coverage Status](https://coveralls.io/repos/MirkoMignini/lydia/badge.svg?branch=master&service=github)](https://coveralls.io/github/MirkoMignini/lydia?branch=master)
+[![Code Climate](https://codeclimate.com/github/MirkoMignini/lydia/badges/gpa.svg)](https://codeclimate.com/github/MirkoMignini/lydia)
+
+# Lydia
+
+Lightweight, fast and easy to use small ruby web framework.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lydia'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lydia
+
+## Another ruby web framework? WTF?
+
+This project is not intended to become a top notch framework or the new rails, it's just an experiment. 
+The goals of this project are:
+
+* [Rack](https://github.com/rack/rack/) based.
+* Modular (Router, Application...).
+* A powerful router that works stand alone too.
+* Easy templates support using [Tilt](https://github.com/rtomayko/tilt).
+* Well written, easy to read and to understand code.
+* Less lines of code as possible (but no [code golf](https://en.wikipedia.org/wiki/Code_golf)).
+* [Don't repeat yourself](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself).
+* [100% test code coverage](https://coveralls.io/github/MirkoMignini/lydia?branch=master).
+* [Continuos integration](https://travis-ci.org/MirkoMignini/lydia).
+* Highest codeclimate score and [0 issues](https://codeclimate.com/github/MirkoMignini/lydia/issues).
+
+## Usage
+
+Usage instructions soon available!
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lydia/application"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/hello_world.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'lydia'
+
+get '/' do
+  'Hello world!'
+end

data/lib/lydia.rb

@@ -0,0 +1,10 @@
+require 'rack'
+require 'lydia/application'
+require 'lydia/delegator'
+require 'lydia/version'
+
+module Lydia
+  at_exit { Rack::Handler.default.run(Application) }
+end
+
+extend Lydia::Delegator

data/lib/lydia/application.rb

@@ -0,0 +1,53 @@
+require 'forwardable'
+require 'rack/builder'
+require 'lydia/router'
+require 'lydia/templates'
+require 'lydia/filters'
+require 'lydia/helpers'
+require 'lydia/request'
+require 'lydia/response'
+
+module Lydia
+  class Application < Router
+    include Templates
+    include Filters
+    include Helpers
+    
+    def process
+      result = super
+      if result.nil?
+        @response.build(200)
+      elsif result.class <= Rack::Response
+        result.finish
+      else
+        @response.build(result)
+      end
+    end
+    
+    def new_request(env)
+      Lydia::Request.new(env)
+    end
+    
+    def new_response(body = [], status = 200, header = {})
+      Lydia::Response.new(body, status, header)
+    end
+    
+    class << self
+      extend Forwardable
+      
+      def_delegators :builder, :map, :use, :run
+      
+      def builder
+        @builder ||= Rack::Builder.new
+      end
+
+      alias new! new
+      
+      def new(*args, &bk)
+        app = new!(*args, &bk)
+        builder.run(app)
+        builder.to_app
+      end
+    end
+  end  
+end

data/lib/lydia/delegator.rb

@@ -0,0 +1,12 @@
+require 'lydia/application'
+require 'forwardable'
+
+module Lydia
+  module Delegator
+    extend Forwardable
+    def_delegators  Lydia::Application, 
+                    :head, :get, :patch, :put, :post, :delete, :options,
+                    :namespace, :before, :after,
+                    :map, :use, :run
+  end
+end

data/lib/lydia/filters.rb

@@ -0,0 +1,52 @@
+require 'lydia/route'
+
+module Lydia
+  module Filters
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def filters
+        @filters ||= Hash.new { |h, k| h[k] = [] }
+      end
+      
+      %w(before after).each do |filter|
+        define_method(filter) do |pattern = '/*', options = {}, &block|
+          filters[filter.to_sym] << Route.new(@namespace || '', pattern, options, &block)
+        end
+      end
+      
+      def redirect(pattern, options = {})
+        return ArgumentError.new('Options must contains :to') unless options.include?(:to)
+        filters[:redirect] << Route.new(@namespace || '', pattern, options)
+      end
+    end
+    
+    def dispatch(env)
+      process_redirects(env)
+      process_before_filters(env)
+      result = super(env)
+      process_after_filters(env)
+      result
+    end
+    
+    %w(before after).each do |filter_type|
+      define_method("process_#{filter_type}_filters") do |env|
+        self.class.filters[filter_type.to_sym].each do |filter|
+          instance_eval(&filter.block) if filter.match?(env)
+        end
+      end
+    end
+    
+    def process_redirects(env)
+      self.class.filters[:redirect].each do |redirect|
+        if redirect.match?(env)
+          env['PATH_INFO'] = redirect.namespace + redirect.options[:to]
+          @request = new_request(env)
+          break
+        end
+      end
+    end
+  end
+end

data/lib/lydia/halted.rb

@@ -0,0 +1,9 @@
+module Lydia
+  class Halted < StandardError
+    attr_reader :content
+    def initialize(content)
+      @content = content
+      super
+    end
+  end
+end

data/lib/lydia/helpers.rb

@@ -0,0 +1,19 @@
+module Lydia
+  module Helpers
+    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
+    end
+  end
+end

data/lib/lydia/not_found.rb

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

data/lib/lydia/request.rb

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

data/lib/lydia/response.rb

@@ -0,0 +1,33 @@
+require 'rack/response'
+
+module Lydia
+  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
+      end
+      finish
+    end
+  end
+end

data/lib/lydia/route.rb

@@ -0,0 +1,36 @@
+module Lydia
+  class Route    
+    attr_reader :regexp, :params, :namespace, :pattern, :options, :block
+    
+    WILDCARD_REGEX = /\/\*(.*)/.freeze
+    NAMED_SEGMENTS_REGEX = /\/([^\/]*):([^:$\/]+)/.freeze
+
+    def initialize(namespace, pattern, options = {}, &block)
+      @namespace = namespace
+      @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 = pattern
+      else
+        raise ArgumentError.new('Pattern must be a string or a regex')
+      end
+    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
+    end
+  end 
+end

data/lib/lydia/router.rb

@@ -0,0 +1,86 @@
+require 'lydia/route'
+require 'lydia/standard_pages'
+require 'lydia/not_found'
+require 'lydia/halted'
+require 'rack/request'
+require 'rack/response'
+
+module Lydia
+  class Router
+    include StandardPages
+    
+    attr_reader :request, :response, :env
+    
+    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(@namespace, pattern, options, &block)
+        end
+      end
+      
+      def namespace(pattern, options = {})
+        prev_namespace = @namespace ||= ''
+        @namespace += pattern
+        yield
+        @namespace = prev_namespace
+      end
+      
+      def call(env)
+        new.call(env)
+      end
+    end
+    
+    def next_route
+      throw :next_route
+    end  
+    
+    def halt(input = nil)
+      raise Halted.new(input || halted)
+    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)
+    end
+    
+    def dispatch(env)
+      self.class.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
+        end
+      end
+      raise NotFound
+    end  
+  end
+end