hanami-api 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fb567b59fdf0ad2b6bc543c20857caed2015b596
-  data.tar.gz: c337a9fc89f227ca2f001e518a026d6398875796
+SHA256:
+  metadata.gz: b78d8afabe0c9e3a00e3d809866366d1961786fab864788d37bb0b4edc0b67c8
+  data.tar.gz: 7df6b562a2721f299b9c2a307f546c4e79d72f500b67032ed434907bc880dc09
 SHA512:
-  metadata.gz: 8ad8ccecfbc46dcb2ae9e2349f00acbf1a9f653f3ffd23f9b0ee7101c4aa82f7241140448da6c99c7a5888f763edac56ce54af12ad872e0fdcf1b5b62d2da252
-  data.tar.gz: 4ca503c7ec8016ef8ad947a84119f133b4490727fe1c6f349ba8e2513eab6c629f29f3ed33e9b3aa9a7da3203598903c2763ae804118c502af1572a6fab9a2a6
+  metadata.gz: bb8c28fded8d1518c02d286d57d56afff643caab1da5c11e0f357b6dea72e79a4788be00b11169599b692d74fc867244516220785932e3b30895b72077375a77
+  data.tar.gz: 82db2bdc48a9416f884d22fb7d3fe9d3bb7f6dab1632416ca0939e6ed66c87f4a4fc81e2a7a0d86da18a9e8a3e418d189a375a78ca8e63b2a7177e7e9a5bb91b

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,10 @@
+# Please keep AllCops, Bundler, Layout, Style, Metrics groups and then order cops
+# alphabetically
+#
+# References:
+#   * https://github.com/bbatsov/ruby-style-guide
+#   * https://rubocop.readthedocs.io/
+inherit_from:
+  - https://raw.githubusercontent.com/hanami/devtools/master/.rubocop-unstable.yml
+AllCops:
+  TargetRubyVersion: 2.7

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Hanami::API
+Minimal, extremely fast, lightweight Ruby framework for HTTP APIs.
+
+## v0.1.0 - 2020-02-19
+### Added
+- [Luca Guidi] Introduced `Hanami::API` superclass

data/Gemfile

@@ -1,4 +1,7 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-# Specify your gem's dependencies in hanami-api.gemspec
+source "https://rubygems.org"
 gemspec
+
+gem "byebug", require: false
+gem "hanami-router", git: "https://github.com/hanami/router.git", branch: "feature/tree-rewrite"

data/README.md

@@ -1,28 +1,371 @@
-# Hanami::Api
+# Hanami::API
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/hanami/api`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Minimal, extremely fast, lightweight Ruby framework for HTTP APIs.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's `Gemfile`:
 
 ```ruby
-gem 'hanami-api'
+gem "hanami-api"
 ```
 
 And then execute:
 
-    $ bundle
+```shell
+$ bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install hanami-api
+```shell
+$ gem install hanami-api
+```
+
+## Performance
+
+Benchmark against an app with 10,000 routes, hitting the 10,000th to measure the worst case scenario.
+Based on [`jeremyevans/r10k`](https://github.com/jeremyevans/r10k), `Hanami::API` scores first for speed, and second for memory footprint.
+
+### Runtime
+
+Runtime to complete 20,000 requests (lower is better).
+
+| Framework  | Seconds to complete |
+|------------|---------------------|
+| hanami-api | 0.11628299998119473 |
+| watts      | 0.23525599995628    |
+| roda       | 0.348202999914065   |
+| syro       | 0.355627000099048   |
+| rack-app   | 0.6226229998283088  |
+| cuba       | 1.2913489998318255  |
+| rails      | 17.04722599987872   |
+| synfeld    | 171.83788800006732  |
+| sinatra    | 197.47695700009353  |
+
+### Memory
+
+Memory footprint for 10,000 routes app (lower is better).
+
+| Framework  | Bytes  |
+|------------|--------|
+| roda       | 47252  |
+| hanami-api | 53988  |
+| cuba       | 55420  |
+| syro       | 60256  |
+| rack-app   | 82976  |
+| watts      | 84956  |
+| sinatra    | 124980 |
+| rails      | 143048 |
+| synfeld    | 172680 |
 
 ## Usage
 
-TODO: Write usage instructions here
+Create `config.ru` at the root of your project:
+
+```ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "hanami/api"
+
+class App < Hanami::API
+  get "/" do
+    "Hello, world"
+  end
+end
+
+run App.new
+```
+
+Start the Rack server with `bundle exec rackup`
+
+### Routes
+
+A route is a combination of three elements:
+
+  * HTTP method (e.g. `get`)
+  * Path (e.g. `"/"`)
+  * Endpoint (e.g. `MyEndpoint.new`)
+
+```ruby
+get "/", to: MyEndpoint.new
+```
+
+### HTTP methods
+
+`Hanami::API` supports the following HTTP methods:
+
+  * `get`
+  * `head`
+  * `post`
+  * `patch`
+  * `put`
+  * `options`
+  * `trace`
+  * `link`
+  * `unlink`
+
+### Endpoints
+
+`Hanami::API` supports two kind of endpoints: block and Rack.
+
+#### Rack endpoint
+
+The framework is compatible with Rack. Any Rack endpoint, can be passed to the route:
+
+```ruby
+get "/", to: MyRackEndpoint.new
+```
+
+#### Block endpoint
+
+A block passed to the route definition is named a block endpoint.
+The returning value will compose the Rack response. It can be:
+
+##### String
+
+```ruby
+get "/" do
+  "Hello, world"
+end
+```
+
+It will return `[200, {}, ["Hello, world"]]`
+
+##### Integer
+
+```ruby
+get "/" do
+  418
+end
+```
+
+It will return `[418, {}, ["I'm a teapot"]]`
+
+##### Integer, String
+
+```ruby
+get "/" do
+  [401, "You shall not pass"]
+end
+```
+
+It will return `[401, {}, ["You shall not pass"]]`
+
+##### Integer, Hash, String
+
+```ruby
+get "/" do
+  [401, {"X-Custom-Header" => "foo"}, "You shall not pass"]
+end
+```
+
+It will return `[401, {"X-Custom-Header" => "foo"}, ["You shall not pass"]]`
+
+### Block context
+
+When using the block syntax there is a rich API to use.
+
+#### env
+
+The `#env` method exposes the Rack environment for the current request
+
+#### status
+
+Get HTTP status
+
+```ruby
+get "/" do
+  puts status
+    # => 200
+end
+```
+
+Set HTTP status
+
+```ruby
+get "/" do
+  status(201)
+end
+```
+
+#### headers
+
+Get HTTP response headers
+
+```ruby
+get "/" do
+  puts headers
+    # => {}
+end
+```
+
+Set HTTP status
+
+```ruby
+get "/" do
+  headers["X-My-Header"] = "OK"
+end
+```
+
+#### body
+
+Get HTTP response body
+
+```ruby
+get "/" do
+  puts body
+    # => nil
+end
+```
+
+Get HTTP response body
+
+```ruby
+get "/" do
+  body "Hello, world"
+end
+```
+
+#### params
+
+Access params for current request
+
+```ruby
+get "/" do
+  id = params[:id]
+  # ...
+end
+```
+
+#### halt
+
+Halts the flow of the block and immediately returns with the current HTTP status
+
+```ruby
+get "/authenticate" do
+  halt(401)
+
+  # this code will never be reached
+end
+```
+
+It sets a Rack response: `[401, {}, ["Unauthorized"]]`
+
+```ruby
+get "/authenticate" do
+  halt(401, "You shall not pass")
+
+  # this code will never be reached
+end
+```
+
+It sets a Rack response: `[401, {}, ["You shall not pass"]]`
+
+#### redirect
+
+Redirects request and immediately halts it
+
+```ruby
+get "/legacy" do
+  redirect "/dashboard"
+
+  # this code will never be reached
+end
+```
+
+It sets a Rack response: `[301, {"Location" => "/new"}, ["Moved Permanently"]]`
+
+```ruby
+get "/legacy" do
+  redirect "/dashboard", 302
+
+  # this code will never be reached
+end
+```
+
+It sets a Rack response: `[302, {"Location" => "/new"}, ["Moved"]]`
+
+#### back
+
+Utility for redirect back using HTTP request header `HTTP_REFERER`
+
+```ruby
+get "/authenticate" do
+  if authenticate(env)
+    redirect back
+  else
+    # ...
+  end
+end
+```
+
+#### json
+
+Sets a JSON response for the given object
+
+```ruby
+get "/user/:id" do
+  user = UserRepository.new.find(params[:id])
+  json(user)
+end
+```
+
+```ruby
+get "/user/:id" do
+  user = UserRepository.new.find(params[:id])
+  json(user, "application/vnd.api+json")
+end
+```
+
+### Scope
+
+Prefixing routes is possible with routing scopes:
+
+```ruby
+scope "api" do
+  scope "v1" do
+    get "/users", to: Actions::V1::Users::Index.new
+  end
+end
+```
+
+It will generate a route with `"/api/v1/users"` as path.
+
+### Rack Middleware
+
+To mount a Rack middleware it's possible with `.use`
+
+```ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "hanami/api"
+
+class App < Hanami::API
+  use ElapsedTime
+
+  scope "api" do
+    use ApiAuthentication
+
+    scope "v1" do
+      use ApiV1Deprecation
+    end
+
+    scope "v2" do
+      # ...
+    end
+  end
+end
+```
+
+Middleware are inherited from top level scope.
+
+In the example above, `ElapsedTime` is used for each incoming request because
+it's part of the top level scope. `ApiAuthentication` it's used for all the API
+versions, because it's defined in the `"api"` scope. `ApiV1Deprecation` is used
+only by the routes in `"v1"` scope, but not by `"v2"`.
 
 ## Development
 
@@ -32,5 +375,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/jodosha/hanami-api.
+Bug reports and pull requests are welcome on GitHub at https://github.com/hanami/api.
 

data/Rakefile

@@ -1,2 +1,13 @@
+# frozen_string_literal: true
+
+require "rake"
 require "bundler/gem_tasks"
-task :default => :spec
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  file_list = FileList["spec/**/*_spec.rb"]
+
+  task.pattern = file_list
+end
+
+task default: "spec"

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "hanami/api"

data/hanami-api.gemspec

@@ -1,27 +1,37 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'hanami/api/version'
+# frozen_string_literal: true
+
+require_relative "lib/hanami/api/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "hanami-api"
-  spec.version       = Hanami::Api::VERSION
+  spec.version       = Hanami::API::VERSION
   spec.authors       = ["Luca Guidi"]
   spec.email         = ["me@lucaguidi.com"]
 
   spec.summary       = "Hanami API"
-  spec.description   = "Hanami API for fast, lightweight applications"
-  spec.homepage      = "http://hanamirb.org"
+  spec.description   = "Extremely fast and lightweight HTTP API"
+  spec.homepage      = "http://rubygems.org"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
-  spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/hanami/api"
+  spec.metadata["changelog_uri"] = "https://github.com/hanami/api/blob/master/CHANGELOG.md"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "hanami-router", "~> 2.0.alpha"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.8"
+  spec.add_development_dependency "rubocop", "~> 0.79"
 end

data/lib/hanami/api.rb

@@ -1,7 +1,345 @@
-require "hanami/api/version"
+# frozen_string_literal: true
 
 module Hanami
-  module Api
-    # Your code goes here...
+  # Hanami::API
+  #
+  # @since 0.1.0
+  class API
+    require "hanami/api/version"
+    require "hanami/api/error"
+    require "hanami/api/router"
+    require "hanami/api/middleware"
+
+    # @since 0.1.0
+    # @api private
+    def self.inherited(app)
+      super
+
+      app.class_eval do
+        @routes = []
+        @stack = Middleware::Stack.new
+      end
+    end
+
+    class << self
+      # @since 0.1.0
+      # @api private
+      attr_reader :routes
+
+      # @since 0.1.0
+      # @api private
+      attr_reader :stack
+    end
+
+    # Defines a named root route (a GET route for "/")
+    #
+    # @param to [#call] the Rack endpoint
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    #
+    # @example Proc endpoint
+    #   require "hanami/router"
+    #
+    #   router = Hanami::Router.new do
+    #     root to: ->(env) { [200, {}, ["Hello from Hanami!"]] }
+    #   end
+    #
+    # @example Block endpoint
+    #   require "hanami/router"
+    #
+    #   router = Hanami::Router.new do
+    #     root do
+    #       "Hello from Hanami!"
+    #     end
+    #   end
+    def self.root(*args, **kwargs, &blk)
+      @routes << [:root, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts GET requests for the given path.
+    # It also defines a route to accept HEAD requests.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @example Proc endpoint
+    #   require "hanami/api"
+    #
+    #   class MyAPI < Hanami::API
+    #     get "/", to: ->(*) { [200, {}, ["OK"]] }
+    #   end
+    #
+    # @example Block endpoint
+    #   require "hanami/api"
+    #
+    #   class MyAPI < Hanami::API
+    #     get "/" do
+    #       "OK"
+    #     end
+    #   end
+    #
+    # @example Constraints
+    #   require "hanami/api"
+    #
+    #   class MyAPI < Hanami::API
+    #     get "/users/:id", to: ->(*) { [200, {}, ["OK"]] }, id: /\d+/
+    #   end
+    def self.get(*args, **kwargs, &blk)
+      @routes << [:get, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts POST requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.post(*args, **kwargs, &blk)
+      @routes << [:post, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts PATCH requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.patch(*args, **kwargs, &blk)
+      @routes << [:patch, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts PUT requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.put(*args, **kwargs, &blk)
+      @routes << [:put, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts DELETE requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.delete(*args, **kwargs, &blk)
+      @routes << [:delete, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts TRACE requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.trace(*args, **kwargs, &blk)
+      @routes << [:trace, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts OPTIONS requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.options(*args, **kwargs, &blk)
+      @routes << [:options, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts LINK requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.link(*args, **kwargs, &blk)
+      @routes << [:link, args, kwargs, blk]
+    end
+
+    # Defines a route that accepts UNLINK requests for the given path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.unlink(*args, **kwargs, &blk)
+      @routes << [:unlink, args, kwargs, blk]
+    end
+
+    # Defines a route that redirects the incoming request to another path.
+    #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param code [Integer] a HTTP status code to use for the redirect
+    #
+    # @since 0.1.0
+    #
+    # @see .get
+    def self.redirect(*args, **kwargs, &blk)
+      @routes << [:redirect, args, kwargs, blk]
+    end
+
+    # Defines a routing scope. Routes defined in the context of a scope,
+    # inherit the given path as path prefix and as a named routes prefix.
+    #
+    # @param path [String] the scope path to be used as a path prefix
+    # @param blk [Proc] the routes definitions withing the scope
+    #
+    # @since 0.1.0
+    #
+    # @see #path
+    #
+    # @example
+    #   require "hanami/api"
+    #
+    #   class MyAPI < Hanami::API
+    #     scope "v1" do
+    #       get "/users", to: ->(*) { ... }, as: :users
+    #     end
+    #   end
+    #
+    #   # It generates a route with a path `/v1/users`
+    def self.scope(*args, **kwargs, &blk)
+      @routes << [:scope, args, kwargs, blk]
+    end
+
+    # Mount a Rack application at the specified path.
+    # All the requests starting with the specified path, will be forwarded to
+    # the given application.
+    #
+    # All the other methods (eg `#get`) support callable objects, but they
+    # restrict the range of the acceptable HTTP verb. Mounting an application
+    # with #mount doesn't apply this kind of restriction at the router level,
+    # but let the application to decide.
+    #
+    # @param app [#call] a class or an object that responds to #call
+    # @param at [String] the relative path where to mount the app
+    # @param constraints [Hash] a set of constraints for path variables
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "hanami/api"
+    #
+    #   class MyAPI < Hanami::API
+    #     mount MyRackApp.new, at: "/foo"
+    #   end
+    def self.mount(*args, **kwargs, &blk)
+      @routes << [:mount, args, kwargs, blk]
+    end
+
+    # Use a Rack middleware
+    #
+    # @param middleware [Class,#call] a Rack middleware
+    # @param args [Array<Object>] an optional array of arguments for Rack middleware
+    # @param blk [Block] an optional block to pass to the Rack middleware
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require "hanami/api"
+    #
+    #   class MyAPI < Hanami::API
+    #     use MyRackMiddleware
+    #   end
+    def self.use(middleware, *args, &blk)
+      @stack.use(middleware, args, &blk)
+    end
+
+    # @since 0.1.0
+    def initialize(routes: self.class.routes, stack: self.class.stack)
+      @stack = stack
+      @router = Router.new(stack: @stack) do
+        routes.each do |method_name, args, kwargs, blk|
+          send(method_name, *args, **kwargs, &blk)
+        end
+      end
+
+      freeze
+    end
+
+    # @since 0.1.0
+    def freeze
+      @app = @stack.finalize(@router)
+      @url_helpers = @router.url_helpers
+      @router.remove_instance_variable(:@url_helpers)
+      remove_instance_variable(:@stack)
+      remove_instance_variable(:@router)
+      @url_helpers.freeze
+      @app.freeze
+      super
+    end
+
+    # @since 0.1.0
+    def call(env)
+      @app.call(env)
+    end
+
+    # TODO: verify if needed here on in block context
+    #
+    # @since 0.1.0
+    # @api private
+    def path(name, variables = {})
+      @url_helpers.path(name, variables)
+    end
+
+    # TODO: verify if needed here on in block context
+    #
+    # @since 0.1.0
+    # @api private
+    def url(name, variables = {})
+      @url_helpers.url(name, variables)
+    end
   end
 end

data/lib/hanami/api/block/context.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "hanami/router/block"
+require "rack/utils"
+require "json"
+
+module Hanami
+  class API
+    module Block
+      class Context < Hanami::Router::Block::Context
+        # @overload body
+        #   Gets the current HTTP response body
+        #   @return [String] the HTTP body
+        # @overload body(value)
+        #   Sets the HTTP body
+        #   @param value [String] the HTTP response body
+        #
+        # @since 0.1.0
+        def body(value = nil)
+          if value
+            @body = value
+          else
+            @body
+          end
+        end
+
+        # Halts the flow of the block and immediately returns with the current
+        # HTTP status
+        #
+        # @param status [Integer] a valid HTTP status code
+        # @param body [String] an optional HTTP response body
+        #
+        # @example HTTP Status
+        #   get "/authenticate" do
+        #     halt(401)
+        #
+        #     # this code will never be reached
+        #   end
+        #
+        #   # It sets a Rack response: [401, {}, ["Unauthorized"]]
+        #
+        # @example HTTP Status and body
+        #   get "/authenticate" do
+        #     halt(401, "You shall not pass")
+        #
+        #     # this code will never be reached
+        #   end
+        #
+        #   # It sets a Rack response: [401, {}, ["You shall not pass"]]
+        #
+        # @since 0.1.0
+        def halt(status, body = nil)
+          body ||= http_status(status)
+          throw :halt, [status, body]
+        end
+
+        # Redirects request and immediately halts it
+        #
+        # @param url [String] the destination URL
+        # @param status [Integer] an optional HTTP code for the redirect
+        #
+        # @see #halt
+        #
+        # @since 0.1.0
+        #
+        # @example URL
+        #   get "/legacy" do
+        #     redirect "/dashboard"
+        #
+        #     # this code will never be reached
+        #   end
+        #
+        #   # It sets a Rack response: [301, {"Location" => "/new"}, ["Moved Permanently"]]
+        #
+        # @example URL and HTTP status
+        #   get "/legacy" do
+        #     redirect "/dashboard", 302
+        #
+        #     # this code will never be reached
+        #   end
+        #
+        #   # It sets a Rack response: [302, {"Location" => "/new"}, ["Moved"]]
+        def redirect(url, status = 301)
+          headers["Location"] = url
+          halt(status)
+        end
+
+        # Utility for redirect back using HTTP request header `HTTP_REFERER`
+        #
+        # @since 0.1.0
+        #
+        # @example
+        #   get "/authenticate" do
+        #     if authenticate(env)
+        #       redirect back
+        #     else
+        #       # ...
+        #     end
+        #   end
+        def back
+          env["HTTP_REFERER"] || "/"
+        end
+
+        # Sets a JSON response for the given object
+        #
+        # @param object [Object] a JSON serializable object
+        # @param mime [String] optional MIME type to set for the response
+        #
+        # @since 0.1.0
+        #
+        # @example JSON serializable object
+        #   get "/user/:id" do
+        #     user = UserRepository.new.find(params[:id])
+        #     json(user)
+        #   end
+        #
+        # @example JSON serializable object and custom MIME type
+        #   get "/user/:id" do
+        #     user = UserRepository.new.find(params[:id])
+        #     json(user, "application/vnd.api+json")
+        #   end
+        def json(object, mime = "application/json")
+          headers["Content-Type"] = mime
+          JSON.generate(object)
+        end
+
+        # @since 0.1.0
+        # @api private
+        def call
+          case caught
+            in String => body
+            [status, headers, [body]]
+            in Integer => status
+            [status, headers, [self.body || http_status(status)]]
+            in [Integer, String] => response
+            [response[0], headers, [response[1]]]
+            in [Integer, Hash, String] => response
+            headers.merge!(response[1])
+            [response[0], headers, [response[2]]]
+          end
+        end
+
+        private
+
+        # @since 0.1.0
+        # @api private
+        def caught
+          catch :halt do
+            instance_exec(&@blk)
+          end
+        end
+
+        # @since 0.1.0
+        # @api private
+        def http_status(code)
+          Rack::Utils::HTTP_STATUS_CODES.fetch(code)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/api/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Hanami
+  class API
+    # @since 0.1.0
+    class Error < StandardError
+    end
+  end
+end

data/lib/hanami/api/middleware.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "rack/builder"
+
+module Hanami
+  class API
+    # Hanami::API middleware stack
+    #
+    # @since 0.1.0
+    # @api private
+    module Middleware
+      # Middleware stack
+      #
+      # @since 0.1.0
+      # @api private
+      class Stack
+        # @since 0.1.0
+        # @api private
+        ROOT_PREFIX = "/"
+        private_constant :ROOT_PREFIX
+
+        # @since 0.1.0
+        # @api private
+        def initialize
+          @prefix = ROOT_PREFIX
+          @stack = Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        # @since 0.1.0
+        # @api private
+        def use(middleware, args, &blk)
+          @stack[@prefix].push([middleware, args, blk])
+        end
+
+        # @since 0.1.0
+        # @api private
+        def with(path)
+          prefix = @prefix
+          @prefix = path
+          yield
+        ensure
+          @prefix = prefix
+        end
+
+        # @since 0.1.0
+        # @api private
+        def finalize(app) # rubocop:disable Metrics/MethodLength
+          uniq!
+          return app if @stack.empty?
+
+          s = self
+
+          Rack::Builder.new do
+            s.each do |prefix, stack|
+              s.mapped(self, prefix) do
+                stack.each do |middleware, args, blk|
+                  use(middleware, *args, &blk)
+                end
+              end
+
+              run app
+            end
+          end
+        end
+
+        # @since 0.1.0
+        # @api private
+        def each(&blk)
+          uniq!
+          @stack.each(&blk)
+        end
+
+        # @since 0.1.0
+        # @api private
+        def mapped(builder, prefix, &blk)
+          if prefix == ROOT_PREFIX
+            builder.instance_eval(&blk)
+          else
+            builder.map(prefix, &blk)
+          end
+        end
+
+        private
+
+        # @since 0.1.0
+        # @api private
+        def uniq!
+          @stack.each_value(&:uniq!)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/api/router.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+require "hanami/api/block/context"
+
+module Hanami
+  class API
+    # @since 0.1.0
+    class Router < ::Hanami::Router
+      # @since 0.1.0
+      # @api private
+      def initialize(stack:, **kwargs, &blk)
+        @stack = stack
+        super(block_context: Block::Context, **kwargs, &blk)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def freeze
+        return self if frozen?
+
+        remove_instance_variable(:@stack)
+        super
+      end
+
+      # @since 0.1.0
+      # @api private
+      def use(middleware, *args, &blk)
+        @stack.use(middleware, args, &blk)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def scope(*args, **kwargs, &blk)
+        @stack.with(args.first) do
+          super
+        end
+      end
+    end
+  end
+end

data/lib/hanami/api/version.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Hanami
-  module Api
-    VERSION = "0.0.0"
+  class API
+    # @since 0.1.0
+    VERSION = "0.1.0"
   end
 end

metadata

@@ -1,44 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: hanami-api
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-04 00:00:00.000000000 Z
+date: 2020-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: hanami-router
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
-  type: :development
+        version: 2.0.alpha
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: 2.0.alpha
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
-description: Hanami API for fast, lightweight applications
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.79'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.79'
+description: Extremely fast and lightweight HTTP API
 email:
 - me@lucaguidi.com
 executables: []
@@ -46,6 +74,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
@@ -53,11 +84,18 @@ files:
 - bin/setup
 - hanami-api.gemspec
 - lib/hanami/api.rb
+- lib/hanami/api/block/context.rb
+- lib/hanami/api/error.rb
+- lib/hanami/api/middleware.rb
+- lib/hanami/api/router.rb
 - lib/hanami/api/version.rb
-homepage: http://hanamirb.org
+homepage: http://rubygems.org
 licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
+  homepage_uri: http://rubygems.org
+  source_code_uri: https://github.com/hanami/api
+  changelog_uri: https://github.com/hanami/api/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -66,15 +104,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Hanami API