apiculture 0.0.19 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6f0c8bf33ab6d850b0e5ebe4137248b2eece90b
-  data.tar.gz: ff2545d4a6b2d335670722f52052b3081976afb6
+  metadata.gz: aa9f65f24dcec58c1fa839c4b06ad6707ff94929
+  data.tar.gz: 972227095a632256fba17ff766701d6626135f19
 SHA512:
-  metadata.gz: 0cd7c2561d5d0139893fbfc78c58e46ee889c84e91756f51773d1000ce4a94b8c5e1af3d2cf0c997835dfc35d6de2fdbaff9b65cece17c3c9835f31915349126
-  data.tar.gz: 2870ec784e365047cf7c737bec1510b98e19fb3efa1d5fbb6c3b3cecabdf78aaa09fea584d3a83abca63ffd99d190831a46867b1ee36c397a9eb275bc3b85bf4
+  metadata.gz: e4f2f860e3ede4b6969b6a42cd25157ff58ac1f9d5c9fa37d984e4e2eabe48b35c912efd358584a0392655c292e392feaed2e69fd13d992dba418419541c8139
+  data.tar.gz: 03754e831d7b7a2e44fdb431906ffb6119d78ee1263a2978caf89e43983f216ad5f1d8ad61e331fcdedfe03f491ce9ff996cb6c39034fc78234adae370bccf91

data/.travis.yml

@@ -1,10 +1,13 @@
+gemfile:
+  - gemfiles/Gemfile.rack-1.x
+  - gemfiles/Gemfile.rack-2.x
 rvm:
-- 2.1.5
-- 2.2.2
-- 2.3.3
-- 2.4.1
+- 2.3.7
+- 2.4.4
+- 2.5.1
+- 2.6.0-preview1
 sudo: false
 cache: bundler
 matrix:
   allow_failures:
-    - rvm: 2.1.5 # incompatible with the new jeweler version
+    - rvm: 2.6.0-preview1

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 WeTransfer
+Copyright (c) 2015-2018 WeTransfer
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,31 +1,31 @@
 # apiculture
 
-A little toolkit for building RESTful API backends on top of Sinatra.
+A little toolkit for building RESTful API backends on top of Rack.
 
 [![Build Status](https://travis-ci.org/WeTransfer/apiculture.svg?branch=master)](https://travis-ci.org/WeTransfer/apiculture)
 
 ## Ideas
 
 A simple API definition DSL with simple premises:
-  
+
  * Endpoint URLs should be _visible_ in the actual code. The reason for that is with nested
    blocks you inevitably end up setting up context somewhere far away from the terminal route
    that ends up using that context.
  * Explicit allowed/required parameters (both payload/query string and body)
  * Explicit description in front of the API action definition
  * Wrap the actual work into Actions, so that the API definition is mostly routes
- 
+
 ## A taste of honey
 
 ```ruby
-class Api::V2 < Sinatra::Base
-  
+class Api::V2 < Apiculture::App
+
   use Rack::Parser, :content_types => {
     'application/json'  => JSON.method(:load).to_proc
   }
-  
+
   extend Apiculture
-  
+
   desc 'Create a Contact'
   required_param :name, 'Name of the person', String
   param :email, 'Email address of the person', String
@@ -36,7 +36,7 @@ class Api::V2 < Sinatra::Base
     # works exactly the same - but we suggest using Actions instead.
     action_result CreateContact # uses Api::V2::CreateContact
   end
-  
+
   desc 'Fetch a Contact'
   route_param :id, 'ID of the person'
   responds_with 200, 'Contact data', {name: 'John Appleseed', id: "ac19...fefg"}
@@ -75,7 +75,7 @@ If you want to also examine the HTML documentation that gets built during the te
 Note that this requires presence of the `open` commandline utility (should be available on both OSX and Linux).
 
 ## Contributing to apiculture
- 
+
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
 * Fork the project.
@@ -86,6 +86,5 @@ Note that this requires presence of the `open` commandline utility (should be av
 
 ## Copyright
 
-Copyright (c) 2015 WeTransfer. See LICENSE.txt for
+Copyright (c) 2015-2018 WeTransfer. See LICENSE.txt for
 further details.
-

data/apiculture.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.authors = ["Julik Tarkhanov", "WeTransfer"]
   s.homepage       = 'http://github.com/wetransfer/zip_tricks'
-  s.description = "A toolkit for building REST APIs on top of Sinatra"
+  s.description = "A toolkit for building REST APIs on top of Rack"
   s.email = "me@julik.nl"
 
   # Prevent pushing this gem to RubyGems.org.
@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
     raise 'RubyGems 2.0 or newer is required to protect against ' \
       'public gem pushes.'
   end
-  
+
   s.files = `git ls-files -z`.split("\x0")
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -31,17 +31,17 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/WeTransfer/apiculture"
   s.licenses = ["MIT"]
   s.rubygems_version = "2.4.5.1"
-  s.summary = "Sweet API sauce on top of Sintra"
+  s.summary = "Sweet API sauce on top of Rack"
 
-  s.add_runtime_dependency 'sinatra', '~> 1'
+  s.add_runtime_dependency 'mustermann', '~> 1'
   s.add_runtime_dependency 'builder', '~> 3'
   s.add_runtime_dependency 'rdiscount', '~> 2'
   s.add_runtime_dependency 'github-markup', '~> 1'
-  s.add_runtime_dependency "mustache", '~> 1'
+  s.add_runtime_dependency 'mustache', '~> 1'
 
   s.add_development_dependency 'rack-test'
   s.add_development_dependency "rspec", "~> 3.1", '< 3.2'
-  s.add_development_dependency "rdoc", "~> 3.12"
+  s.add_development_dependency "rdoc", "~> 6.0"
   s.add_development_dependency "rake", "~> 10"
   s.add_development_dependency "bundler", "~> 1.0"
   s.add_development_dependency "simplecov", ">= 0"

data/gemfiles/Gemfile.rack-1.x

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+gem 'rack', "~> 1"
+
+gem 'mustermann', '~> 1'
+gem 'builder', '~> 3'
+gem 'rdiscount', '~> 2'
+gem 'github-markup', '~> 1'
+gem 'mustache', '~> 1'
+
+group :development do
+  gem 'rack-test'
+  gem "rspec", "~> 3.1", '< 3.2'
+  gem "rdoc", "~> 6.0"
+  gem "rake", "~> 10"
+  gem "bundler", "~> 1.0"
+  gem "simplecov", ">= 0"
+end

data/gemfiles/Gemfile.rack-2.x

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+gem 'rack', "~> 2"
+
+gem 'mustermann', '~> 1'
+gem 'builder', '~> 3'
+gem 'rdiscount', '~> 2'
+gem 'github-markup', '~> 1'
+gem 'mustache', '~> 1'
+
+group :development do
+  gem 'rack-test'
+  gem "rspec", "~> 3.1", '< 3.2'
+  gem "rdoc", "~> 6.0"
+  gem "rake", "~> 10"
+  gem "bundler", "~> 1.0"
+  gem "simplecov", ">= 0"
+end

data/lib/apiculture/action.rb

@@ -11,9 +11,9 @@
 class Apiculture::Action
   # Initialize a new BasicAction, with the given Sintra application and a hash
   # of keyword arguments that will be converted into instance variables.
-  def initialize(sinatra_app, **ivars)
+  def initialize(app_receiver, **ivars)
     ivars.each_pair {|k,v| instance_variable_set("@#{k}", v) }
-    @_sinatra_app = sinatra_app
+    @_sinatra_app = app_receiver
   end
   
   # Halt with a JSON error message (delegates to Sinatra's halt() under the hood)

data/lib/apiculture/app.rb

@@ -0,0 +1,131 @@
+require'mustermann'
+
+class Apiculture::App
+
+  class << self
+    def use(middlreware_factory, middleware_options, &middleware_blk)
+      @middleware_configurations ||= []
+      @middleware_configurations << [middleware_factory, middleware_options, middleware_blk]
+    end
+
+    def middleware_configurations
+      @middleware_configurations || []
+    end
+
+    def get(url, **options, &handler_blk)
+      define_action :get, url, options, &handler_blk
+    end
+
+    def post(url, **options, &handler_blk)
+      define_action :post, url, options, &handler_blk
+    end
+
+    def put(url, **options, &handler_blk)
+      define_action :put, url, options, &handler_blk
+    end
+
+    def delete(url, **options, &handler_blk)
+      define_action :delete, url, options, &handler_blk
+    end
+
+    def actions
+      @actions || []
+    end
+
+    def define_action(http_method, url_path, **options, &handler_blk)
+      @actions ||= []
+      @actions << [http_method.to_s.upcase, url_path, options, handler_blk]
+    end
+  end
+
+  def call_without_middleware(env)
+    @env = env
+
+    # First try to route via actions...
+    given_http_method = env.fetch('REQUEST_METHOD')
+    given_path = env.fetch('PATH_INFO')
+    given_path = '/' + given_path unless given_path.start_with?('/')
+
+    action_list = self.class.actions
+    # TODO: I believe Sinatra matches bottom-up, not top-down.
+    action_list.reverse.each do | (action_http_method, action_url_path, action_options, action_handler_callable)|
+      route_pattern = Mustermann.new(action_url_path)
+      if given_http_method == action_http_method && route_params = route_pattern.params(given_path)
+        @request = Rack::Request.new(env)
+        @params.merge!(@request.params)
+        @route_params = route_params
+
+        match = route_pattern.match(given_path)
+        @route_params['captures'] = match.captures unless match.nil?
+        @params.merge!(@route_params)
+        return perform_action_block(&action_handler_callable)
+      end
+    end
+
+    # and if nothing works out - respond with a 404
+    out = JSON.pretty_generate({
+      error: 'No matching action found for %s %s' % [given_http_method, given_path],
+    })
+    [404, {'Content-Type' => 'application/json', 'Content-Length' => out.bytesize.to_s}, [out]]
+  end
+
+  def self.call(env)
+    app = new
+    Rack::Builder.new do
+      (@middleware_configurations || []).each do |middleware_args|
+        use(*middleware_args)
+      end
+      run ->(env) { app.call_without_middleware(env) }
+    end.to_app.call(env)
+  end
+
+  attr_reader :request
+  attr_reader :env
+  attr_reader :params
+
+  def initialize
+    @status = 200
+    @content_type = 'text/plain'
+    @params = Apiculture::IndifferentHash.new
+  end
+
+  def content_type(new_type)
+    @content_type = Rack::Mime.mime_type('.%s' % new_type)
+  end
+
+  def status(status_code)
+    @status = status_code.to_i
+  end
+
+  def halt(rack_status, rack_headers, rack_body)
+    throw :halt, [rack_status, rack_headers, rack_body]
+  end
+
+  def perform_action_block(&blk)
+    # Execut the action in a Sinatra-like fashion - passing the route parameter values as
+    # arguments to the given block/callable. This is where in the future we should ditch
+    # the Sinatra calling conventions - Sinatra mandates that the action accept the route parameters
+    # as arguments and grab all the useful stuff from instance methods like `params` etc. whereas
+    # we probably want to have just Rack apps mounted per route (under an action)
+    response = catch(:halt) do
+      body_string_or_rack_triplet = instance_exec(*@route_params.values, &blk)
+
+      if rack_triplet?(body_string_or_rack_triplet)
+        return body_string_or_rack_triplet
+      end
+
+     [@status, {'Content-Type' => @content_type}, [body_string_or_rack_triplet]]
+    end
+
+    return response
+  end
+
+  def rack_triplet?(maybe_triplet)
+    maybe_triplet.is_a?(Array) &&
+    maybe_triplet.length == 3 &&
+    maybe_triplet[0].is_a?(Integer) &&
+    maybe_triplet[1].is_a?(Hash) &&
+    maybe_triplet[1].keys.all? {|k| k.is_a?(String) } &&
+    maybe_triplet[2].respond_to?(:each)
+  end
+end

data/lib/apiculture/indifferent_hash.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+module Apiculture
+  # A poor man's ActiveSupport::HashWithIndifferentAccess, with all the Rails-y
+  # stuff removed.
+  #
+  # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are
+  # considered to be the same.
+  #
+  #   rgb = Sinatra::IndifferentHash.new
+  #
+  #   rgb[:black]    =  '#000000' # symbol assignment
+  #   rgb[:black]  # => '#000000' # symbol retrieval
+  #   rgb['black'] # => '#000000' # string retrieval
+  #
+  #   rgb['white']   =  '#FFFFFF' # string assignment
+  #   rgb[:white]  # => '#FFFFFF' # symbol retrieval
+  #   rgb['white'] # => '#FFFFFF' # string retrieval
+  #
+  # Internally, symbols are mapped to strings when used as keys in the entire
+  # writing interface (calling e.g. <tt>[]=</tt>, <tt>merge</tt>). This mapping
+  # belongs to the public interface. For example, given:
+  #
+  #   hash = Sinatra::IndifferentHash.new(:a=>1)
+  #
+  # You are guaranteed that the key is returned as a string:
+  #
+  #   hash.keys # => ["a"]
+  #
+  # Technically other types of keys are accepted:
+  #
+  #   hash = Sinatra::IndifferentHash.new(:a=>1)
+  #   hash[0] = 0
+  #   hash # => { "a"=>1, 0=>0 }
+  #
+  # But this class is intended for use cases where strings or symbols are the
+  # expected keys and it is convenient to understand both as the same. For
+  # example the +params+ hash in Sinatra.
+  class IndifferentHash < Hash
+    def self.[](*args)
+      new.merge!(Hash[*args])
+    end
+
+    def initialize(*args)
+      super(*args.map(&method(:convert_value)))
+    end
+
+    def default(*args)
+      super(*args.map(&method(:convert_key)))
+    end
+
+    def default=(value)
+      super(convert_value(value))
+    end
+
+    def assoc(key)
+      super(convert_key(key))
+    end
+
+    def rassoc(value)
+      super(convert_value(value))
+    end
+
+    def fetch(key, *args)
+      super(convert_key(key), *args.map(&method(:convert_value)))
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), convert_value(value))
+    end
+
+    alias_method :store, :[]=
+
+    def key(value)
+      super(convert_value(value))
+    end
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :has_key?, :key?
+    alias_method :include?, :key?
+    alias_method :member?, :key?
+
+    def value?(value)
+      super(convert_value(value))
+    end
+
+    alias_method :has_value?, :value?
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def dig(key, *other_keys)
+      super(convert_key(key), *other_keys)
+    end if method_defined?(:dig) # Added in Ruby 2.3
+
+    def fetch_values(*keys)
+      super(*keys.map(&method(:convert_key)))
+    end if method_defined?(:fetch_values) # Added in Ruby 2.3
+
+    def slice(*keys)
+      keys.map!(&method(:convert_key))
+      self.class[super(*keys)]
+    end if method_defined?(:slice) # Added in Ruby 2.5
+
+    def values_at(*keys)
+      super(*keys.map(&method(:convert_key)))
+    end
+
+    def merge!(other_hash)
+      return super if other_hash.is_a?(self.class)
+
+      other_hash.each_pair do |key, value|
+        key = convert_key(key)
+        value = yield(key, self[key], value) if block_given? && key?(key)
+        self[key] = convert_value(value)
+      end
+
+      self
+    end
+
+    alias_method :update, :merge!
+
+    def merge(other_hash, &block)
+      dup.merge!(other_hash, &block)
+    end
+
+    def replace(other_hash)
+      super(other_hash.is_a?(self.class) ? other_hash : self.class[other_hash])
+    end
+
+    private
+
+    def convert_key(key)
+      key.is_a?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        value.is_a?(self.class) ? value : self.class[value]
+      when Array
+        value.map(&method(:convert_value))
+      else
+        value
+      end
+    end
+  end
+end

data/lib/apiculture/sinatra_instance_methods.rb

@@ -21,15 +21,14 @@ module Apiculture::SinatraInstanceMethods
   def json_halt(with_error_message, status: 400, **attrs_for_json_response)
     # Pretty-print + newline to be terminal-friendly
     err_str = JSON.pretty_generate({error: with_error_message}.merge(attrs_for_json_response)) + NEWLINE
-    halt status, {'Content-Type' => 'application/json'}, [err_str] 
+    halt status, {'Content-Type' => 'application/json'}, [err_str]
   end
   
   # Handles the given action via the given class, passing it the instance variables
   # given in the keyword arguments
   def action_result(action_class, **action_ivars)
     call_result = action_class.new(self, **action_ivars).perform
-
-    unless call_result.is_a?(Array) || call_result.is_a?(Hash) || (call_result.nil? && status == 204)
+    unless call_result.is_a?(Array) || call_result.is_a?(Hash) || (call_result.nil? && @status == 204)
       raise "Action result should be an Array, a Hash or it can be nil but only if status is 204, instead it was a #{call_result.class}"
     end
   

data/lib/apiculture/version.rb

@@ -1,3 +1,3 @@
 module Apiculture
-  VERSION = '0.0.19'
+  VERSION = '0.1.0'
 end

data/lib/apiculture.rb

@@ -1,6 +1,8 @@
 # Allows brief definitions of APIs for documentation and parameter checks
 module Apiculture
   require_relative 'apiculture/version'
+  require_relative 'apiculture/indifferent_hash'
+  require_relative 'apiculture/app'
   require_relative 'apiculture/action'
   require_relative 'apiculture/sinatra_instance_methods'
   require_relative 'apiculture/action_definition'

data/spec/apiculture/action_spec.rb

@@ -4,42 +4,42 @@ describe Apiculture::Action do
   context '.new' do
     it 'exposes the methods of the object given as a first argument to initialize' do
       action_class = Class.new(described_class)
-      fake_sinatra = double('Sinatra::Base', something: 'value')
-      action = action_class.new(fake_sinatra)
+      fake_app = double('Apiculture::App', something: 'value')
+      action = action_class.new(fake_app)
       expect(action).to respond_to(:something)
       expect(action.something).to eq('value')
     end
-    
+
     it 'converts keyword arguments to instance variables' do
       action_class = Class.new(described_class)
       action = action_class.new(nil, foo: 'a string')
       expect(action.instance_variable_get('@foo')).to eq('a string')
     end
   end
-  
+
   it 'responds to perform()' do
     expect(described_class.new(nil)).to respond_to(:perform)
   end
-  
+
   it 'can use bail() to throw a Sinatra halt' do
-    fake_sinatra = double('Sinatra::Base')
-    expect(fake_sinatra).to receive(:json_halt).with('Failure', status: 400) 
+    fake_app = double('Apiculture::App')
+    expect(fake_app).to receive(:json_halt).with('Failure', status: 400) 
     action_class = Class.new(described_class)
-    action_class.new(fake_sinatra).bail "Failure"
+    action_class.new(fake_app).bail "Failure"
   end
-  
+
   it 'can use bail() to throw a Sinatra halt with a custom status' do
-    fake_sinatra = double('Sinatra::Base')
-    expect(fake_sinatra).to receive(:json_halt).with("Failure", status: 417)
-    
+    fake_app = double('Apiculture::App')
+    expect(fake_app).to receive(:json_halt).with("Failure", status: 417)
+
     action_class = Class.new(described_class)
-    action_class.new(fake_sinatra).bail "Failure", status: 417
+    action_class.new(fake_app).bail "Failure", status: 417
   end
-  
+
   it 'can use bail() to throw a Sinatra halt with extra JSON attributes' do
-    fake_sinatra = double('Sinatra::Base')
-    expect(fake_sinatra).to receive(:json_halt).with("Failure", status: 417, message: "Totale")
+    fake_app = double('Apiculture::App')
+    expect(fake_app).to receive(:json_halt).with("Failure", status: 417, message: "Totale")
     action_class = Class.new(described_class)
-    action_class.new(fake_sinatra).bail "Failure", status: 417, message: 'Totale'
+    action_class.new(fake_app).bail "Failure", status: 417, message: 'Totale'
   end
 end

data/spec/apiculture/app_documentation_spec.rb

@@ -2,7 +2,7 @@ require_relative '../spec_helper'
 
 describe "Apiculture.api_documentation" do
   let(:app) {
-    Class.new(Sinatra::Base) do
+    Class.new(Apiculture::App) do
       extend Apiculture
       
       markdown_string 'This API is very important. Because it has to do with pancakes.'
@@ -71,7 +71,7 @@ describe "Apiculture.api_documentation" do
   end
   
   it 'generates app documentation honoring the mount point' do
-    overridden = Class.new(Sinatra::Base) do
+    overridden = Class.new(Apiculture::App) do
       extend Apiculture
       mounted_at '/api/v2/'
       api_method :get, '/pancakes' do
@@ -83,7 +83,7 @@ describe "Apiculture.api_documentation" do
   end
   
   it 'generates app documentation injecting the inline Markdown strings' do
-    app_class = Class.new(Sinatra::Base) do
+    app_class = Class.new(Apiculture::App) do
       extend Apiculture
       markdown_string '# This describes important stuff'
       api_method :get, '/pancakes' do
@@ -103,7 +103,7 @@ describe "Apiculture.api_documentation" do
     before(:each) { File.open('./TEST.md', 'w') {|f| f << "# This is an important header"} }
     after(:each) { File.unlink('./TEST.md') }
     it 'splices the contents of the file using markdown_file' do
-      app_class = Class.new(Sinatra::Base) do
+      app_class = Class.new(Apiculture::App) do
         extend Apiculture
         markdown_file './TEST.md'
         api_method :get, '/pancakes' do

data/spec/apiculture_spec.rb

@@ -2,71 +2,69 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Apiculture" do
   include Rack::Test::Methods
-  
+
   before(:each) { @app_class = nil }
   def app
     @app_class or raise "No @app_class defined in the example"
   end
-  
+
   context 'as API definition DSL' do
     it 'allows all the standard Siantra DSL to go through without modifications' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         post '/things/*' do
-          return params.inspect
+          params.inspect
         end
       end
-      
+
       post '/things/a/b/c/d', {'foo' => 'bar'}
       expect(last_response.body).to eq("{\"foo\"=>\"bar\", \"splat\"=>[\"a/b/c/d\"], \"captures\"=>[\"a/b/c/d\"]}")
     end
-    
+
     it 'flags :captures as a reserved Sinatra parameter when used as a URL param' do
       expect {
-        Class.new(Sinatra::Base) do
+        Class.new(Apiculture::App) do
           extend Apiculture
           route_param :captures, "Something it captures"
           api_method(:get, '/thing/:captures') { raise "Should never be called" }
         end
       }.to raise_error(/\:captures is a reserved magic parameter name/)
     end
-    
+
     it 'flags :captures as a reserved Sinatra parameter when used as a request param' do
       expect {
-        Class.new(Sinatra::Base) do
+        Class.new(Apiculture::App) do
           extend Apiculture
           param :captures, "Something it captures", String
           api_method(:get, '/thing') { raise "Should never be called" }
         end
       }.to raise_error(/\:captures is a reserved magic parameter name/)
     end
-    
+
     it 'flags :splat as a reserved Sinatra parameter when used as a URL param' do
       expect {
-        Class.new(Sinatra::Base) do
+        Class.new(Apiculture::App) do
           extend Apiculture
           route_param :splat, "Something it splats"
           api_method(:get, '/thing/:splat') { raise "Should never be called" }
         end
       }.to raise_error(/\:splat is a reserved magic parameter name/)
     end
-    
+
     it 'flags :splat as a reserved Sinatra parameter when used as a request param' do
       expect {
-        Class.new(Sinatra::Base) do
+        Class.new(Apiculture::App) do
           extend Apiculture
           param :splat, "Something it splats", String
           api_method(:get, '/thing') { raise "Should never be called" }
         end
       }.to raise_error(/\:splat is a reserved magic parameter name/)
     end
-    
+
     it 'flags URL and request params of the same name' do
       expect {
-        Class.new(Sinatra::Base) do
+        Class.new(Apiculture::App) do
           extend Apiculture
           route_param :id, 'Id of the thing'
           param :id, "Something it identifies (conflict)", String
@@ -74,15 +72,12 @@ describe "Apiculture" do
         end
       }.to raise_error(/\:id mentioned twice/)
     end
-    
+
     it "defines a basic API that can be called" do
       $created_thing = nil
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
-      
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         desc "Create a Thing with a name"
         route_param :id, "The ID of the thing"
         required_param :name, "Name of the thing", String
@@ -91,60 +86,53 @@ describe "Apiculture" do
           'Wild success'
         end
       end
-    
+
       post '/thing/123', {name: 'Monsieur Thing'}
       expect(last_response.body).to eq('Wild success')
       expect($created_thing).to eq({id: '123', name: 'Monsieur Thing'})
     end
-    
+
     it "serves the API documentation at a given URL using serve_api_documentation_at" do
       $created_thing = nil
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
-      
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         desc "Create a Thing with a name"
         required_param :name, "Name of the thing", String
         api_method( :post, '/thing/:id') {}
         serve_api_documentation_at('/documentation')
       end
-    
+
       get '/documentation'
       expect(last_response['Content-Type']).to include('text/html')
       expect(last_response.body).to include('Create a Thing')
     end
-    
+
     it 'raises when a required param is not provided' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         required_param :name, "Name of the thing", String
         api_method :post, '/thing' do
           raise "Should never be called"
         end
       end
-    
+
       expect {
         post '/thing', {}
       }.to raise_error('Missing parameter :name')
     end
-  
+
     it 'verifies the parameter type' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         required_param :number, "Number of the thing", Integer
         api_method :post, '/thing' do
           raise "Should never be called"
         end
       end
-    
+
       expect {
         post '/thing', {number: '123'}
       }.to raise_error('Received String, expected Integer for :number')
@@ -156,12 +144,10 @@ describe "Apiculture" do
           value == "Magic word"
         end
       end.new
-      
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         required_param :pretty_please, "Only a magic word will do", custom_matcher
         api_method :post, '/thing' do
           'Ohai!'
@@ -177,25 +163,21 @@ describe "Apiculture" do
     end
 
     it 'suppresses parameters that are not defined in the action definition' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         api_method :post, '/thing' do
           raise ":evil_ssh_injection should have wiped from params{}" if params[:evil_ssh_injection]
           'All is well'
         end
       end
-      
+
       post '/thing', {evil_ssh_injection: 'I am Homakov!'}
       expect(last_response).to be_ok
     end
 
     it 'allows route parameters that are not mentioned in the action definition, but are given in Sinatra path' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
 
         api_method :post, '/api-thing/:id_of_thing' do |id|
@@ -214,7 +196,7 @@ describe "Apiculture" do
           'All is well'
         end
       end
-      
+
       post '/vanilla-thing/123456'
       expect(last_response).to be_ok
 
@@ -223,9 +205,7 @@ describe "Apiculture" do
     end
 
     it 'does not clobber the status set in a separate mutating call when using json_response' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
 
         api_method :post, '/api/:id' do
@@ -233,27 +213,38 @@ describe "Apiculture" do
           json_response({was_created: true})
         end
       end
-      
+
       post '/api/123'
       expect(last_response.status).to eq(201)
     end
-    
+
     it 'raises when describing a route parameter that is not included in the path' do
       expect {
-        Class.new(Sinatra::Base) do
+        Class.new(Apiculture::App) do
           extend Apiculture
           route_param :thing_id, "The ID of the thing"
           api_method(:get, '/thing/:id') { raise "Should never be called" }
         end
       }.to raise_error('Parameter :thing_id not present in path "/thing/:id"')
     end
-    
+
+    it 'returns a 404 when a non existing route is called' do
+      @app_class = Class.new(Apiculture::App) do
+        extend Apiculture
+
+        api_method :post, '/api' do
+          [1]
+        end
+      end
+
+      post '/api-404'
+      expect(last_response.status).to eq(404)
+    end
+
     it 'applies a symbol typecast by calling a method on the parameter value' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         required_param :number, "Number of the thing", Integer, :cast => :to_i
         api_method :post, '/thing' do
           raise "Not cast" unless params[:number] == 123
@@ -265,11 +256,9 @@ describe "Apiculture" do
     end
 
     it 'ensures current behaviour for route params is not changed' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         route_param :number, "Number of the thing"
         api_method :post, '/thing/:number' do
           raise "Casted to int" if params[:number] == 123
@@ -280,12 +269,22 @@ describe "Apiculture" do
       expect(last_response.body).to eq('Total success')
     end
 
+    it 'supports returning a rack triplet' do
+      @app_class = Class.new(Apiculture::App) do
+        extend Apiculture
+        api_method :get, '/rack' do
+          [402, {'X-Money-In-The-Bank' => 'yes, please'}, ['Buy bitcoin']]
+        end
+      end
+      get '/rack'
+      expect(last_response.status).to eq 402
+      expect(last_response.body).to eq 'Buy bitcoin'
+    end
+
     it 'ensures current behaviour when no route params are present does not change' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         param :number, "Number of the thing", Integer, cast: :to_i
         api_method :post, '/thing' do
           raise "Behaviour changed" unless params[:number] == 123
@@ -297,11 +296,9 @@ describe "Apiculture" do
     end
 
     it 'applies a symbol typecast by calling a method on the route parameter value' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         route_param :number, "Number of the thing", Integer, :cast => :to_i
         api_method :post, '/thing/:number' do
           raise "Not cast" unless params[:number] == 123
@@ -314,28 +311,29 @@ describe "Apiculture" do
 
 
     it 'cast block arguments to the right type', run: true do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         route_param :number, "Number of the thing", Integer, :cast => :to_i
         api_method :post, '/thing/:number' do |number|
-          raise "Not cast" unless number.class == Integer
+          raise "Not cast" unless number.is_a?(Integer)
           'Total success'
         end
       end
       post '/thing/123'
       expect(last_response.body).to eq('Total success')
+
+      # Double checking that bignums are okay, too
+      bignum = 10**30
+      post "/thing/#{bignum}"
+      expect(last_response.body).to eq('Total success')
     end
 
-    
+
     it 'merges route_params and regular params' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-      
+
         param :number, "Number of the thing", Integer, :cast => :to_i
         route_param :id, "Id of the thingy", Integer, :cast => :to_i
         route_param :awesome, "Hash of the thingy"
@@ -352,11 +350,9 @@ describe "Apiculture" do
 
 
     it 'applies a Proc typecast by calling the proc (for example - for ISO8601 time)' do
-      @app_class = Class.new(Sinatra::Base) do
-        settings.show_exceptions = false
-        settings.raise_errors = true
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-    
+
         required_param :when, "When it happened", Time, cast: ->(v){ Time.parse(v) }
         api_method :post, '/occurrence' do
           raise "Not cast" unless params[:when].year == 2015
@@ -368,18 +364,16 @@ describe "Apiculture" do
       expect(last_response.body).to eq('Total success')
     end
   end
-  
+
   context 'Sinatra instance method extensions' do
     it 'adds support for json_response' do
-      @app_class = Class.new(Sinatra::Base) do
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-        settings.show_exceptions = false
-        settings.raise_errors = true
         api_method :get, '/some-json' do
           json_response({foo: 'bar'})
         end
       end
-      
+
       get '/some-json'
       expect(last_response).to be_ok
       expect(last_response['Content-Type']).to include('application/json')
@@ -388,24 +382,20 @@ describe "Apiculture" do
     end
 
     it 'adds support for json_response to set http status code', run: true do
-      @app_class = Class.new(Sinatra::Base) do
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-        settings.show_exceptions = false
-        settings.raise_errors = true
         api_method :post, '/some-json' do
           json_response({foo: 'bar'}, status: 201)
         end
       end
-      
+
       post '/some-json'
       expect(last_response.status).to eq(201)
     end
 
     it 'adds support for json_halt' do
-      @app_class = Class.new(Sinatra::Base) do
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-        settings.show_exceptions = false
-        settings.raise_errors = true
         api_method :get, '/simple-halt' do
           json_halt "Nein."
           raise "This should never be called"
@@ -419,13 +409,13 @@ describe "Apiculture" do
           raise "This should never be called"
         end
       end
-      
+
       get '/simple-halt'
       expect(last_response.status).to eq(400)
       expect(last_response['Content-Type']).to include('application/json')
       parsed_body = JSON.load(last_response.body)
       expect(parsed_body).to eq({"error"=>"Nein."})
-      
+
       get '/halt-with-error-payload'
       expect(last_response.status).to eq(400)
       expect(last_response['Content-Type']).to include('application/json')
@@ -441,10 +431,8 @@ describe "Apiculture" do
       end
     end
     it 'allows returning an empty body when the status is 204' do
-      @app_class = Class.new(Sinatra::Base) do
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-        settings.show_exceptions = false
-        settings.raise_errors = true
         api_method :get, '/nil204' do
           action_result NilTestAction
         end
@@ -458,10 +446,8 @@ describe "Apiculture" do
     it "does not allow returning an empty body when the status isn't 204" do
       # Mock out the perform call so that status doesn't change from the default of 200
       expect_any_instance_of(NilTestAction).to receive(:perform).with(any_args).and_return(nil)
-      @app_class = Class.new(Sinatra::Base) do
+      @app_class = Class.new(Apiculture::App) do
         extend Apiculture
-        settings.show_exceptions = false
-        settings.raise_errors = true
         api_method :get, '/nil200' do
           action_result NilTestAction
         end

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@ require 'rspec'
 require 'apiculture'
 require 'rack'
 require 'rack/test'
-require 'sinatra/base'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apiculture
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.1.0
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-03 00:00:00.000000000 Z
+date: 2018-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sinatra
+  name: mustermann
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -121,14 +121,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -171,7 +171,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A toolkit for building REST APIs on top of Sinatra
+description: A toolkit for building REST APIs on top of Rack
 email: me@julik.nl
 executables: []
 extensions: []
@@ -186,11 +186,15 @@ files:
 - README.md
 - Rakefile
 - apiculture.gemspec
+- gemfiles/Gemfile.rack-1.x
+- gemfiles/Gemfile.rack-2.x
 - lib/apiculture.rb
 - lib/apiculture/action.rb
 - lib/apiculture/action_definition.rb
+- lib/apiculture/app.rb
 - lib/apiculture/app_documentation.rb
 - lib/apiculture/app_documentation_tpl.mustache
+- lib/apiculture/indifferent_hash.rb
 - lib/apiculture/markdown_segment.rb
 - lib/apiculture/method_documentation.rb
 - lib/apiculture/sinatra_instance_methods.rb
@@ -222,8 +226,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
-summary: Sweet API sauce on top of Sintra
+summary: Sweet API sauce on top of Rack
 test_files: []