know_it_all 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4550ab98d97e3e526452bbf3e1b7e8dd22bbe8ed
+  data.tar.gz: 707163abb17202e76a11f7fb7edf4b17438bd57d
+SHA512:
+  metadata.gz: c4a86f9030e144126720a63363418073bd8837db9b2ab2e42426d25a7c459cf83b034bc6f62a44940680058ae990f559f5ea7991b35bf23b0acc50c71b308919
+  data.tar.gz: 3be9fcdaa02b1de4ddbcdc752e8f0639a0656c0c73edf9d5420302e0cde436a517429f6cd78d14af458ec1e32dca0ceefd97527373b1fac39dd23714526529f5

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.ruby-version
+.ruby-gemset

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in know_it_all.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 mrodrigues
+
+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,379 @@
+> Well, actually...
+
+# KnowItAll
+
+KnowItAll is a small, object-oriented approach to authorization. It knows everything about your application!
+
+More of an architectural pattern for API-focused authorization than properly a dependency, and heavily inspired by [Pundit](https://github.com/elabs/pundit), this gem simply provides a small set of helpers that make applying the pattern easier.
+
+If your application needs to validate pre-requisites before performing certain actions, at the same time providing helpful error messages for the API's clients, all that while using regular magic-less Ruby and object oriented design patterns, KnowItAll is your friend.
+
+## Why?
+
+The assumption made is that each action has its own requirements based on the current context. Some may be related to the current user's permissions in the system, others with the parameters sent, and others yet may even have nothing to do with any input received. Let's say you're building the API for a food delivery app. To be able to checkout, you need to validate the following requirements:
+
+- The user must be signed in;
+- The user must have a registered address;
+- The registered address must be within a determined radius;
+- The cart must contain at least $10 in items;
+- The chosen items must be available for delivery;
+- The store must be open.
+
+It'd be very helpful for a developer consuming this API if, in case of failure, the API returned an appropriate error message explaining exactly what when wrong, instead of an empty `403 Forbidden`. Performing this manually is easy, but quickly polutes the action's code:
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    return error("User must be signed in") unless current_user
+    return error("User must have a registered address") unless current_user.address
+    return error("Registered address is outside the range") unless address_in_range?(current_user.address)
+    return error("Cart must contain at least $10 in items") unless cart_has_minimum?(cart)
+    return error("Some of the items are not available") unless items_available?(cart.items)
+    return error("The store is closed") unless store.open?
+
+    # Here finally starts what the action actually does
+    order = Order.create(order_params)
+    if order.save
+      render json: order, status: :created
+    else
+      render json: { errors: order.errors }, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+    def error(message)
+      render json: { error: message }, status: :forbidden
+    end
+end
+```
+
+It's much more readable, as well as easier to test and extend, if all of those requirement tests were contained in a proper class:
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    policy = OrdersPolicies::Create.new(current_user, cart, store)
+    return render json: { errors: policy.errors } unless policy.authorize?
+
+    order = Order.create(order_params)
+    if order.save
+      render json: order, status: :created
+    else
+      render json: { errors: order.errors }, status: :unprocessable_entity
+    end
+  end
+end
+```
+
+That's exactly the architectural pattern encouraged by this gem. By including a small set of helpers, it makes it extremely simple to perform complex validations and provide helpful feedback through the API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'know_it_all'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install know_it_all
+
+## Usage
+
+There are two steps to using this gem: creating and using policies:
+
+### Creating policies
+
+A policy is simply a class obeys some rules:
+
+* It is initialized with the same arguments that are passed to the `authorize`, `authorize!` and `authorize?` methods in the controller;
+* It responds to a method `errors`;
+* Calling `errors` returns an object that responds to the method `empty?` and is serializable. It's usually an array, but it could easily be an `ActiveModel::Errors`.
+
+Here's an example:
+
+```ruby
+module OrdersPolicies
+  class Create
+    def initialize(current_user, cart, store)
+      @current_user = current_user
+      @cart = cart
+      @store = store
+    end
+
+    def errors
+      @errors = []
+      @errors << "User must be signed in" unless @current_user
+      @errors << "User must have a registered address" unless @current_user.address
+      @errors << "Registered address is outside the range" unless address_in_range?(current_user.address)
+      @errors << "Cart must contain at least $10 in items" unless cart_has_minimum?(@cart)
+      @errors << "Some of the items are not available" unless items_available?(@cart.items)
+      @errors << "The store is closed" unless @store.open?
+    end
+  end
+end
+```
+
+Using `ActiveModel::Validations`:
+
+```ruby
+module OrdersPolicies
+  class Create
+    includes ActiveModel::Validations
+
+    validates_presence_of :current_user, :address
+    validate :address_in_range
+    validate :cart_has_minimum
+    validate :items_are_available
+    validate :store_is_open
+
+    def initialize(current_user, cart, store)
+      @current_user = current_user
+      @cart = cart
+      @store = store
+
+      run_validations! # Populates the `ActiveModel::Errors`
+    end
+  end
+end
+```
+
+#### Naming convention
+
+The convention `KnowItAll` uses for defining the name of the constant containing the appropriate policy is the following:
+
+* Based on the `controller_path` method on the controller, it builds a module name by appending the `Policies` suffix: `"orders"` becomes `"OrdersPolicies"` and `"admin/dashboard_panel"` becomes `"Admin::DashboardPanelPolicies"`.
+* Based on the `action_name` method on the controller, it builds a class name: `"index"` becomes `"Index"`, `"increase_inventory"` becomes `"IncreaseInventory"`.
+* By appending the class name to the module name, it tries to find that constant: with `controller_path == "orders"` and `action_name == "Index"`, it looks for a `OrdersPolicies::Index` constant.
+
+For more details about how the module and class names are converted, please check the [`ActiveSupport::Inflector#camelize`](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-camelize) method.
+
+#### Helper class
+
+If you don't want to write your own policy from the scratch, I've also provided a minimalistic base policy:
+
+```ruby
+module OrdersPolicies
+  class Create < KnowItAll::Base
+    assert :user_signed_in?, "User must be signed in" 
+    assert :address_present?, "User must have a registered address" 
+    assert :address_in_range?, "Registered address is outside the range" 
+    assert :cart_has_minimum?, "Cart must contain at least $10 in items" 
+    assert :items_available?, "Some of the items are not available" 
+    assert :store_open?, "The store is closed" 
+
+    def initialize(current_user, cart, store)
+      @current_user = current_user
+      @cart = cart
+      @store = store
+    end
+  end
+end
+```
+
+The class method `assert` expects a `Symbol` representing the name of a predicate and a `String` containing the error message in case the predicate fails. The default `errors` method returns an array containing the messages for all the assertions that didn't pass.
+
+### Using policies
+
+The simplest approach is to include the `KnowItAll` module in the controller you want to perform the validation. For this example, let's make the helpers available to all controllers by including it in the `ApplicationController`:
+
+```ruby
+class ApplicationController < ActionController::Base
+  include KnowItAll
+end
+```
+
+After that, we can use the helpers in any controller that inherits from `ApplicationController`:
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    authorize! current_user, cart, store
+
+    order = Order.create(order_params)
+    if order.save
+      render json: order, status: :created
+    else
+      render json: { errors: order.errors }, status: :unprocessable_entity
+    end
+  end
+end
+```
+
+#### What happens when not authorized
+
+The `authorize` method raises a `KnowItAll::NotAuthorized` exception in case the authorization has failed, and contains the instance of the policy used to perform the validation:
+
+```ruby
+class ApplicationController < ActionController::Base
+  include KnowItAll
+  rescue_from KnowItAll::NotAuthorized do |exception|
+    render json: { errors: exception.policy.errors }, status: :forbidden
+  end
+end
+```
+
+This pattern is so common that I've wrote a method that does exactly that:
+
+```ruby
+class ApplicationController < ActionController::Base
+  include KnowItAll
+  rescue_from KnowItAll::NotAuthorized, with: :render_not_authorized
+end
+```
+
+Alternatively, you can use the bangless form of the authorization method (`authorize`), which doesn't raise an exception and return an array of errors:
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    errors = authorize current_user, cart, store
+    if errors.empty?
+      order = Order.create(order_params)
+      if order.save
+        render json: order, status: :created
+      else
+        render json: { errors: order.errors }, status: :unprocessable_entity
+      end
+    else
+      return render json: { errors: errors }, status: :forbidden
+    end
+  end
+end
+```
+
+#### Querying authorizations in the view
+
+You can use the predicate `authorize?` to make decisions based on future authorizations in your views. First you need to make the method available as a helper:
+
+```ruby
+class ApplicationController < ActionController::Base
+  include KnowItAll
+  helper_method :authorize?
+end
+```
+
+Then use it in your views, passing the appropriate overrides (more about that here):
+
+```erb
+<%= form_for @order do |f| %>
+  <!-- Form fields -->
+
+  <%= f.button "Place order", disabled: authorize?(
+                                          @current_user,
+                                          @cart,
+                                          @store,
+                                          controller_path: "orders",
+                                          action_name: "create"
+                                        ) %>
+<% end %>
+```
+
+#### Avoiding conflicts in the controller
+
+It's possible that you're already using methods with the same names as the ones in the `KnowItAll` module: `authorize`, `authorized?`, `authorize!`, `policy`, `policy_class`, `policy_name`, `render_not_authorized` or `verify_authorized`. In that case, the solution is to include the module in another class, and use it as a collaborator. The only methods `KnowItAll` needs to find the correct policies are `controller_path` and `action_name`:
+
+```ruby
+class Authorizer
+  include KnowItAll
+  attr_reader :controller_path, :action_name
+
+  def initialize(controller)
+    @controller_path = controller.controller_path
+    @action_name = controller.action_name
+  end
+end
+
+class ApplicationController < ActionController::Base
+  protected
+
+    def authorizer
+      Authorizer.new(self)
+    end
+end
+
+class OrdersController < ApplicationController
+  def create
+    authorizer.authorize! current_user, cart, store
+
+    # Action's code here
+  end
+end
+```
+
+In that case, I've made available a `KnowItAll::Authorizer` class that does exactly that:
+
+```ruby
+class ApplicationController < ActionController::Base
+  protected
+
+    def authorizer
+      KnowItAll::Authorizer.new(self)
+    end
+end
+```
+
+#### Overrides
+
+It's possible to override any of the methods `KnowItAll` uses to define the appropriate policy. You can do that in the controller:
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    authorize! current_user, cart, store
+
+    # Action's code here
+  end
+
+  def policy_name
+    "OrdersPolicies::Checkout"
+  end
+end
+```
+
+Or when calling the `authorize`, `authorize?` or `authorize!` methods:
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    authorize! current_user, cart, store, policy_name: "OrdersPolicies::Checkout"
+
+    # Action's code here
+  end
+end
+```
+
+The available overrides are: `controller_path`, `action_name`, `policy_name`, `policy_class` and `policy` (instance of the policy).
+
+## Enforcing authorization checks
+
+While developing a simple feature, it's easy to forget to perform an authorization check. It's helpful during development to know when you forget it, so I've provided a `verify_authorized` method that raises a `KnowItAll::AuthorizationNotPerformedError` when there were no calls to any one of the authorization methods: `authorize`, `authorize?` or `authorize!`:
+
+```ruby
+class ApplicationController < ActionController::Base
+  include KnowItAll
+  after_action :verify_authorized
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. 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/[USERNAME]/know_it_all. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "know_it_all"
+
+# 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

data/bin/setup

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

data/know_it_all.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'know_it_all/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "know_it_all"
+  spec.version       = KnowItAll::VERSION
+  spec.authors       = ["mrodrigues"]
+  spec.email         = ["mrodrigues.uff@gmail.com"]
+
+  spec.summary       = %q{OO authorization for APIs}
+  spec.description   = %q{Minimalistic authorization focused on APIs}
+  spec.homepage      = "https://github.com/mrodrigues/know_it_all"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "pry"
+end

data/lib/know_it_all/authorizer.rb

@@ -0,0 +1,33 @@
+module KnowItAll
+  class Authorizer
+    include KnowItAll
+
+    def initialize(controller)
+      self.controller = controller
+    end
+
+    def controller_path
+      controller.controller_path
+    end
+
+    def action_name
+      controller.action_name
+    end
+
+    def policy(*args)
+      controller.respond_to?(:policy) && controller.policy(*args) || super
+    end
+
+    def policy_class(*args)
+      controller.respond_to?(:policy_class) && controller.policy_class(*args) || super
+    end
+
+    def policy_name(*args)
+      controller.respond_to?(:policy_name) && controller.policy_name(*args) || super
+    end
+
+    private
+
+      attr_accessor :controller
+  end
+end

data/lib/know_it_all/base.rb

@@ -0,0 +1,14 @@
+module KnowItAll
+  class Base
+    def self.assert(method_name, message)
+      @@validations ||= {}
+      @@validations[method_name] = message
+    end
+
+    def errors
+      @@validations.each
+        .select { |method_name, _| !self.send(method_name) }
+        .map { |_, message| message }
+    end
+  end
+end

data/lib/know_it_all/version.rb

@@ -0,0 +1,3 @@
+module KnowItAll
+  VERSION = "0.1.0"
+end

data/lib/know_it_all.rb

@@ -0,0 +1,67 @@
+require "know_it_all/version"
+require "know_it_all/base"
+require "know_it_all/authorizer"
+
+module KnowItAll
+  SUFFIX = "Policies"
+
+  def authorize?(*args)
+    authorize(*args).empty?
+  end
+
+  def authorize(*args,
+                 controller_path: self.controller_path,
+                 action_name: self.action_name,
+                 policy_name: self.policy_name(
+                   controller_path: controller_path,
+                   action_name: action_name
+                 ),
+                 policy_class: self.policy_class(policy_name: policy_name),
+                 policy: self.policy(*args, policy_class: policy_class)
+                )
+    @_authorization_performed = true
+    policy.errors
+  end
+
+  def authorize!(*args)
+    raise NotAuthorized.new(policy(*args)) unless authorize?(*args)
+  end
+
+  def policy(*args, policy_class: self.policy_class)
+    policy_class.new(*args)
+  end
+
+  def policy_class(policy_name: self.policy_name)
+    @policy_class ||= policy_name.constantize
+  end
+
+  def policy_name(
+    controller_path: self.controller_path,
+    action_name: self.action_name
+  )
+    "#{controller_path.to_s.camelize}#{SUFFIX}::#{action_name.to_s.camelize}"
+  end
+
+  def render_not_authorized(exception)
+    render(
+      json: {
+        errors: exception.policy.errors
+      },
+      status: :forbidden
+    )
+  end
+
+  def verify_authorized
+    raise AuthorizationNotPerformedError unless @_authorization_performed
+  end
+
+  class NotAuthorized < StandardError
+    attr_accessor :policy
+
+    def initialize(policy)
+      self.policy = policy
+    end
+  end
+
+  class AuthorizationNotPerformedError < StandardError; end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: know_it_all
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mrodrigues
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Minimalistic authorization focused on APIs
+email:
+- mrodrigues.uff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- know_it_all.gemspec
+- lib/know_it_all.rb
+- lib/know_it_all/authorizer.rb
+- lib/know_it_all/base.rb
+- lib/know_it_all/version.rb
+homepage: https://github.com/mrodrigues/know_it_all
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: OO authorization for APIs
+test_files: []