fit_api 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 0d176cc7557464b1cb5b9756b11feb083c8ec735799d2d89e587d3a271794b86
-  data.tar.gz: 5a0a48d8fbf84fd0abd3e82b004b34f9393a522a2cdec75250d6698840cc8dd7
+SHA1:
+  metadata.gz: 5922975501ebc48453cb5a6f7ad438befbe85d0b
+  data.tar.gz: 9d93fc4af41f39e28581820d75d699d0638c9ce6
 SHA512:
-  metadata.gz: c079a3c4f083fd3543878d9e6d9cf030ee28b9f91ce67a94b4ca31a5d70c6128f3de32c09822b109ce4188ff897b6dc6b7298f8aa73205a7d05f56c67253fc36
-  data.tar.gz: ca6de1c94256a2840192be7e3fea05d5575a4d57a747be8026540590ca22448a6d40f5fcee52b713a3d7b0f84873b685521a45e7f388be66c00b83d239276fe5
+  metadata.gz: 88eb8fa868fd5e0084a81c3bb4ed2e1672b128b27f6be74914cda3f13d527dae03d4dd54e167551473ef8b91317218f6e3ad898fe229e4361a41d9c5b21e4d52
+  data.tar.gz: c9e11e13e75c4f5bf4a88ac62b63a73c198be62b77a07810635ee959d434cde146db11218c40b7b9a0df06b4285cf00974723ae7bb2f3e28c466fa4ccd30e981

data/Gemfile

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

data/README.md

@@ -1,6 +1,6 @@
 # fit-api
 
-Lightweight framework for building JSON API's
+Lightweight framework for building JSON API"s
 
 ## Introduction
 
@@ -37,63 +37,61 @@ $ gem install fit_api
 ## Usage
 
 This is a basic example showing how it works... you can check the demo app from this repository:
-[fit-api-demo](http://github.com/bermanya/fit-api-demo)
+[fit-api-demo](http://github.com/bermanya/minesweeper-api)
 
 **api.rb**
 
 ```ruby
-require 'fit_api'
+# optional:
+FitApi::Router.auto_load_path "controllers"
 
 FitApi::Router.define do
-  get '/:name', to: 'app#show'
+  get "/:name", to: "app#show"
 
-  root to: 'app#index'
+  root to: "app#index"
 end
+```
+
+**controllers/app_controllers.rb**
 
+```
 class AppController < FitApi::Controller
   def index
-    json({ message: 'Hello world' })
+    json(message: "Hello world")
   end
   
   def show
-    json({ message: "Welcome #{params.name}" })
+    if found
+      json(message: "Welcome #{params.name}")
+    else
+      json(404, error: "not found")
+    end
   end
 end
-
-# You can setup any Rack Middleware
-
-FitApi.use Rack::CommonLogger, Logger.new('log/app.log')
-
-Rack::Handler::WEBrick.run FitApi.app
 ```
 
 ```bash
-ruby api.rb
+rackup
 ```
 
 ## Router
 
-It recognizes URLs and invoke the controller's action... the DSL is pretty similar to Rails (obviously not so powerful):
+It recognizes URLs and invoke the controller"s action... the DSL is pretty similar to Rails (obviously not 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'
+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
 
-You can pass the following options:
-
-```
-only
-except
-controller
+You can pass the following options: `only, except, controller`
 ```
 
 **Nested:**
@@ -133,7 +131,7 @@ end
 **Member & Collection:**
 
 ```ruby
-resources :contacts, only: %i(index) do
+resources :contacts, only: :index do
   member do
     post :add_activity
   end
@@ -171,14 +169,14 @@ end
 -----
 
 ```ruby
-namespace '/hello/world', controller: :test do
+namespace "/hello/world", controller: :test do
   get :test
 end
 ```
 
 |  Method  |         Path      |  Controller & action  |
 |----------|-------------------|-----------------------|
-|  **GET** | /test/world/test  | test#test             |
+|  **GET** | /hello/world/test  | test#test             |
 
 -----
 
@@ -187,7 +185,7 @@ end
 ```ruby
 controller :app do
   get :another_action
-  get '/welcome', action: 'hello_world'
+  get "/welcome", action: "hello_world"
 end
 ```
 
@@ -201,7 +199,7 @@ end
 ### Root
 
 ```ruby
-root to: 'app#index'
+root to: "app#index"
 ```
 
 |  Method  |  Path  |  Controller & action  |
@@ -213,7 +211,7 @@ root to: 'app#index'
 ### Customize error 404 message
 
 ```ruby
-not_found to: 'app#error_404'
+not_found to: "app#error_404"
 ```
 
 ## Controllers
@@ -224,17 +222,15 @@ One limitation is the class name of your controller must end with "Controller",
 ```ruby
 class AppController < FitApi::Controller
   def index
-    json 'hello world'
+    json "hello world"
   end
   
-  def process_post
-    json resource, 201
+  def create
+    json 201, resource
   end
 end 
 ```
 
-You have the method `#json` available, which basically sets the response body.  
-
 Default status code: ```200```
 
 ----
@@ -254,8 +250,8 @@ You can exit the current action throwing an exception... the default status code
 ```ruby
 halt
 halt 500
-halt 404, 'Not found'
-halt 'Error message'
+halt 404, "Not found"
+halt "Error message"
 ```
 
 ----
@@ -265,33 +261,33 @@ halt 'Error message'
 #### GET /users
 
 ```bash
-curl -i http://localhost:1337/users/:id?name=Berna&age=28&height=180
+curl -i http://localhost:1337/users/:id?name=Berna&level=1&xp=70
 ```
 
 ```ruby
 params.id         # 1
 params.name       # "Berna"
-params[:age]      # 28
-params['height']  # 180
+params[:level]    # 1
+params["xp"]      # 70
 ```
 
 #### POST with params:
 
 ```bash
-curl -i -X POST  -d 'user[name]=Berna&user[age]=28' http://localhost:1337/users
+curl -i -X POST  -d "user[name]=Berna&user[level]=1" http://localhost:1337/users
 ```
 
 #### POST with JSON:
 
 ```bash
-curl -i -X POST -H "Content-Type: application/json" -d '{ "user": { "name": "Berna", "age": 28 } }' http://localhost:1337/users
+curl -i -X POST -H "Content-Type: application/json" -d "{ "user": { "name": "Berna", "xp": 50 } }" http://localhost:1337/users
 ```
 
 Result:
 
 ```ruby
 params.user.name     # "Berna"
-params[:user][:age]  # "28"
+params[:user][:xp]   # 50
 ```
 
 ----
@@ -299,7 +295,7 @@ params[:user][:age]  # "28"
 #### #permit
 
 ```ruby
-params.user.permit(:name, :age)
+params.user.permit(:name, :level, :xp)
 ```
 
 ----
@@ -315,7 +311,7 @@ params.user.except(:height)
 ### Request Headers
 
 ```ruby
-request.headers['Authorization']
+request.headers["Authorization"]
 ```
 
 ----
@@ -323,7 +319,7 @@ request.headers['Authorization']
 ### Response Headers
 
 ```ruby
-headers['Header-Name'] = 'Header Value'
+headers["Header-Name"] = "Header Value"
 ```
 
 ----
@@ -332,7 +328,7 @@ headers['Header-Name'] = 'Header Value'
 
 ```ruby
 before_action *actions, only: %i(index show)
-after_action *actions, except: %i(destroy)
+after_action *actions, except: :destroy
 ```
 
 ## TODO:

data/lib/fit_api.rb

@@ -1,10 +1,12 @@
-require 'rack'
-require 'json/ext'
-require 'dry/inflector'
+# frozen_string_literal: true
 
-require 'fit_api/version'
-require 'fit_api/router'
-require 'fit_api/controller'
+require "rack"
+require "json/ext"
+require "dry/inflector"
+
+require "fit_api/version"
+require "fit_api/router"
+require "fit_api/controller"
 
 module FitApi
   def self.builder

data/lib/fit_api/controller.rb

@@ -1,14 +1,19 @@
+# frozen_string_literal: true
+
 module FitApi
   class Halt < StandardError; end
 
   class Controller
-    attr_accessor :response
+    attr_accessor :response, :action
     attr_reader :request, :params, :headers
 
     def initialize(request, params)
       @request = request
       @params  = params
-      @headers = {}
+
+      set_default_headers
+
+      @response = [ 501, @headers, [ 'Not implemented' ] ]
     end
 
     class << self
@@ -18,35 +23,65 @@ module FitApi
 
       %i(before after).each do |callback_type|
         define_method "#{callback_type}_action" do |*callbacks|
-          executable_actions = callbacks.last.is_a?(Hash) ? callbacks.last : {}
+          options = callbacks.last.is_a?(Hash) ? callbacks.last : {}
 
           callbacks.each do |method|
-            unless method.is_a?(Hash) 
-              actions[callback_type] << { method: method }.merge(executable_actions)
-            end
+            next if method.is_a?(Hash) 
+            actions[callback_type] << { method: method }.merge(options)
           end
         end
       end
     end
 
-    def set_response_headers
-      headers['Date'] ||= Rack::Utils.rfc2822(Time.now)
-      headers['Content-Type'] ||= 'application/json'
-
-      headers.each &response.method(:add_header)
-    end
-
-    def json(object, status = 200)
-      self.response = Rack::Response.new(JSON.pretty_generate(object), status)
+    def json(status = 200, data)
+      data = data.to_h unless data.is_a?(Hash) && data.is_a?(String)
+      json = JSON.pretty_generate(data)
+      @response = [ status, headers, [ json ] ]
     end
 
     def halt(*args)
       is_int = args.first.is_a?(Integer)
       status = is_int ? args.first : 400
-      error  = is_int ? (args.count > 1 ? args.last : '') : args.first
+      error  = is_int ? (args.count > 1 ? args.last : "") : args.first
 
-      json(error, status)
+      json(status, error.to_h)
       raise Halt
     end
+
+    def invoke(action)
+      return unless respond_to?(action)
+      self.action = action.to_sym
+      trigger_callbacks(:before, action)
+      send(action)
+      trigger_callbacks(:after, action)
+      @response
+    end
+
+    private
+
+    def set_default_headers
+      @headers = {
+        "Date"         => Rack::Utils.rfc2822(Time.now),
+        "Content-Type" => "application/json"
+      }
+    end
+
+    def trigger_callbacks(type, action)
+      klass = self.class
+      while klass != Object
+        actions = klass.actions[type].each do |rule|
+          send(rule[:method]) if run?(rule, action.to_sym)
+        end
+        klass = klass.superclass
+      end
+    end
+
+    def run?(rule, action)
+      except, only = Array(rule[:except]), Array(rule[:only])
+
+      except.any? && !except.include?(action) ||
+        only.any? && only.include?(action) ||
+          only.empty? && except.empty?
+    end
   end
 end

data/lib/fit_api/router.rb

@@ -1,36 +1,45 @@
-require 'fit_api/router/mapper'
+# frozen_string_literal: true
+
+require "fit_api/router/mapper"
 
 module FitApi
   module Router
-    def self.call(env)
-      method, path = env['REQUEST_METHOD'], env['PATH_INFO']
-      is_root = path == '/'
+    module_function
 
-      if route = Router.find(method, path, !is_root)
-        route.invoke(env)
-      else
-        status = is_root ? 200 : 404
-        res    = is_root ? 'fit-api is working!' : 'Action not found'
+    def call(env)
+      method, path = env["REQUEST_METHOD"], env["PATH_INFO"]
+      is_root = path == "/"
 
-        [ status, { 'Content-Type' => 'application/json' }, [ res.to_json ] ]
+      if route = find(method, path, !is_root)
+        return route.invoke(env)
       end
+
+      status = is_root ? 200 : 404
+      res    = is_root ? "fit-api is working!" : "Action not found"
+
+      [ status, { "Content-Type" => "application/json" }, [ res.to_json ] ]
     end
 
-    def self.find(method, path, find_not_found_action = true)
+    def find(method, path, fetch_not_found = true)
       route = mapper.routes[method.downcase].find { |route| route.match? path }
       return route if route
 
-      if find_not_found_action
-        not_found = find('get', '/404', false)
+      if fetch_not_found
+        not_found = find("get", "/404", false)
         return not_found if not_found
       end
     end
 
-    def self.define(&block)
+    def auto_load_path(path = nil)
+      return @auto_load_path unless path
+      @auto_load_path = path
+    end
+
+    def define(&block)
       mapper.instance_eval &block
     end
 
-    def self.mapper
+    def mapper
       @mapper ||= Mapper.new
     end
   end

data/lib/fit_api/router/mapper.rb

@@ -1,4 +1,6 @@
-require 'fit_api/router/route'
+# frozen_string_literal: true
+
+require "fit_api/router/route"
 
 module FitApi
   module Router
@@ -13,6 +15,7 @@ module FitApi
       %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
@@ -25,15 +28,15 @@ module FitApi
       end
 
       def root(to:)
-        get '', to: to
+        get "", to: to
       end
 
       def not_found(to:)
-        get '/404', to: to
+        get "/404", to: to
       end
 
       def member(&block)
-        namespace '/:id', controller: @controller, &block
+        namespace "/:id", controller: @controller, &block
       end
 
       def collection(&block)
@@ -79,8 +82,8 @@ module FitApi
         only    = options[:only]
         except  = options[:except]
  
-        return actions & only   if only
-        return actions - except if except
+        return actions & Array(only)   if only
+        return actions - Array(except) if except
 
         actions
       end
@@ -93,9 +96,9 @@ module FitApi
         actions.each do |action|
           case action
           when :index
-            get '', to: "#{resource}#index"
+            get "", to: "#{resource}#index"
           when :create
-            post '', to: "#{resource}#create"
+            post "", to: "#{resource}#create"
           when :show
             get path, to: "#{resource}#show"
           when :update
@@ -118,13 +121,13 @@ module FitApi
       end
 
       def get_resource_path(type)
-        return type == :resources ? '/:id' : ''
+        return type == :resources ? "/:id" : ""
       end
 
       def fix_path(path)
-        fix = path.is_a?(Symbol) || path[0] != '/' && path != ''
+        fix = path.is_a?(Symbol) || path[0] != "/" && path != ""
         path = fix ? "/#{path}" : path
-        path.gsub(/\/$/, '')
+        path.gsub(/\/$/, "")
       end
 
       def s(word)

data/lib/fit_api/router/params.rb

@@ -1,54 +1,37 @@
+# frozen_string_literal: true
+
 module FitApi
   module Router 
-    class Params
-      def initialize(hash)
-        @hash = hash
-      end
-
-      def to_h
-        @hash
-      end
-
-      def to_json
-        @hash.to_json
-      end
-
+    module Params
       def [](key)
-        value = @hash[key.to_s]
-
+        value = super(key.to_s)
         if value.is_a?(Hash)
-          self.class.new(value) 
-        else
-          value
+          value.extend(Params)
         end
+        value
       end
 
-      def []=(key, value)
-        @hash[key.to_s] = value
+      def except(*blacklist)
+        blacklist.map!(&:to_s)
+        build(keys - blacklist)
       end
 
-      def method_missing(method_sym, *arguments, &block)
-        if @hash.include? method_sym.to_s
-          send('[]', method_sym.to_s)
-        else
-          nil
-        end
+      def permit(*whitelist)
+        whitelist.map!(&:to_s)
+        build(keys & whitelist)
       end
 
-      def except(*blacklist)
-        Params.new(
-          {}.tap do |h|
-            (@hash.keys - blacklist.map(&:to_s)).each { |k| h[k] = @hash[k] }
-          end
-        )
+      private
+
+      def build(new_keys)
+        {}.tap do |h|
+          new_keys.each { |k| h[k] = self[k] }
+        end.extend(Params)
       end
 
-      def permit(*whitelist)
-        Params.new(
-          {}.tap do |h|
-            (@hash.keys & whitelist.map(&:to_s)).each { |k| h[k] = @hash[k] }
-          end
-        )
+      def method_missing(method_sym, *args, &block)
+        attr = self.key?(method_sym) ? method_sym : method_sym.to_s
+        self[attr]
       end
     end
   end

data/lib/fit_api/router/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FitApi
   module Router
     class Parser
@@ -5,7 +7,7 @@ module FitApi
 
       def initialize(route, path)
         @route = route
-        @path  = path.gsub(/\/$/, '')
+        @path  = path.gsub(/\/$/, "")
         @match = false
         @params = {}
 
@@ -29,12 +31,12 @@ module FitApi
 
         params.each_index do |i|
           @params[params[i]] = 
-            result[i].match(/^\d+$/) ? result[i].to_i : URI.decode(result[i])
+            result[i].match(/^\d+$/) ? result[i].to_i : URI.decode_www_form_component(result[i])
         end
       end
 
       def regexp
-        @route.gsub(/\:\w+/, '([^\/]*)')
+        @route.gsub(/\:\w+/, "([^\/]*)")
       end
     end
   end

data/lib/fit_api/router/route.rb

@@ -1,87 +1,68 @@
-require 'fit_api/router/parser'
-require 'fit_api/router/params'
+# frozen_string_literal: true
+
+require "fit_api/router/parser"
+require "fit_api/router/params"
 
 module FitApi
   module Router
-    class Route
-      attr_reader :verb, :path, :controller, :action
+    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
 
+    class Route
       def initialize(verb, path, options = {})
         @verb       = verb
         @path       = path
         @controller = get_controller(options)
         @action     = get_action(options)
+
+        require_controller
       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.to_s.capitalize}Controller").new(request, params)
+        request    = Request.new(env)
+        params     = build_params(request)
+        controller = Object.const_get("#{@controller.to_s.capitalize}Controller").new(request, params)
 
-        run! controller
+        controller.invoke(@action)
       rescue Halt
-        controller.set_response_headers
         controller.response
-      rescue Exception => ex
-        error = { message: "#{ex.message} (#{ex.class})", backtrace: ex.backtrace }
-        controller.json(ENV['RACK_ENV'] == 'production' ? 'An error has occured' : error, 500)
       end
 
       def match?(path)
-        parse(path).match?
+        Parser.new(@path, path).match?
       end
 
       private
 
       def get_controller(options)
         return options[:controller] if options[:controller]
-        options[:to].split('#').first
+        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)
+        return options[:to].split("#").last if options[:to]
+        @path[/\w+$/]
       end
 
-      def run!(controller)
-        run_callbacks! controller, :before
-        controller.send action
-        run_callbacks! controller, :after
-        controller.set_response_headers
-        controller.response
-      end
-
-      def run_callbacks!(controller, type)
-        klass = controller.class
-
-        while klass != Object
-          actions = klass.actions[type].each do |rule|
-            controller.send(rule[:method]) if run?(rule)
-          end
-          klass = klass.superclass
+      def require_controller
+        if path = Router.auto_load_path
+          require "./#{path}/#{@controller}_controller"
         end
       end
 
-      def run?(rule)
-        except, only = rule[:except], rule[:only]
+      def build_params(request)
+        route_params = Parser.new(@path, request.path).params
+        params       = JSON.parse(request.body.read) rescue request.params
 
-        except && !except.map(&:to_s).include?(action) ||
-          only && only.map(&:to_s).include?(action) ||
-            !only && !except
-      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('-') }
+        new_params = params.merge(route_params)
+        new_params.extend(Params)
+        new_params.with_indifferent_access
+        new_params
       end
     end
   end

data/lib/fit_api/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module FitApi
   def self.version
-    '1.1.2'
+    "1.1.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fit_api
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Bernardo Castro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-31 00:00:00.000000000 Z
+date: 2020-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -78,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Lightweight framework for building APIs