eldr 0.0.2

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop)
+
+task :default do
+  Rake::Task['spec'].execute
+end

data/TODOS

@@ -0,0 +1,3 @@
+- [ ] Rdocs
+- [ ] performance improvements
+- [ ] wiki pages

data/eldr.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/eldr/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'eldr'
+  s.version     = Eldr::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['K-2052']
+  s.email       = ['k@2052.me']
+  s.homepage    = 'https://github.com/eldr-rb/eldr'
+  s.summary     = 'A minimal framework that lights a fire in your development'
+  s.description = 'A minimal framework that lights a fire in your development.
+                   Built close to Rack and the metal.'
+  s.licenses    = ['MIT']
+
+  s.required_rubygems_version = '~> 1.3.6'
+  s.required_ruby_version     = '~> 2.0'
+  s.rubyforge_project         = 'eldr'
+
+  s.add_dependency 'rack',       '~> 1.5'
+  s.add_dependency 'mustermann', '0.4.0'
+  s.add_dependency 'fast_blank', '0.0.2'
+
+  s.add_development_dependency 'bundler',   '~> 1.7'
+  s.add_development_dependency 'rake',      '10.4.2'
+  s.add_development_dependency 'rspec',     '3.1.0'
+  s.add_development_dependency 'rubocop',   '0.28.0'
+  s.add_development_dependency 'rack-test', '0.6.2'
+  s.add_development_dependency 'tilt',      '2.0.1'
+  s.add_development_dependency 'slim',      '3.0.1'
+  s.add_development_dependency 'coveralls', '~> 0.7'
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/examples/README.md

@@ -0,0 +1,7 @@
+# Running these examples
+
+To run these examples pass them into rackup:
+
+```sh
+$ bundle exec rackup examples/builder.ru
+```

data/examples/action_objects.ru

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+
+class Show
+  attr_accessor :env
+  
+  def helper_logic
+    # do things here
+  end
+
+  def params
+    env['eldr.params']
+  end
+
+  def call(env)
+    @env = env
+
+    helper_logic
+    # @cat = Cat.find params[:id]
+    Rack::Response.new "Found cat named #{params['name'].capitalize}!"
+  end
+end
+
+class CatsController < Eldr::App
+  get '/cats/:name', Show.new
+end
+
+run CatsController.new

data/examples/app.ru

@@ -0,0 +1,75 @@
+class ExampleApp < Eldr::App
+  class NotFound < StandardError
+    def call(env)
+      [404, {}, ['']]
+    end
+  end
+  attr_accessor :cats
+
+  before :before do
+    @thing1 = "Thing1"
+  end
+
+  before do
+    @thing2 = "Thing2"
+  end
+
+  after :cats do
+    @cats == 'Cats!'
+  end
+
+  get '/posts' do |params|
+    Rack::Response.new "posts", 200
+  end
+
+  post '/posts' do
+    Rack::Response.new "posts", 201
+  end
+
+  put '/posts' do
+    Rack::Response.new "posts", 200
+  end
+
+  delete '/posts' do
+    Rack::Response.new "posts", 201
+  end
+
+  get '/deferred' do
+    throw :pass
+  end
+
+  get '/deferred' do
+    Rack::Response.new "Deferred!", 200
+  end
+
+  get '/raises-an-error' do
+    raise NotFound, 'Not Found'
+  end
+
+  get '/state' do
+    @state = 1 + @state.to_i
+    [200, {}, [@state]]
+  end
+
+  get '/state-2' do
+    [200, {}, [@state ||= 0]]
+  end
+
+  get '/before', name: :before do
+    [200, {}, [@thing1]]
+  end
+
+  get '/before-all', name: :before do
+    [200, {}, [@thing2]]
+  end
+
+  get '/after' do
+    [200, {}, ["Cats!"]]
+  end
+
+  get '/posts/:id' do
+    [200, {}, [params['id']]]
+  end
+end
+
+run ExampleApp

data/examples/builder.ru

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+
+class SimpleCounterMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['eldr.simple_counter'] ||= 0
+    env['eldr.simple_counter'] += 1
+    @app.call(env)
+  end
+end
+
+class BuilderExample < Eldr::App
+  use SimpleCounterMiddleware
+
+  get '/' do |env|
+    Rack::Response.new env['eldr.simple_counter'].to_s
+  end
+end
+
+run BuilderExample

data/examples/custom_response.ru

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+
+class Response
+  attr_accessor :status, :headers, :body
+
+  def initialize(body, status=200, headers={})
+    @body, @status, @headers = body, status, headers
+  end
+
+  def to_a
+    [@status, @headers, [@body]]
+  end
+  alias_method :to_ary, :to_a
+end
+
+class CustomResponseExample < Eldr::App
+  get '/' do
+    Response.new("Hello World Custom!")
+  end
+end
+
+run CustomResponseExample

data/examples/errors.ru

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+
+class ErrorResponse < StandardError
+  def call(env)
+    Rack::Response.new message, 500
+  end
+end
+
+class ErrorsExample < Eldr::App
+  get '/' do
+    raise ErrorResponse, "Bad Data"
+  end
+end
+
+run ErrorsExample

data/examples/hello_world.ru

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+
+class HelloWorld < Eldr::App
+  get '/', proc { [200, {'Content-Type' => 'txt'}, ['Hello World!']] }
+end
+
+run HelloWorld

data/examples/inheritance.ru

@@ -0,0 +1,22 @@
+class SimpleMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['eldr.simple_counter'] ||= 0
+    env['eldr.simple_counter'] += 1
+    @app.call(env)
+  end
+end
+
+class TestInheritanceApp < Eldr::App
+  use SimpleCounterMiddleware
+  set :bob, 'what about him?'
+end
+
+class InheritedApp < TestInheritanceApp
+  get '/', proc { [200, {}, [env['eldr.simple_counter']]]}
+end
+
+run InheritedApp

data/examples/multiple_apps.ru

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+
+class HelloWorldExample < Eldr::App
+  get '/' do
+    Rack::Response.new "Hello World EXAMPLE!"
+  end
+end
+
+class CatsExample < Eldr::App
+  get '/' do
+    Rack::Response.new "Hello Cats!"
+  end
+end
+
+class DogsExample < Eldr::App
+  get '/', proc { Rack::Response.new "Hello Dogs!" }
+end
+
+map '/' do
+  run HelloWorldExample
+end
+
+map '/cats' do
+  run CatsExample
+end
+
+map '/dogs' do
+  run DogsExample
+end

data/examples/rails_style_routing.ru

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+
+class Cats
+  def index env
+    Rack::Response.new "Hello from all the Cats!"
+  end
+end
+
+class RailsStyle < Eldr::App
+  get '/cats', to: 'Cats#index'
+end
+
+run RailsStyle

data/examples/rendering_templates.ru

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'eldr'
+require 'tilt'
+require 'slim'
+
+module RenderingResponses
+  class NotFound < StandardError
+    def call(env)
+      Rack::Response.new message, 404
+    end
+  end
+end
+
+module RenderingHelpers
+  def render(path, resp_code=200)
+    Rack::Response.new Tilt.new(find_template(path)).render(self), resp_code
+  end
+
+  def find_template(path)
+    template = File.join(__dir__, 'views', path)
+    raise RenderingResponses::NotFound, 'Template Not Found' unless File.exists? template
+    template
+  end
+end
+
+class RenderingTemplatesExample < Eldr::App
+  include RenderingHelpers
+
+  get '/cats' do
+    render 'cats.slim'
+  end
+
+  get '/no-template' do
+    render 'template.slim'
+  end
+end
+
+run RenderingTemplatesExample

data/examples/views/cats.slim

@@ -0,0 +1 @@
+h1 Cats!

data/lib/eldr/app.rb

@@ -0,0 +1,146 @@
+require 'forwardable'
+require 'rack/request'
+
+require_relative 'route'
+require_relative 'matcher'
+require_relative 'recognizer'
+require_relative 'configuration'
+require_relative 'builder'
+
+###
+# Eldr is a minimal Ruby framework
+###
+module Eldr
+  ###
+  # The main class all Eldr apps extend
+  ###
+  class App # rubocop:disable Metrics/ClassLength
+    attr_accessor :env, :configuration
+    HTTP_VERBS = %w(DELETE GET HEAD OPTIONS PATCH POST PUT)
+
+    class << self
+      attr_accessor :routes, :recognizer, :builder, :before_filters, :after_filters, :configuration
+      extend Forwardable
+      def_delegators :builder, :map, :use
+
+      alias_method :_new, :new
+      def new(*args, &block)
+        builder.run _new(*args, &block)
+        builder
+      end
+
+      def call(env)
+        new.call env
+      end
+
+      def inherited(base)
+        base.builder.use builder.middleware
+        base.configuration.merge!(configuration)
+      end
+
+      def builder
+        @builder ||= Builder.new
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+      alias_method :config, :configuration
+
+      def set(key, value)
+        configuration.set(key, value)
+      end
+
+      def before_filters
+        @before_filters ||= { all: [] }
+      end
+
+      def after_filters
+        @after_filters ||= { all: [] }
+      end
+
+      def before(*keys, &block)
+        *keys = [:all] if keys.empty?
+        keys.each do |key|
+          before_filters[key] ||= []
+          before_filters[key] << block
+        end
+      end
+
+      def after(*keys, &block)
+        *keys = [:all] if keys.empty?
+        keys.each do |key|
+          after_filters[key] ||= []
+          after_filters[key] << block
+        end
+      end
+
+      def routes
+        @routes ||= { delete: [], get: [], head: [], options: [], patch: [], post: [], put: [] }
+      end
+
+      def recognizer
+        @recognizer ||= Recognizer.new(routes)
+      end
+
+      HTTP_VERBS.each do |verb|
+        define_method verb.downcase.to_sym do |path, *args, &block|
+          handler = Proc.new(&block) if block
+          handler ||= args.pop if args.last.respond_to?(:call)
+          options ||= args.pop if args.last.is_a?(Hash)
+          options ||= {}
+          add(verb: verb.downcase.to_sym, path: path, handler: handler, options: options)
+        end
+      end
+
+      def add(verb: :get, path: '/', options: {}, handler: nil)
+        handler = Proc.new if block_given?
+        route = Route.new(verb: verb, path: path, options: options, handler: handler)
+
+        route.before_filters.push(*before_filters[route.name]) if before_filters.include? route.name
+        route.after_filters.push(*after_filters[route.name]) if after_filters.include? route.name
+
+        routes[verb] << route
+        route
+      end
+      alias_method :<<, :add
+    end
+
+    def initialize(configuration = nil)
+      configuration ||= self.class.configuration
+      @configuration = configuration
+    end
+
+    def call(env)
+      dup.call!(env)
+    end
+
+    def call!(env)
+      @env = env
+
+      recognize(env).each do |route|
+        env['eldr.route'] = route
+        params.merge!(route.params(env['PATH_INFO']))
+        catch(:pass) { return route.call(env, app: self) }
+      end
+      rescue => error
+        if error.respond_to? :call
+          error.call(env)
+        else
+          raise error
+        end
+    end
+
+    def request
+      env['eldr.request'] ||= Rack::Request.new(env)
+    end
+
+    def params
+      env['eldr.params'] ||= request.params
+    end
+
+    def recognize(env)
+      self.class.recognizer.call(env)
+    end
+  end
+end

data/lib/eldr/builder.rb

@@ -0,0 +1,60 @@
+require 'rack/builder'
+
+module Eldr
+  class Builder < Rack::Builder
+    attr_accessor :middleware
+    def initialize(default_app = nil, &block)
+      @middleware, @map, @run, @warmup = [], nil, default_app, nil
+      instance_eval(&block) if block_given?
+    end
+
+    def self.app(default_app = nil, &block)
+      new(default_app, &block).to_app
+    end
+
+    def use(middleware, *args, &block)
+      if middleware.is_a? Array
+        @middleware.push(*middleware)
+      else
+        if @map
+          mapping, @map = @map, nil
+          @middleware << proc { |app| generate_map app, mapping }
+        end
+        @middleware << proc { |app| middleware.new(app, *args, &block) }
+      end
+    end
+
+    def run(app) # rubocop:disable Style/TrivialAccessors
+      @run = app
+    end
+
+    def warmup(prc = nil, &block)
+      @warmup = prc || block
+    end
+
+    def map(path, &block)
+      @map ||= {}
+      @map[path] = block
+    end
+
+    def to_app
+      app = @map ? generate_map(@run, @map) : @run
+      fail 'missing run or map statement' unless app
+      app = @middleware.reverse.inject(app) { |a, e| e[a] }
+      @warmup.call(app) if @warmup
+      app
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+
+    private
+
+    def generate_map(default_app, mapping)
+      mapped = default_app ? { '/' => default_app } : {}
+      mapping.each { |r, b| mapped[r] = self.class.new(default_app, &b).to_app }
+      URLMap.new(mapped)
+    end
+  end
+end

data/lib/eldr/configuration.rb

@@ -0,0 +1,37 @@
+module Eldr
+  ###
+  # This a OpenStruct like class.
+  # It wraps a hash and when you hit a method that doesn't exist it tries to pull it from the hash
+  # Probably can break in 100 ways an is dumb, but it works.
+  # And it performs astromnomically better than stuff like Hashie::Mash
+  ###
+  class Configuration
+    attr_accessor :table
+
+    def initialize
+      defaults = { lock: false }
+      table.merge!(defaults)
+    end
+
+    def set(key, value)
+      @table[key] = value
+    end
+
+    def table
+      @table ||= {}
+    end
+
+    def merge!(hash)
+      hash = hash.table unless hash.is_a? Hash
+      @table.merge!(hash)
+    end
+
+    def method_missing(method, *args)
+      if !args.empty? # we assume we are setting something
+        set(method.to_s.gsub(/\=$/, '').to_sym, args.pop)
+      else
+        @table[method.to_s.gsub(/\?$/, '').to_sym]
+      end
+    end
+  end
+end

data/lib/eldr/matcher.rb

@@ -0,0 +1,36 @@
+require 'mustermann'
+
+module Eldr
+  class Matcher
+    PATH_DELIMITER  = '/'.freeze
+    QUERY_PREFIX    = '?'.freeze
+    QUERY_DELIMITER = '&'.freeze
+
+    def initialize(path, options = {})
+      @path = path.is_a?(String) && path.empty? ? PATH_DELIMITER : path
+      @capture = options.delete(:capture)
+      @default_values = options.delete(:default_values)
+    end
+
+    def match(pattern)
+      match_data = handler.match(pattern)
+      return match_data if match_data
+      pattern = pattern[0..-2] if mustermann? && pattern != PATH_DELIMITER && pattern.end_with?(PATH_DELIMITER)
+      handler.match(pattern)
+    end
+
+    def mustermann?
+      handler.instance_of?(Mustermann)
+    end
+
+    def handler
+      @handler ||=
+      case @path
+      when String
+        Mustermann.new(@path, capture: @capture)
+      when Regexp
+        /^(?:#{@path})$/
+      end
+    end
+  end
+end

data/lib/eldr/recognizer.rb

@@ -0,0 +1,35 @@
+require 'fast_blank'
+
+module Eldr
+  class Recognizer
+    class NotFound < StandardError
+      def call(_env)
+        [404, {}, ['']]
+      end
+    end
+
+    attr_accessor :app, :env, :routes, :pattern
+
+    def initialize(routes)
+      @routes = routes
+    end
+
+    def call(env)
+      @env = env
+
+      ret_routes = routes[verb].select { |route| !route.match(pattern).nil? }
+      raise NotFound if ret_routes.empty?
+      ret_routes
+    end
+
+    def pattern
+      @pattern = env['PATH_INFO']
+      @pattern = '/' if @pattern.blank?
+      @pattern
+    end
+
+    def verb
+      env['REQUEST_METHOD'].downcase.to_sym
+    end
+  end
+end