fit_api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 47c9ea656a0413aed2e76fdbdd586c4df827a71fde3346eb1829526cf2d5fe72
+  data.tar.gz: 3105d64111f3d3bdb9fb1fc7882afe62498a0e06b40a363d7380e9a5713dd1d4
+SHA512:
+  metadata.gz: f02633bd1e2ce741ab55dd3e959827de5323458eeb3614be57759578537a2b64a52f43f1b51be4f55acf5566a138d89aa3307939cb421611a1e6039a4f120995
+  data.tar.gz: 4362fa551cf76e494f5408912da387c0553bbe469d574cd85123c56e022f25ab5539c48348870391e32d4b4f764488cd25673158eb83434e2759c0d09bbf5fc3

data/.gitignore

@@ -0,0 +1,5 @@
+.byebug_history
+*.swp
+Gemfile.lock
+/log
+/doc

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+ruby '2.5.3'
+
+gem 'rack', git: 'https://github.com/rack/rack.git'
+gem 'rack-test',     '~> 1.1.0'
+gem 'dry-inflector', '~> 0.1.2'

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright © 2014-2017 Luca Guidi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,309 @@
+# fit-api
+
+Lightweight framework for building JSON API's
+
+## Introduction
+
+fit-api is a 400 line dependency library based on Rack and inspired by Rails & Sinatra. 
+The goal of this library is to provide simplicity when developing an API with ruby.
+
+## Installation
+
+Install the latest version from RubyGems
+
+```
+$ gem install fit_api
+```
+
+## Table of Contents
+
+* [fit-api](#fit-api)
+    * [Table of Contents](#table-of-contents)
+    * [Usage](#usage)
+    * [Router](#router)
+        * [Resource/s](#resources)
+        * [Namespace](#namespace)
+        * [Controller](#controller)
+        * [Root](#root)
+        * [404](#customize-error-404-message)
+    * [Controllers](#controllers)
+        * [Request](#request)
+        * [Params](#params)
+        * [Headers](#request-headers)
+        * [Callbacks](#callbacks)
+    * [Rack Middlewares](#rack-middlewares)
+
+
+## Usage
+
+This is a basic example showing how it works... you can check the demo app from this repository:
+[fit-api-demo](/bermanya/fit-api-demo)
+
+**my_app.rb**
+
+```ruby
+require 'fit_api'
+
+require_relative 'routes'
+require_relative 'app_controller'
+
+Rack::Handler::WEBrick.run FitApi::App.new
+```
+
+**routes.rb**
+
+```ruby
+FitApi::Router.define do
+  get '/:name', to: 'app#show'
+
+  root to: 'app#index'
+end
+```
+
+**app_controller.rb**
+
+```ruby
+class AppController < FitApi::Controller
+  def index
+    json({ message: 'Hello world' })
+  end
+  
+  def show
+    json({ message: "Welcome #{params.name}" })
+  end
+end
+```
+
+```bash
+ruby my_app.rb
+```
+
+## Router
+
+It recognizes URLs and invoke the controller's action... the DSL is pretty similar to Rails (obviously not to so powerful):
+
+### HTTP methods:
+
+```ruby
+get '/test/:name',  to: 'app#test_show'
+post '/test',       to: 'app#test_post'
+put '/test',        to: 'app#test_put'
+delete '/test/:id', to: 'app#test_delete'
+```
+
+### Resources
+
+**Nested:**
+
+```ruby
+resources :users do
+  resource :avatar do
+    get :comments
+    post :add_comment
+  end
+end
+```
+
+**Endpoints for users:**
+
+|    Method   |        Path        |  Controller & action  |
+|-------------|--------------------|-----------------------|
+|  **GET**    | /users             | users#index           |
+|  **GET**    | /users/:id         | users#show            |
+|  **POST**   | /users             | users#create          |
+|  **PATCH**  | /users/:id         | users#update          |
+|  **DELETE** | /users/:id         | users#destroy         |
+
+**Endpoints for avatar:**
+
+|    Method   |                Path                |  Controller & action  |
+|-------------|------------------------------------|-----------------------|
+|  **GET**    | /users/:user_id/avatar             | avatar#show           |
+|  **POST**   | /users/:user_id/avatar             | avatar#create         |
+|  **PATCH**  | /users/:user_id/avatar             | avatar#update         |
+|  **DELETE** | /users/:user_id/avatar             | avatar#destroy        |
+|  **GET**    | /users/:user_id/avatar/comments    | avatar#comments       |
+|  **POST**   | /users/:user_id/avatar/add_comment | avatar#add_comment    |
+
+-----
+
+**Member & Collection:**
+
+```ruby
+resources :contacts, only: %i(index) do
+  member do
+    post :add_activity
+  end
+  
+  collection do
+    get :search
+  end
+end
+```
+
+|    Method   |           Path             |  Controller & action  |
+|-------------|----------------------------|-----------------------|
+|  **GET**    | /contacts                  | contacts#index        |
+|  **GET**    | /contacts/search           | contacts#search       |
+|  **POST**   | /contacts/:id/add_activity | contacts#add_activity |
+
+-----
+
+### Namespace
+
+Only for paths
+
+```ruby
+namespace :test do
+  get :hello_world 
+  post :hello_world, action: :post_hello_world 
+end
+```
+
+|   Method   |         Path       |  Controller & action  |
+|------------|--------------------|-----------------------|
+|  **GET**   | /test/hello_world  | test#hello_world      |
+|  **POST**  | /test/hello_world  | test#post_hello_world |
+
+-----
+
+```ruby
+namespace '/hello/world', controller: :test do
+  get :test
+end
+```
+
+|  Method  |         Path      |  Controller & action  |
+|----------|-------------------|-----------------------|
+|  **GET** | /test/world/test  | test#test             |
+
+-----
+
+### Controller
+
+```ruby
+controller :app do
+  get :another_action
+end
+```
+
+|   Method   |         Path      |  Controller & action  |
+|------------|-------------------|-----------------------|
+|  **GET**   | /another_action   | app#another_action    |
+
+-----
+
+### Root
+
+```ruby
+root to: 'app#index'
+```
+
+|  Method  |  Path  |  Controller & action  |
+|----------|--------|-----------------------|
+|  **GET** | /      | app#index             |
+
+-----
+
+### Customize error 404 message
+
+```ruby
+not_found 'app#error_404'
+```
+
+## Controllers
+
+The library provides one father class `FitApi::Controller` that should be inherited from your controllers.  
+One limitation is the class name of your controller must end with "Controller", i.e: AppController, UsersController...
+
+```ruby
+class AppController < FitApi::Controller
+  def index
+    json 'hello world'
+  end
+  
+  def process_post
+    json params 
+  end
+end 
+```
+
+You have the method `#json` available, basically, it sets the Response body.
+
+### Request
+
+You can access the Request object like this: `request`
+
+### Params
+
+Assuming the following requests:
+
+**GET /users/:id?name=Berna&age=28&height=180**
+
+```ruby
+params.id           # 1
+params.name         # "Berna"
+params[:age]        # 28
+params['height']    # 180
+```
+
+**POST /test** 
+
+With Params:
+
+```bash
+curl -i -X POST  -d 'user[name]=Berna&user[age]=28' http://server:1337/test
+```
+
+With JSON:
+
+```bash
+curl -i -X POST -H "Content-Type: application/json" -d '{ "user": { "name": "Berna", "age": 28 } }' http://server:1337/test
+```
+
+Then we have the following data in our `params` object:
+
+```ruby
+params.user             # > Params
+params.user.name        # "Berna"
+params[:user][:age]     # 28
+```
+
+### Request Headers
+
+```ruby
+request.headers['Authorization']
+```
+
+### Response Headers
+
+```ruby
+headers['Header-Key'] = 'Header Value'
+```
+
+### Callbacks
+
+```ruby
+before_action *actions
+after_action *actions, only: %i(index show)
+```
+
+## Rack Middlewares
+
+You can set up any rack middleware you want, i.e:
+
+**config.ru**
+
+```ruby
+require 'fit_api'
+
+use Rack::CommonLogger, Logger.new('log/app.log')
+
+run FitApi::App.new
+```
+
+## TODO:
+- [ ] Implement tests
+- [ ] Allow websockets -> `FitApi::Controller#stream`
+
+Any contribution would be appreciated =)  

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fit_api.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path("../lib/fit_api/version.rb", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'fit_api'
+  s.summary     = 'Lightweight framework for building APIs'
+  s.description = 'fit-api is a Rack based framework for building JSON APIs'
+  s.author      = 'Bernardo Castro'
+  s.email       = 'bernacas@gmail.com'
+  s.version     = FitApi.version
+  s.date        = Time.now.strftime("%Y-%m-%d")
+  s.license     = 'MIT'
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- spec/*`.split("\n")
+  s.required_ruby_version = '>= 2.2.0'
+  s.add_dependency 'rack', '~> 2.0'
+  s.add_dependency 'dry-inflector', '~> 0.1'
+end

data/lib/fit_api.rb

@@ -0,0 +1,12 @@
+require 'rack'
+require 'json/ext'
+require 'dry/inflector'
+
+require 'fit_api/app'
+require 'fit_api/controller'
+
+module FitApi
+  def self.inflector
+    @inflector ||= Dry::Inflector.new
+  end
+end

data/lib/fit_api/app.rb

@@ -0,0 +1,9 @@
+require 'fit_api/router'
+
+module FitApi
+  class App
+    def call(env)
+      Router.call(env)
+    end
+  end
+end

data/lib/fit_api/controller.rb

@@ -0,0 +1,48 @@
+module FitApi
+  class Controller
+    attr_accessor :response
+    attr_reader :request, :params, :headers
+
+    def initialize(request, params)
+      @request = request
+      @params  = params
+      @headers = {}
+    end
+
+    class << self
+      def actions
+        @actions ||= Hash.new { |h,k| h[k] = [] }
+      end
+
+      %i(before after).each do |callback_type|
+        define_method "#{callback_type}_action" do |*methods|
+          only = methods.last.is_a?(Hash) ? methods.last[:only] : nil
+          methods.each do |method|
+            unless method.is_a?(Hash) 
+              actions[callback_type] << { method: method, only: only }
+            end
+          end
+        end
+      end
+    end
+
+    def set_response_headers
+      response.add_header 'Content-Type', 'application/json'
+      response.add_header 'Date', Rack::Utils.rfc2822(Time.now)
+
+      headers.each &response.method(:add_header)
+    end
+
+    private
+
+    def json(hash, status: 200)
+      self.response = 
+        Rack::Response.new(hash.to_json, status)
+    end
+
+    def halt(status = 400, error)
+      json(error, status: status)
+      raise Halt
+    end
+  end
+end

data/lib/fit_api/router.rb

@@ -0,0 +1,36 @@
+require 'fit_api/router/mapper'
+
+module FitApi
+  module Router
+    def self.call(env)
+      method, path = env['REQUEST_METHOD'], env['PATH_INFO']
+      route = find method, path, path != '/'
+
+      return route.invoke(env) if route
+
+      res = path == '/' ? { message: 'fit-api is working!' } : { error: 'action not found' }
+
+      [ res[:error] ? 404 : 200, { 'Content-Type' => 'application/json'}, [ res.to_json ] ]
+    end
+
+    def self.find(method, path, find_error = true)
+      routes = mapper.routes[method.downcase]
+      route = routes.find { |route| route.match? path }
+
+      return route if route
+
+      if find_error 
+        not_found = find('get', '/404', false)
+        return not_found if not_found
+      end
+    end
+
+    def self.define(&block)
+      mapper.instance_eval &block
+    end
+
+    def self.mapper
+      @mapper ||= Mapper.new
+    end
+  end
+end

data/lib/fit_api/router/mapper.rb

@@ -0,0 +1,125 @@
+require 'fit_api/router/route'
+
+module FitApi
+  module Router
+    class Mapper
+      attr_reader :routes
+
+      def initialize
+        @routes = Hash.new { |h,k| h[k] = [] }
+        @namespaces = []
+      end
+
+      %w(get post put delete patch).each do |verb|
+        define_method verb do |path, options = {}|
+          options[:controller] ||= @controller
+          route = Route.new(verb, "#{@namespaces.join}#{fix_path(path)}", options)
+          @routes[verb] << route
+        end
+      end
+
+      %i(resource resources).each do |resource_type|
+        define_method resource_type do |resource, options = {}, &block|
+          set_resource resource_type, resource, options, &block
+        end
+      end
+
+      def root(to:)
+        get '', to: to
+      end
+
+      def not_found(to)
+        get '/404', to: to
+      end
+
+      def member(&block)
+        namespace '/:id', &block
+      end
+
+      def collection(&block)
+        instance_eval &block
+      end
+
+      def namespace(path, options = {}, &block)
+        @namespaces << fix_path(path)
+        if controller = options[:controller] || path
+          previous, @controller = @controller, controller
+        end
+        instance_eval &block
+        @controller = previous if controller
+        @namespaces.pop
+      end
+
+      def controller(controller, &block)
+        @controller = controller
+        instance_eval &block
+        @controller = nil
+      end
+
+      private
+
+      def set_resource(type, resource, options, &block)
+        options[:only] ||= %i(index show create update destroy)
+        path = get_path(type, resource)
+
+        @parent = [ type, resource ]
+        @controller = options[:controller] || resource
+
+        namespace path, options do
+          set_actions type, resource, options[:only]
+          instance_eval &block if block
+        end
+
+        @parent, @controller = nil, nil
+      end
+
+      def set_actions(type, resource, actions)
+        path = get_resource_path(type)
+
+        actions.delete(:index) if type == :resource
+
+        actions.each do |action|
+          case action
+          when :index
+            get '', to: "#{resource}#index"
+          when :create
+            post '', to: "#{resource}#create"
+          when :show
+            get path, to: "#{resource}#show"
+          when :update
+            patch path, to: "#{resource}#update"
+          when :destroy
+            delete path, to: "#{resource}#destroy"
+          end
+        end
+      end
+
+      def get_path(type, resource)
+        return "/:#{s(@parent.last)}_id/#{resource}"    if type == :resources && parent_is?(:resources)
+        return "/:#{s(@parent.last)}_id/#{s(resource)}" if type == :resource  && parent_is?(:resources)
+        return "/#{s(resource)}"                       if type == :resource  && parent_is?(:resource)
+        return "/#{resource}"
+      end
+
+      def parent_is?(type)
+        @parent && @parent.first == type
+      end
+
+      def get_resource_path(type)
+        return type == :resources ? '/:id' : ''
+      end
+
+      def fix_path(path)
+        if path.is_a?(Symbol) || path[0] != '/' && path != ''
+          "/#{path}"
+        else
+          path
+        end
+      end
+
+      def s(word)
+        FitApi.inflector.singularize(word)
+      end
+    end
+  end
+end

data/lib/fit_api/router/params.rb

@@ -0,0 +1,51 @@
+module FitApi
+  module Router 
+    class Params
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def to_json
+        @hash.to_json
+      end
+
+      def [](key)
+        value = @hash[key.to_s]
+
+        if value.is_a?(Hash)
+          self.class.new(value) 
+        else
+          value
+        end
+      end
+
+      def []=(key, value)
+        @hash[key.to_s] = value
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        if @hash.include? method_sym.to_s
+          send('[]', method_sym.to_s)
+        else
+          nil
+        end
+      end
+
+      def except(*blacklist)
+        Params.new(
+          {}.tap do |h|
+            (@hash.keys - blacklist.map(&:to_s)).each { |k| h[k] = @hash[k] }
+          end
+        )
+      end
+
+      def permit(*whitelist)
+        Params.new(
+          {}.tap do |h|
+            (@hash.keys & whitelist.map(&:to_s)).each { |k| h[k] = @hash[k] }
+          end
+        )
+      end
+    end
+  end
+end

data/lib/fit_api/router/parser.rb

@@ -0,0 +1,41 @@
+module FitApi
+  module Router
+    class Parser
+      attr_reader :params
+
+      def initialize(route, path)
+        @route = route
+        @path  = path.gsub(/\/$/, '')
+        @match = false
+        @params = {}
+
+        parse
+      end
+
+      def match?
+        @match
+      end
+
+      private
+
+      def parse
+        result = @path.scan(/^#{regexp}$/)
+        set_params(result.flatten) if result.any?
+      end
+
+      def set_params(result)
+        @match = true 
+        params = @route.scan(/\/\:+(\w+)/).flatten
+
+        params.each_index do |i|
+          @params[params[i]] = 
+            result[i].match(/^\d+$/) ? result[i].to_i : URI.decode(result[i])
+        end
+      end
+
+      def regexp
+        @route.gsub(/\:\w+/, '([^\/]*)')
+      end
+    end
+  end
+end

data/lib/fit_api/router/route.rb

@@ -0,0 +1,74 @@
+require 'fit_api/router/parser'
+require 'fit_api/router/params'
+
+module FitApi
+  module Router
+    class Route
+      attr_reader :verb, :path, :controller, :action
+
+      def initialize(verb, path, options = {})
+        @verb       = verb
+        @path       = path
+        @controller = get_controller(options)
+        @action     = get_action(options)
+      end
+
+      def invoke(env)
+        request      = Request.new(env)
+        route_params = parse(request.path).params
+        json_params  = JSON.parse(request.body.read) rescue {}
+        params       = Params.new(request.params.merge(route_params).merge(json_params))
+        controller   = Object.const_get("#{@controller.capitalize}Controller").new(request, params)
+
+        run! controller
+      rescue Halt
+        controller.response
+      end
+
+      def match?(path)
+        parse(path).match?
+      end
+
+      private
+
+      def get_controller(options)
+        return options[:controller] if options[:controller]
+        options[:to].split('#').first
+      end
+
+      def get_action(options)
+        return options[:action] if options[:action]
+        return options[:to].split('#').last if options[:to]
+        path[/\w+$/]
+      end
+
+      def parse(path)
+        Parser.new(@path, path)
+      end
+
+      def run!(controller)
+        run_callbacks! controller, :before
+        controller.send action
+        run_callbacks! controller, :after
+        controller.response
+      ensure
+        controller.set_response_headers
+      end
+
+      def run_callbacks!(controller, type)
+        controller.class.actions[type].each do |action|
+          if action[:only].nil? || action[:only].include?(@action.to_sym)
+            controller.send action[:method]
+          end
+        end
+      end
+    end
+
+    class Request < Rack::Request
+      def headers
+        env.select { |k,v| k.start_with? 'HTTP_'}.
+          transform_keys { |k| k.sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-') }
+      end
+    end
+  end
+end

data/lib/fit_api/version.rb

@@ -0,0 +1,3 @@
+module FitApi
+  def self.version; '1.0.0' end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: fit_api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bernardo Castro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: fit-api is a Rack based framework for building JSON APIs
+email: bernacas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- fit_api.gemspec
+- lib/fit_api.rb
+- lib/fit_api/app.rb
+- lib/fit_api/controller.rb
+- lib/fit_api/router.rb
+- lib/fit_api/router/mapper.rb
+- lib/fit_api/router/params.rb
+- lib/fit_api/router/parser.rb
+- lib/fit_api/router/route.rb
+- lib/fit_api/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Lightweight framework for building APIs
+test_files: []