Initial mess

Author: jodosha

.gitignore

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

.rspec

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

.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

Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+gemspec
+
+gem "byebug", require: false
+gem "hanami-router", git: "https://github.com/hanami/router.git", branch: "feature/tree-rewrite"

README.md

@@ -0,0 +1,36 @@
+# 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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hanami-api'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install hanami-api
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jodosha/hanami-api.
+

Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rake"
+require "bundler/gem_tasks"
+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"

bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "hanami/api"
+
+# 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(__FILE__)

bin/setup

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

hanami-api.gemspec

@@ -0,0 +1,37 @@
+# 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.authors       = ["Luca Guidi"]
+  spec.email         = ["me@lucaguidi.com"]
+
+  spec.summary       = "Hanami API"
+  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["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"
+
+  # 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_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

lib/hanami/api.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Hanami
+  # Hanami::API
+  #
+  # @since 0.1.0
+  class API
+    require "hanami/api/version"
+    require "hanami/api/error"
+    require "hanami/api/router"
+    require "hanami/api/middleware"
+
+    def self.inherited(app)
+      super
+
+      app.class_eval do
+        @routes = []
+        @stack = Middleware::Stack.new
+      end
+    end
+
+    class << self
+      attr_reader :routes, :stack
+    end
+
+    def self.root(*args, **kwargs, &blk)
+      @routes << [:root, args, kwargs, blk]
+    end
+
+    def self.get(*args, **kwargs, &blk)
+      @routes << [:get, args, kwargs, blk]
+    end
+
+    def self.post(*args, **kwargs, &blk)
+      @routes << [:post, args, kwargs, blk]
+    end
+
+    def self.patch(*args, **kwargs, &blk)
+      @routes << [:patch, args, kwargs, blk]
+    end
+
+    def self.put(*args, **kwargs, &blk)
+      @routes << [:put, args, kwargs, blk]
+    end
+
+    def self.delete(*args, **kwargs, &blk)
+      @routes << [:delete, args, kwargs, blk]
+    end
+
+    def self.trace(*args, **kwargs, &blk)
+      @routes << [:trace, args, kwargs, blk]
+    end
+
+    def self.options(*args, **kwargs, &blk)
+      @routes << [:options, args, kwargs, blk]
+    end
+
+    def self.link(*args, **kwargs, &blk)
+      @routes << [:link, args, kwargs, blk]
+    end
+
+    def self.unlink(*args, **kwargs, &blk)
+      @routes << [:unlink, args, kwargs, blk]
+    end
+
+    def self.redirect(*args, **kwargs, &blk)
+      @routes << [:redirect, args, kwargs, blk]
+    end
+
+    def self.scope(*args, **kwargs, &blk)
+      @routes << [:scope, args, kwargs, blk]
+    end
+
+    def self.mount(*args, **kwargs, &blk)
+      @routes << [:mount, args, kwargs, blk]
+    end
+
+    def self.use(middleware, *args, &blk)
+      @stack.use(middleware, args, &blk)
+    end
+
+    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
+
+    def freeze
+      @app = @stack.finalize(@router)
+      remove_instance_variable(:@stack)
+      @router.freeze
+      super
+    end
+
+    def call(env)
+      @app.call(env)
+    end
+
+    # TODO: verify if needed here on in block context
+    def path(name, variables = {})
+      @router.path(name, variables)
+    end
+
+    # TODO: verify if needed here on in block context
+    def url(name, variables = {})
+      @router.url(name, variables)
+    end
+  end
+end

lib/hanami/api/block/context.rb

@@ -0,0 +1,70 @@
+# 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
+        def body(value = nil)
+          if value
+            @body = value
+          else
+            @body
+          end
+        end
+
+        def halt(status, body = nil)
+          body ||= http_status(status)
+          throw :halt, [status, body]
+        end
+
+        def redirect(url, status = 301)
+          headers["Location"] = url
+          halt(status)
+        end
+
+        def back
+          env["HTTP_REFERER"] || "/"
+        end
+
+        def json(object, mime = "application/json")
+          headers["Content-Type"] = mime
+          JSON.generate(object)
+        end
+
+        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
+
+        def caught
+          result = nil
+          halted = catch :halt do
+            result = instance_exec(&@blk)
+            nil
+          end
+
+          halted || result
+        end
+
+        def http_status(code)
+          Rack::Utils::HTTP_STATUS_CODES.fetch(code)
+        end
+      end
+    end
+  end
+end

lib/hanami/api/error.rb

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