api_schema 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd078f116a2eae7922f15408fd29d233d1af4e8d
+  data.tar.gz: 622afbb13b567654a91a2915995a6f9eda3dfaa3
+SHA512:
+  metadata.gz: ba089ca4c00ec03ce5234b828212b3912bc43c65c643f7935ba39252127b964347574cf351cf76c1710e16614958c572be64f3272faf28959e95ff6e359dbb79
+  data.tar.gz: b286a9cca79d3f87661ca1a9550ec86faee2c6be18eb200ca523ae93803801f939add825e945e3859b83c747c229bbf4e4575525563da3a9f9abcbc0e7b07389

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.14.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+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, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at dmitry.chopey@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Dimitry Chopey
+
+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,287 @@
+# Api Schema
+Provides a framework and DSL for describing APIs and generate swagger-json using minimalist, schema.db-like syntax.
+
+<p align="center">
+    <a href="#installation">Installation</a> | <a href="#usage">Usage</a> | <a href="#license">License</a>
+</p>
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'api_schema'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install api_schema
+
+## Usage
+
+Just add `include ApiSchema` and configurations to your base class and inherit from it.
+
+#### BaseDocs
+
+```ruby
+module V1
+  class BaseDocs
+    include ApiSchema
+
+    configure do |config|
+      config.title = 'Users API'
+      config.description = 'API for users'
+      config.version = '1.0'
+      config.host = 'sample.com'
+      config.base_path = '/api'
+      config.terms_of_service = 'https://sample.com/terms'
+      config.contact_name = 'API Team'
+      config.consumes = 'application/json'
+      config.produces = 'application/json'
+      config.authorization = true
+      config.error_model = :error_model
+      config.error_desc = {
+        '401' => "Unauthorized",
+        '403' => "Forbidden",
+        '404' => "Not found",
+        '422' => "Unprocessable Entity"
+      }
+    end
+  end
+end
+```
+
+#### UsersController
+
+```ruby
+module V1
+  module ControllersDocs
+    class UsersController < BaseDocs
+
+      get do
+        path_param :id, :integer
+        name 'Get User'
+        desc 'Returns user with provided id'
+        response 200, :user
+        error! 401, 403, 404, 422
+      end
+    end
+  end
+```
+
+#### UserSerializer
+
+```ruby
+module V1
+  module SerializersDocs
+    class UserSerializer < BaseDocs
+
+      serializer :user do |f|
+        f.integer  :id, required: true
+        f.string   :email, required: true
+        f.string   :name
+      end
+    end
+  end
+```
+
+### Serializers
+
+To describe serializers you can use `serializer` and `array_serializer` methods.
+
+**Here `:user` and `:users` are unique identifiers**
+
+For **member** responses:
+
+```ruby
+serializer :user do |f|
+  f.integer  :id, required: true
+  f.string   :email, required: true
+  f.string   :name
+end
+```
+
+Will have such a structure:
+
+```json
+{
+  "user": {
+    "id": 1,
+    "email": "john.doe.gmail.com",
+    "name": "John Doe"
+  }
+}
+```
+
+For **collection** responses:
+
+```ruby
+array_serializer :users do |f|
+  f.reference :meta
+  f.reference :user, type: :array
+end
+```
+
+Will have such a structure:
+
+```json
+{
+  "meta": {...},
+  "users": [
+    {
+      "id": 1,
+      "email": "john.doe.gmail.com",
+      "name": "John Doe"
+    },
+    {...}]
+}
+```
+
+Then you can use this descriptions in the controllers with identifiers:
+
+```ruby
+response 200, :user
+```
+
+```ruby
+response 200, :users
+```
+
+#### References
+
+To user nested descriptions, you can use `reference` method:
+
+```ruby
+serializer :file do |f|
+  f.integer :file_name, required: true
+  f.string  :file_url, required: true
+end
+```
+
+```ruby
+serializer :attachment do |f|
+  f.integer   :id, required: true
+  f.reference :file
+end
+```
+
+#### Parents
+
+To inherit fields from another serializer, you can use `parent` parameter:
+
+```ruby
+serializer :file do |f|
+  f.integer   :file_name, required: true
+  f.string    :file_url, required: true
+end
+```
+
+```ruby
+serializer :attachment, parent: :file do |f|
+  f.integer   :id, required: true
+end
+```
+
+### Controllers
+
+#### Endpoints
+
+To describe endpoints you can use `get`, `post`, `put`, `patch` methods.
+
+Get **collection**:
+
+```ruby
+get do
+  query_param :query, :string
+  query_param :sort_by, :string
+  name 'List Users'
+  desc "Returns list of the users"
+  response 200, :users
+  error! 401, 403, 422
+end
+```
+
+Will produce `/users` endpoint.
+
+To get **member** you should use `path_param` method:
+
+```ruby
+get do
+  path_param :id, :integer
+  name 'Get User'
+  desc 'Returns user with provided id'
+  response 200, :user
+  error! 401, 403, 422
+end
+```
+
+Will produce `/users/{id}` endpoint.
+
+By default gem uses controller's name to generate endpoints, but you can make custom by passing first argument:
+
+```ruby
+get 'people' do
+  path_param :id, :integer
+  name 'Get User'
+  desc 'Returns user with provided id'
+  response 200, :user
+  error! 401, 403, 422
+end
+```
+
+Will produce `/people/{id}` endpoint.
+
+Use `extra_path` argument to add extra path to the endpoint
+
+```ruby
+get extra_path: :read do
+  path_param :id, :integer
+  name 'Read Notification'
+  desc 'Reads notification with provided id'
+  response 200
+  error! 401, 403, 422
+end
+```
+
+Will produce `/notification/{id}/read` endpoint.
+
+#### Parameters
+
+To describe each endpoint you can use `header`, `body`, `path_param`, `query_param`
+
+`header` and `body`:
+
+```ruby
+post do
+  header :token, :string
+  body :create_user
+  name 'Create User'
+  desc 'Creates and returns new user'
+  response 200, :user
+  error! 401, 403, 422
+end
+```
+
+To describe body of the request you can use `request_body` method. It's just an alias for serializer:
+
+```ruby
+request_body :create_user do |f|
+  f.string   :email, required: true
+  f.string    :first_name, required: true
+  f.string    :last_name, required: true
+end
+```
+
+## Dependencies
+
+- [Active Support](https://github.com/rails/rails/tree/master/activesupport)
+- [Swagger::Blocks](https://github.com/fotinakis/swagger-blocks)
+
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/api_schema.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'api_schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "api_schema"
+  spec.version       = ApiSchema::VERSION
+  spec.authors       = ["Dmitry Chopey"]
+  spec.email         = ["dmitry.chopey@gmail.com"]
+
+  spec.summary       = %q{api_schema provides a framework and DSL for describing APIs
+                          and generate swagger json.}
+  spec.description   = %q{api_schema provides a framework and DSL for describing APIs
+                          and generate swagger json using minimalist, schema.db-like syntax.}
+  spec.homepage      = "https://github.com/qonto/api_schema."
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "swagger-blocks", "~> 2.0"
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/bin/console

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

data/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

data/lib/api_schema/api_version.rb

@@ -0,0 +1,11 @@
+module ApiSchema
+  class ApiVersion
+    attr_accessor :configuration, :resources, :serializers
+
+    def initialize(configuration)
+      @configuration = configuration
+      @resources = []
+      @serializers = []
+    end
+  end
+end

data/lib/api_schema/configuration.rb

@@ -0,0 +1,41 @@
+module ApiSchema
+  class Configuration
+    include ::Swagger::Blocks::ClassMethods
+
+    attr_accessor :title, :description, :version, :host,
+    :base_path, :terms_of_service, :contact_name,
+    :consumes, :produces, :authorization,
+    :error_model, :error_desc
+
+    def initialize
+      @error_model = 'error_model'
+      @consumes = 'application/json'
+      @produces = 'application/json'
+    end
+
+    def build
+      configuration = self
+      swagger_root do
+        key :swagger, '2.0'
+        info do
+          key :version, configuration.version
+          key :title, configuration.title
+          key :description, configuration.description
+          key :termsOfService, configuration.terms_of_service
+          contact do
+            key :name, configuration.contact_name
+          end
+        end
+        security_definition :authorization do
+          key :name, :Authorization
+          key :type, :apiKey
+          key :in, :header
+        end if configuration.authorization
+        key :host, configuration.host
+        key :basePath, configuration.base_path
+        key :consumes, configuration.consumes
+        key :produces, configuration.produces
+      end
+    end
+  end
+end

data/lib/api_schema/field.rb

@@ -0,0 +1,18 @@
+module ApiSchema
+  class Field
+
+    attr_accessor :type, :name, :format, :required, :description
+
+    def initialize(type, name, options = {})
+      @type = type
+      @name = name
+      @format = options.fetch(:format, nil)
+      @required = options.fetch(:required, false)
+      @description = options.fetch(:desc, '')
+    end
+
+    def required?
+      required
+    end
+  end
+end

data/lib/api_schema/patches/operation_node.rb

@@ -0,0 +1,69 @@
+module Swagger
+  module Blocks
+    module Nodes
+      class OperationNode < Node
+        def success_response(code, model_name = nil, fields = [])
+          response code do
+            schema do
+              key :'$ref', model_name if model_name
+              fields.each do |f|
+                property f.name do
+                  key :type, f.type
+                end
+              end
+            end
+          end
+        end
+
+        def header_param(name, type)
+          parameter do
+            key :name, name
+            key :in, :header
+            key :required, true
+            key :type, type
+          end
+        end
+
+        def body_param(model_name)
+          parameter do
+            key :name, model_name
+            key :in, :body
+            key :required, true
+            schema do
+              key :'$ref', model_name
+            end
+          end
+        end
+
+        def query_param(name, type)
+          parameter do
+            key :name, name
+            key :in, :query
+            key :required, true
+            key :type, type
+          end
+        end
+
+        def path_param(name, type)
+          parameter do
+            key :name, name
+            key :in, :path
+            key :required, true
+            key :type, type
+          end
+        end
+
+        def error_responses(model_name, descriptions, *codes)
+          codes.each do |code|
+            response code do
+              key :description, descriptions[code]
+              schema do
+                key :'$ref', model_name
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/api_schema/patches/property_node.rb

@@ -0,0 +1,29 @@
+module Swagger
+  module Blocks
+    module Nodes
+      class PropertyNode < Node
+        def requires(fields)
+          key :required, fields
+        end
+
+        def property_schema_for(serializer)
+          property serializer.name do
+            key :type, serializer.type
+            key :description, serializer.description
+            requires serializer.required_fields
+            serializer.fields.each do |f|
+              property f.name do
+                key :type, f.type
+                key :format, f.format if f.format
+                key :description, f.description
+              end
+            end
+            serializer.references.each do |r|
+              property_schema_for(r)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/api_schema/patches/schema_node.rb

@@ -0,0 +1,66 @@
+module Swagger
+  module Blocks
+    module Nodes
+      class SchemaNode < Node
+        def requires(fields)
+          key :required, fields
+        end
+
+        def schema_for(serializer)
+          key :title, serializer.id.to_s.humanize
+          serializer.type == :array ? array_schema(serializer) : single_schema(serializer)
+        end
+
+        def single_schema(serializer)
+          key :required, serializer.name
+          property serializer.name do
+            key :type, :object
+            requires serializer.required_fields
+            serializer.fields.each do |f|
+              property f.name do
+                key :type, f.type
+                key :format, f.format if f.format
+                key :description, f.description
+              end
+            end
+            serializer.references.each do |r|
+              property_schema_for(r) #schema_for from PropertyNode class
+            end
+          end
+        end
+
+        def array_schema(serializer)
+          requires serializer.required_fields
+          serializer.fields.each do |f|
+            property f.name do
+              key :type, f.type
+              key :format, f.format if f.format
+              key :description, f.description
+            end
+          end
+          serializer.references.each do |r|
+            property_schema_for(r)
+          end
+        end
+
+        def property_schema_for(serializer)
+          property serializer.name do
+            key :type, serializer.type
+            key :description, serializer.description
+            requires serializer.required_fields
+            serializer.fields.each do |f|
+              property f.name do
+                key :type, f.type
+                key :format, f.format if f.format
+                key :description, f.description
+              end
+            end
+            serializer.references.each do |r|
+              property_schema_for(r)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/api_schema/resource_definition.rb

@@ -0,0 +1,121 @@
+module ApiSchema
+  class ResourceDefinition
+    include ::Swagger::Blocks::ClassMethods
+
+    @@neighbors = {}
+
+    def initialize(method, base_path, extra_path = nil)
+      @base_path = base_path
+      @extra_path = extra_path
+      @method = method
+      @header_params = []
+      @path_params = []
+      @query_params = []
+    end
+
+    HeaderParam = ::Struct.new(:name, :type)
+    PathParam = ::Struct.new(:name, :type)
+    QueryParam = ::Struct.new(:name, :type)
+
+    attr_reader :method, :summary, :description, :header_params, :body_param,
+    :path_params, :query_params, :resp,
+    :errors, :base_path, :extra_path, :full_path
+
+    def name(name)
+      @summary = name
+    end
+
+    def desc(desc)
+      @description = desc
+    end
+
+    def header(name, type)
+      @header_params << HeaderParam.new(name, type)
+    end
+
+    def body(body_param)
+      @body_param = body_param
+    end
+
+    def path_param(name, type)
+      @path_params << PathParam.new(name, type)
+    end
+
+    def query_param(name, type)
+      @query_params << QueryParam.new(name, type)
+    end
+
+    def response(code, model_name = nil, &block)
+      @resp = Response.new(code, model_name)
+      if block && model_name.nil?
+        block.call(@resp)
+      end
+    end
+
+    def error!(*codes)
+      @errors = *codes
+    end
+
+    def with_path_param?
+      !path_params.empty?
+    end
+
+    def with_body?
+      !!body_param
+    end
+
+    def with_errors?
+      !errors.empty?
+    end
+
+    def generate_full_path
+      @full_path = with_path_param? ? "/#{base_path}/{id}" : "/#{base_path}"
+      @full_path << "/#{extra_path}" if extra_path
+    end
+
+    def build_neighbors
+      generate_full_path
+      @@neighbors[full_path] ||= []
+      @@neighbors[full_path] << self
+    end
+
+    def build
+      error_model = :error_model
+      error_desc = {
+        '401' => "Unauthorized",
+        '403' => "Forbidden",
+        '404' => "Not found",
+        '422' => "Unprocessable Entity"
+     }
+      resource = self
+
+      swagger_path resource.full_path do
+        @@neighbors[resource.full_path].each do |r|
+          operation(r.method) do
+            key :summary, r.summary
+            key :description, r.description
+            key :operationId, "#{r.method}_#{r.full_path}"
+            key :tags, r.base_path
+            security do
+              key :authorization, []
+            end
+            body_param(r.body_param) if r.with_body?
+
+            r.header_params.each do |p|
+              header_param(p.name, p.type)
+            end
+            r.path_params.each do |p|
+              path_param(p.name, p.type)
+            end
+            r.query_params.each do |p|
+              query_param(p.name, p.type)
+            end
+
+            success_response(r.resp.code, r.resp.model, r.resp.fields)
+            error_responses(error_model, error_desc, *r.errors) if r.with_errors?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/api_schema/resource_methods.rb

@@ -0,0 +1,45 @@
+module ApiSchema
+  module ResourceMethods
+
+    private
+
+    def get(base_path = default_path, extra_path: nil, &block)
+      resource = ResourceDefinition.new(:get, base_path, extra_path)
+      resource.instance_eval(&block)
+      api_version.resources << resource
+      resource.build_neighbors
+    end
+
+    def post(base_path = default_path, extra_path: nil, &block)
+      resource = ResourceDefinition.new(:post, base_path, extra_path)
+      resource.instance_eval(&block)
+      api_version.resources << resource
+      resource.build_neighbors
+    end
+
+    def put(base_path = default_path, extra_path: nil, &block)
+      resource = ResourceDefinition.new(:put, base_path, extra_path)
+      resource.instance_eval(&block)
+      api_version.resources << resource
+      resource.build_neighbors
+    end
+
+    def patch(base_path = default_path, extra_path: nil, &block)
+      resource = ResourceDefinition.new(:patch, base_path, extra_path)
+      resource.instance_eval(&block)
+      api_version.resources << resource
+      resource.build_neighbors
+    end
+
+    def delete(base_path = default_path, extra_path: nil, &block)
+      resource = ResourceDefinition.new(:delete, base_path, extra_path)
+      resource.instance_eval(&block)
+      api_version.resources << resource
+      resource.build_neighbors
+    end
+
+    def default_path
+      self.to_s.split("::").last.gsub("Controller", "").split(/(?=[A-Z])/).map(&:downcase).join('_')
+    end
+  end
+end

data/lib/api_schema/response.rb

@@ -0,0 +1,17 @@
+module ApiSchema
+  class Response
+
+    attr_reader :code, :model, :fields
+
+    def initialize(code, model)
+      @code = code
+      @model = model
+      @fields = []
+    end
+
+    def method_missing(type, *args, &block)
+      options = args[1] || {}
+      @fields << Field.new(type, args[0], options)
+    end
+  end
+end

data/lib/api_schema/root_methods.rb

@@ -0,0 +1,22 @@
+module ApiSchema
+  module RootMethods
+    def configure
+      configuration ||= Configuration.new
+      yield(configuration)
+      @@api_version = ApiVersion.new(configuration)
+    end
+
+    def api_version
+      @@api_version
+    end
+
+    def generate_json
+      @@api_version.configuration.build
+      @@api_version.serializers.each { |s| s.build }
+      @@api_version.resources.each { |r| r.build }
+
+      nodes = [@@api_version.configuration] +  @@api_version.serializers + @@api_version.resources
+      ::Swagger::Blocks.build_root_json(nodes)
+    end
+  end
+end

data/lib/api_schema/serializer_definition.rb

@@ -0,0 +1,52 @@
+module ApiSchema
+  class SerializerDefinition
+    include ::Swagger::Blocks::ClassMethods
+
+    @@serializers = {}
+
+    PriorReference = ::Struct.new(:id, :type, :desc)
+
+    attr_reader :id, :fields, :references, :parent
+    attr_accessor :type, :name, :description
+
+    def initialize(id, type, name=nil, parent_id = nil)
+      @id = id
+      @type = type
+      @name = name || id
+      @parent = @@serializers[parent_id]
+      @fields = parent&.fields || []
+      @prior_references = parent&.prior_references || []
+      @references = []
+      @@serializers[id] = self
+    end
+
+    def required_fields
+      fields.select { |f| f.required? }.map(&:name) + references.map(&:name)
+    end
+
+    def reference(refernce_id, type: :object, desc: nil)
+      @prior_references << PriorReference.new(refernce_id, type, desc)
+    end
+
+    def build
+      build_references
+      sd = self
+      swagger_schema(id) { schema_for(sd) }
+    end
+
+    def build_references
+      @prior_references.each do |pr|
+        reference = @@serializers[pr.id].clone
+        reference.type = pr.type
+        reference.description = pr.desc
+        reference.name = reference.name.to_s.pluralize if reference.type == :array
+        @references << reference
+      end
+    end
+
+    def method_missing(type, *args, &block)
+      options = args[1] || {}
+      @fields << Field.new(type, args[0], options)
+    end
+  end
+end

data/lib/api_schema/serializer_methods.rb

@@ -0,0 +1,20 @@
+module ApiSchema
+  module SerializerMethods
+
+    private
+
+    def serializer(id, structure: :object, name: nil, parent: nil)
+      serializer = SerializerDefinition.new(id, structure, name, parent)
+      yield serializer if block_given?
+      api_version.serializers << serializer
+    end
+
+    def array_serializer(id, name: nil, parent: nil)
+      serializer = SerializerDefinition.new(id, :array, name, parent)
+      yield serializer if block_given?
+      api_version.serializers << serializer
+    end
+
+    alias_method :request_body, :serializer
+  end
+end

data/lib/api_schema/version.rb

@@ -0,0 +1,3 @@
+module ApiSchema
+  VERSION = "0.1.1"
+end

data/lib/api_schema.rb

@@ -0,0 +1,26 @@
+require 'active_support/inflector'
+require 'swagger/blocks'
+
+require 'api_schema/patches/operation_node'
+require 'api_schema/patches/property_node'
+require 'api_schema/patches/schema_node'
+
+require "api_schema/configuration"
+require "api_schema/api_version"
+require "api_schema/root_methods"
+require "api_schema/field"
+require "api_schema/response"
+require "api_schema/serializer_definition"
+require "api_schema/serializer_methods"
+require "api_schema/resource_definition"
+require "api_schema/resource_methods"
+require "api_schema/version"
+
+module ApiSchema
+
+  def self.included(base)
+    base.extend(RootMethods)
+    base.extend(SerializerMethods)
+    base.extend(ResourceMethods)
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: api_schema
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Dmitry Chopey
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-05-02 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: swagger-blocks
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |-
+  api_schema provides a framework and DSL for describing APIs
+                            and generate swagger json using minimalist, schema.db-like syntax.
+email:
+- dmitry.chopey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- api_schema.gemspec
+- bin/console
+- bin/setup
+- lib/api_schema.rb
+- lib/api_schema/api_version.rb
+- lib/api_schema/configuration.rb
+- lib/api_schema/field.rb
+- lib/api_schema/patches/operation_node.rb
+- lib/api_schema/patches/property_node.rb
+- lib/api_schema/patches/schema_node.rb
+- lib/api_schema/resource_definition.rb
+- lib/api_schema/resource_methods.rb
+- lib/api_schema/response.rb
+- lib/api_schema/root_methods.rb
+- lib/api_schema/serializer_definition.rb
+- lib/api_schema/serializer_methods.rb
+- lib/api_schema/version.rb
+homepage: https://github.com/qonto/api_schema.
+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.6.8
+signing_key: 
+specification_version: 4
+summary: api_schema provides a framework and DSL for describing APIs and generate
+  swagger json.
+test_files: []