tomograph 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3228f341aa3435287604e817404f80f26eec5b71
-  data.tar.gz: c6db2eb21936aa5523e1c3506cb1fca18d795a70
+  metadata.gz: ee14aba11b9ba06a3a83fbe84055570c888cb013
+  data.tar.gz: 0f364c057b8f2569deb21397db74cbb13eb3fe0e
 SHA512:
-  metadata.gz: c82ba6aa0a2137a3f63884f327cdca1ae0f731f455bb8b888f5e99afeddb3d17702144880e1b90d322043e13d81543578aa9f72afa15c6fc3407524e5bf106da
-  data.tar.gz: a815f9f5c0e800e20929dbf9c83734e1bdb743754dcd08ffeb61813517c174ef431cbc9c238a38863599ee0d288887720dbf324b2f5de335afeb997da4d8d7cf
+  metadata.gz: 18d05e492cca9fa7de92a32b564f926842457a1351125beb293d078f8e3d3022503cb8194ef0b0f2b3f6ea4381722871e70cee9fe3eab149b2c031f90157969b
+  data.tar.gz: 36cb8b49d448f23c08c814c0a0a2bd83a2c84f5c4a347892b543622bcc71563bcea4c364015c87f275f624bc259161e981554c69e8faf0a63a2abfa86c1dd933

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.2
 
 Metrics/LineLength:
   Max: 120
@@ -9,3 +9,6 @@ Style/Documentation:
 
 Style/FrozenStringLiteralComment:
   Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false

data/README.md

@@ -1,40 +1,194 @@
 # tomograph
 
-This is make API Tomogram
+Convert API Blueprint to JSON Schema and search.
 
-## Install
+## Installation
 
-config/application.rb
+Add this line to your application's Gemfile:
 
+```ruby
+gem 'tomograph'
 ```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tomograph
+
+## Usage
+
+```ruby
 require 'tomograph'
 ```
 
-## Config
+```ruby
+tomogram = Tomograph::Tomogram.new(apib_path: '/path/to/doc.apib')
+```
+
+## Convert
+
+```ruby
+tomogram.to_json
+```
+
+Example input:
+```
+FORMAT: 1A
+HOST: http://test.local
+
+# project
+
+# Group project
+
+Project
+
+## Authentication [/sessions]
+
+### Sign In [POST]
+
++ Request (application/json)
+
+    + Attributes
+     + login (string, required)
+     + password (string, required)
+     + captcha (string, optional)
+
++ Response 401 (application/json)
+
++ Response 429 (application/json)
+
++ Response 201 (application/json)
+
+    + Attributes
+     + confirmation (Confirmation, optional)
+     + captcha (string, optional)
+     + captcha_does_not_match (boolean, optional)
+
+
+# Data Structures
+
+## Confirmation (object)
+  + id (string, required)
+  + type (string, required)
+  + operation (string, required)
+```
+
+Example output:
+```
+[
+  {
+    "path": "/sessions",
+    "method": "POST",
+    "request": {
+      "$schema": "http://json-schema.org/draft-04/schema#",
+      "type": "object",
+      "properties": {
+        "login": {
+          "type": "string"
+        },
+        "password": {
+          "type": "string"
+        },
+        "captcha": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "login",
+        "password"
+      ]
+    },
+    "responses": [
+      {
+        "status": "401",
+        "body": {}
+      },
+      {
+        "status": "429",
+        "body": {}
+      },
+      {
+        "status": "201",
+        "body": {
+          "$schema": "http://json-schema.org/draft-04/schema#",
+          "type": "object",
+          "properties": {
+            "confirmation": {
+              "type": "object",
+              "properties": {
+                "id": {
+                  "type": "string"
+                },
+                "type": {
+                  "type": "string"
+                },
+                "operation": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "id",
+                "type",
+                "operation"
+              ]
+            },
+            "captcha": {
+              "type": "string"
+            },
+            "captcha_does_not_match": {
+              "type": "boolean"
+            }
+          }
+        }
+      }
+    ]
+  }
+]
+```
+
+## Search
 
-### documentation
+### find_request
 
-For gem needed by a ```drafter``` generate and save ```yaml``` file, and then turn it on config.
+```ruby
+request = tomogram.find_request(method: 'GET', path: '/status/1?qwe=rty')
 ```
-drafter doc/api.apib -o doc/api.yaml
+
+### find_responses
+
+
+```ruby
+responses = request.find_responses(status: '200')
 ```
 
+## Params
+
+Example:
+
 ```ruby
-Tomograph.configure do |config|
-  config.documentation = 'doc/api.yaml'
-end
+Tomograph::Tomogram.new(prefix: '/api/v2', apib_path: '/path/to/doc.apib')
 ```
 
-Then you can use the API tomogram by using the following call:
+or
 
 ```ruby
-Tomograph::Tomogram.json
+Tomograph::Tomogram.new(prefix: '/api/v2', drafter_yaml_path: '/path/to/doc.yaml')
 ```
 
-API tomogram return to json format.
+### apib_path
+
+Path to API Blueprint documentation. There must be an installed [drafter](https://github.com/apiaryio/drafter) to parse it.
+
+### drafter_yaml_path
+
+Path to API Blueprint documentation pre-parsed with `drafter` and saved to a YAML file.
 
 ### prefix
-Default empty String. This is prefix for url if in docimentation URI short .
+
+Default empty String. Prefix of API requests. Example: `'/api'`.
 
 ## License
 

data/lib/tomograph.rb

@@ -1,14 +1,4 @@
 require 'tomograph/tomogram'
-require 'tomograph/configuration'
 
 module Tomograph
-  class << self
-    def configure
-      yield configuration
-    end
-
-    def configuration
-      @configuration ||= Configuration.new
-    end
-  end
 end

data/lib/tomograph/api_blueprint/yaml.rb

@@ -0,0 +1,87 @@
+require 'tomograph/api_blueprint/yaml/action'
+require 'tomograph/tomogram/action'
+
+module Tomograph
+  module ApiBlueprint
+    class Yaml
+      def initialize(prefix, apib_path, drafter_yaml_path)
+        @prefix = prefix
+        @documentation = if apib_path
+                           YAML.safe_load(`drafter #{apib_path}`)
+                         else
+                           YAML.safe_load(File.read("#{Rails.root}/#{drafter_yaml_path}"))
+                         end
+      end
+
+      def groups
+        @groups ||= @documentation['content'][0]['content'].inject([]) do |result_groups, group|
+          next result_groups unless group?(group)
+          result_groups.push(group)
+        end
+      end
+
+      def group?(group)
+        group['element'] != 'copy' && # Element is a human readable text
+          group['meta']['classes'][0] == 'resourceGroup' # skip Data Structures
+      end
+
+      def resources
+        @resources ||= groups.inject([]) do |result_groups, group|
+          result_groups.push(group['content'].inject([]) do |result_resources, resource|
+            next result_resources unless resource?(resource)
+            result_resources.push('resource' => resource, 'resource_path' => resource_path(resource))
+          end)
+        end.flatten
+      end
+
+      def resource?(resource)
+        resource['element'] != 'copy' # Element is a human readable text
+      end
+
+      def resource_path(resource)
+        resource['attributes'] && resource['attributes']['href']
+      end
+
+      def transitions
+        @transitions ||= resources.inject([]) do |result_resources, resource|
+          result_resources.push(resource['resource']['content'].inject([]) do |result_transitions, transition|
+            next result_transitions unless transition?(transition)
+            result_transitions.push('transition' => transition,
+                                    'transition_path' => transition_path(transition, resource['resource_path']))
+          end)
+        end.flatten
+      end
+
+      def transition?(transition)
+        transition['element'] == 'transition'
+      end
+
+      def transition_path(transition, resource_path)
+        transition['attributes'] && transition['attributes']['href'] || resource_path
+      end
+
+      def actions
+        @actions ||= transitions.inject([]) do |result_transition, transition|
+          result_transition.push(transition['transition']['content'].inject([]) do |result_contents, content|
+            next result_contents unless action?(content)
+            result_contents.push(Tomograph::ApiBlueprint::Yaml::Action.new(
+                                   content['content'], transition['transition_path']
+            ))
+          end)
+        end.flatten
+      end
+
+      def action?(content)
+        content['element'] == 'httpTransaction'
+      end
+
+      def to_tomogram
+        @tomogram ||= Tomograph::Tomogram::Action.merge(
+          actions.inject([]) do |result, action|
+            result.push(action.to_tomogram.add_prefix(@prefix))
+          end
+        )
+      end
+    end
+  end
+end

data/lib/tomograph/api_blueprint/yaml/action.rb

@@ -0,0 +1,59 @@
+require 'tomograph/tomogram/action'
+
+module Tomograph
+  module ApiBlueprint
+    class Yaml
+      class Action
+        def initialize(content, path)
+          @content = content
+          @path = path
+        end
+
+        attr_reader :path
+
+        def method
+          @method ||= @content.first['attributes']['method']
+        end
+
+        def request
+          return @request if @request
+
+          request_action = @content.find { |el| el['element'] == 'httpRequest' }
+          @request = json_schema(request_action['content'])
+        end
+
+        def json_schema(actions)
+          schema_node = actions.find do |action|
+            action && action['element'] == 'asset' && action['attributes']['contentType'] == 'application/schema+json'
+          end
+          return {} unless schema_node
+
+          MultiJson.load(schema_node['content'])
+        rescue MultiJson::ParseError => e
+          puts "[Tomograph] Error while parsing #{e}. skipping..."
+          {}
+        end
+
+        def responses
+          return @responses if @responses
+
+          @responses = @content.select do |response|
+            response['element'] == 'httpResponse' && response['attributes']
+          end
+          @responses = @responses.map do |response|
+            {
+              'status' => response['attributes']['statusCode'],
+              'body' => json_schema(response['content'])
+            }
+          end
+        end
+
+        def to_tomogram
+          Tomograph::Tomogram::Action.new(
+            path: path, method: method, request: request, responses: responses
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tomograph/path.rb

@@ -0,0 +1,53 @@
+module Tomograph
+  class Path
+    def initialize(path)
+      unless path && !path.empty?
+        @path = ''
+        return
+      end
+      @path = path
+      @path = delete_till_the_end('{&')
+      @path = delete_till_the_end('{?')
+      @path = cut_off_query_params
+      @path = remove_the_slash_at_the_end
+    end
+
+    def match(find_path)
+      regexp =~ find_path
+    end
+
+    def regexp
+      return @regexp if @regexp
+
+      str = Regexp.escape(to_s)
+      str = str.gsub(/\\{\w+\\}/, '[^&=\/]+')
+      str = "\\A#{str}\\z"
+      @regexp = Regexp.new(str)
+    end
+
+    def to_s
+      @path
+    end
+
+    private
+
+    def delete_till_the_end(beginning_with)
+      path_index = @path.index(beginning_with)
+      path_index ||= 0
+      path_index -= 1
+      @path.slice(0..path_index)
+    end
+
+    def remove_the_slash_at_the_end
+      if @path[-1] == '/'
+        @path[0..-2]
+      else
+        @path
+      end
+    end
+
+    def cut_off_query_params
+      @path.gsub(/\?.*\z/, '')
+    end
+  end
+end

data/lib/tomograph/tomogram.rb

@@ -1,139 +1,27 @@
 require 'multi_json'
+require 'tomograph/path'
+require 'tomograph/api_blueprint/yaml'
 
 module Tomograph
-  class Tomogram < String
-    class << self
-      def json
-        single_sharps = find_resource
-
-        result = []
-        single_sharps.map do |single_sharp|
-          result += single_sharp['content'].inject([]) do |result, resource|
-            next result if text_node?(resource)
-
-            result.concat(extract_actions(resource))
-          end
-        end
-        MultiJson.dump(result)
-      end
-
-      def delete_query_and_last_slash(path)
-        path = delete_till_the_end(path, '{&')
-        path = delete_till_the_end(path, '{?')
-
-        remove_the_slash_at_the_end(path)
-      end
-
-      private
-
-      def extract_actions(resource)
-        actions = []
-        resource_path = resource['attributes'] && resource['attributes']['href']
-
-        transitions = resource['content']
-        transitions.each do |transition|
-          next unless transition['element'] == 'transition'
-
-          path = transition['attributes'] && transition['attributes']['href'] || resource_path
-
-          transition['content'].each do |content|
-            next unless content['element'] == 'httpTransaction'
-
-            action = build_action(content, path)
-            actions << action if action
-          end
-        end
-
-        actions.group_by { |action| action['method'] + action['path'] }.map do |_key, resource_actions|
-          # because in yaml a response has a copy of the same request we can only use the first
-          {
-            'path' => resource_actions.first['path'],
-            'method' => resource_actions.first['method'],
-            'request' => resource_actions.first['request'],
-            'responses' => resource_actions.flat_map { |action| action['responses'] }.compact
-          }
-        end
-      end
-
-      def find_resource
-        documentation['content'][0]['content'].find_all do |resource|
-          !text_node?(resource) &&
-            resource['meta']['classes'][0] == 'resourceGroup' # skip Data Structures
-        end
-      end
-
-      def documentation
-        if Tomograph.configuration.drafter_yaml
-          YAML.load(Tomograph.configuration.drafter_yaml)
-        else
-          YAML.load(File.read("#{Rails.root}/#{Tomograph.configuration.documentation}"))
-        end
-      end
-
-      def delete_till_the_end(path, beginning_with)
-        path_index = path.index(beginning_with)
-        path_index ||= 0
-        path_index -= 1
-        path.slice(0..path_index)
-      end
-
-      def remove_the_slash_at_the_end(path)
-        if path[-1] == '/'
-          path[0..-2]
-        else
-          path
-        end
-      end
-
-      def build_action(content, path)
-        return if text_node?(content)
-
-        action_to_hash(content['content'], path)
-      end
-
-      def action_to_hash(actions, path)
-        {
-          'path' => "#{Tomograph.configuration.prefix}#{delete_query_and_last_slash(path)}",
-          'method' => actions.first['attributes']['method'],
-          'request' => request(actions),
-          'responses' => responses(actions)
-        }
-      end
-
-      def request(actions)
-        request_action = actions.find {|el| el['element'] === 'httpRequest' }
-        json_schema(request_action['content'])
-      end
-
-      def json_schema?(action)
-        action && action['element'] == 'asset' && action['attributes']['contentType'] == 'application/schema+json'
-      end
-
-      def responses(actions)
-        response_actions = actions.select {|el| el['element'] === 'httpResponse' }
-
-        response_actions.map do |response|
-          return unless response['attributes'] # if no response
+  class Tomogram
+    def initialize(prefix: '', apib_path: nil, drafter_yaml_path: nil)
+      @documentation = Tomograph::ApiBlueprint::Yaml.new(prefix, apib_path, drafter_yaml_path)
+      @prefix = prefix
+    end
 
-          {
-            'status' => response['attributes']['statusCode'],
-            'body' => json_schema(response['content'])
-          }
-        end.compact
-      end
+    def to_hash
+      @documentation.to_tomogram.map(&:to_hash)
+    end
 
-      def json_schema(actions)
-        schema_node = actions.find {|action| json_schema?(action) }
-        return {} unless schema_node
+    def to_json
+      MultiJson.dump(to_hash)
+    end
 
-        MultiJson.load(schema_node['content'])
-      rescue MultiJson::ParseError => e
-        puts "[Tomograph] Error while parsing #{ e }. skipping..."
-        {}
-      end
+    def find_request(method:, path:)
+      path = Tomograph::Path.new(path).to_s
 
-      def text_node?(node)
-        node['element'] == 'copy' # Element is a human readable text
+      @documentation.to_tomogram.find do |action|
+        action.method == method && action.path.match(path)
       end
     end
   end

data/lib/tomograph/tomogram/action.rb

@@ -0,0 +1,47 @@
+require 'tomograph/path'
+
+module Tomograph
+  class Tomogram
+    class Action
+      attr_reader :path, :method, :request, :responses
+
+      def initialize(path:, method:, request:, responses:)
+        @path ||= Tomograph::Path.new(path)
+        @method ||= method
+        @request ||= request
+        @responses ||= responses
+      end
+
+      def self.merge(actions)
+        actions.group_by { |action| "#{action.method} #{action.path}" }.map do |_key, related_actions|
+          new(
+            path: related_actions.first.path.to_s,
+            method: related_actions.first.method,
+            request: related_actions.first.request,
+            responses: related_actions.map(&:responses).flatten
+          )
+        end.flatten
+      end
+
+      def add_prefix(prefix)
+        @path = Tomograph::Path.new("#{prefix}#{path}")
+        self
+      end
+
+      def find_responses(status:)
+        to_hash['responses'].find_all do |response|
+          response['status'] == status.to_s
+        end
+      end
+
+      def to_hash
+        @action ||= {
+          'path' => path,
+          'method' => method,
+          'request' => request,
+          'responses' => responses
+        }
+      end
+    end
+  end
+end

data/lib/tomograph/version.rb

@@ -1,3 +1,3 @@
 module Tomograph
-  VERSION = '0.4.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/tomograph.gemspec

@@ -8,7 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors        = ['d.efimov']
   spec.email          = ['d.efimov@fun-box.ru']
 
-  spec.summary        = 'Parser API Blueprint specifications'
+  spec.summary        = 'Convert API Blueprint to JSON Schema and search'
+  spec.homepage       = 'https://github.com/funbox/tomograph'
   spec.license        = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tomograph
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - d.efimov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-23 00:00:00.000000000 Z
+date: 2017-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -155,11 +155,14 @@ files:
 - bin/console
 - bin/setup
 - lib/tomograph.rb
-- lib/tomograph/configuration.rb
+- lib/tomograph/api_blueprint/yaml.rb
+- lib/tomograph/api_blueprint/yaml/action.rb
+- lib/tomograph/path.rb
 - lib/tomograph/tomogram.rb
+- lib/tomograph/tomogram/action.rb
 - lib/tomograph/version.rb
 - tomograph.gemspec
-homepage: 
+homepage: https://github.com/funbox/tomograph
 licenses:
 - MIT
 metadata: {}
@@ -179,8 +182,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Parser API Blueprint specifications
+summary: Convert API Blueprint to JSON Schema and search
 test_files: []

data/lib/tomograph/configuration.rb

@@ -1,11 +0,0 @@
-module Tomograph
-  class Configuration
-    attr_accessor :documentation,
-                  :prefix,
-                  :drafter_yaml
-
-    def initialize
-      @prefix = ''
-    end
-  end
-end