nexmo-oas-renderer 0.1.0

data/lib/nexmo/oas/renderer/config.ru

@@ -0,0 +1,7 @@
+require_relative "./app"
+require "sass/plugin/rack"
+
+Sass::Plugin.options[:style] = :compressed
+use Sass::Plugin::Rack
+
+run Nexmo::OAS::Renderer::API

data/lib/nexmo/oas/renderer/config/code_languages.yml

@@ -0,0 +1,138 @@
+terminal_programs:
+  curl:
+    weight: 1
+    label: cURL
+    lexer: sh
+    icon: curl
+    run_command: 'sh {filename}'
+  cli:
+    label: CLI
+    lexer: sh
+    linkable: false
+
+languages:
+  javascript:
+    weight: 2
+    label: JavaScript
+    lexer: javascript
+    icon: javascript
+    dependencies:
+      - 'nexmo'
+
+  node:
+    weight: 2
+    label: Node.js
+    lexer: javascript
+    icon: node
+    dependencies:
+      - 'nexmo'
+    run_command: 'node {filename}'
+
+  java:
+    weight: 3
+    label: Java
+    lexer: java
+    unindent: true
+    icon: java
+    dependencies:
+      - 'com.nexmo:client:@latest'
+
+  dotnet:
+    weight: 4
+    label: .NET
+    lexer: c#
+    unindent: true
+    icon: dotnet
+    dependencies:
+      - 'Nexmo.Csharp.Client'
+  csharp:
+    weight: 4
+    label: .NET
+    lexer: c#
+    unindent: true
+    icon: dotnet
+    dependencies:
+      - 'Nexmo.Csharp.Client'
+
+  php:
+    weight: 5
+    label: PHP
+    lexer: php
+    icon: php
+    dependencies:
+      - 'nexmo/client'
+    run_command: 'php {filename}'
+
+  python:
+    weight: 6
+    label: Python
+    lexer: python
+    icon: python
+    dependencies:
+      - 'nexmo'
+    run_command: 'python {filename}'
+
+  ruby:
+    weight: 7
+    label: Ruby
+    lexer: ruby
+    icon: ruby
+    dependencies:
+      - 'nexmo'
+    run_command: 'ruby {filename}'
+
+  kotlin:
+    weight: 8
+    label: Kotlin
+    lexer: java
+    icon: android
+    dependencies: []
+
+  android:
+    weight: 9
+    label: Java
+    lexer: java
+    icon: android
+    dependencies: []
+
+  swift:
+    weight: 10
+    label: Swift
+    lexer: swift
+    icon: ios
+    dependencies: []
+
+  objective_c:
+    weight: 11
+    label: Objective-C
+    lexer: objective_c
+    icon: ios
+    dependencies: []
+
+platforms:
+  ios:
+    languages:
+      - swift
+      - objective_c
+  android:
+    languages:
+      - java
+  web:
+    languages:
+      - javascript
+
+data:
+  ncco:
+    label: NCCO
+    lexer: json
+    linkable: false
+  json:
+    weight: 1
+    label: JSON
+    lexer: json
+    linkable: false
+  xml:
+    weight: 2
+    label: XML
+    lexer: xml
+    linkable: false

data/lib/nexmo/oas/renderer/config/dynamic_content.yml

@@ -0,0 +1 @@
+dynamic_content_example: the future

data/lib/nexmo/oas/renderer/config/redirects.yml

@@ -0,0 +1,8 @@
+"/api/voice/ncco": "/voice/voice-api/ncco-reference"
+"/api/account/secret-management": "/api/account#secret-management"
+"/api/developer": "/api/numbers"
+"/api/developer/numbers": "/api/numbers"
+"/api/developer/account": "/api/account"
+"/api/messages": "/api/developer/messages"
+
+"/api/stitch": "/api/conversation"

data/lib/nexmo/oas/renderer/constraints/open_api.rb

@@ -0,0 +1,76 @@
+require_relative '../services/code_language_api'
+
+module Nexmo
+  module OAS
+    module Renderer
+      module Constraints
+        class OpenApi
+
+          OPEN_API_PRODUCTS = %w[
+            sms
+            media
+            number-insight
+            conversation
+            messages-olympus
+            dispatch
+            redact
+            audit
+            voice.v2
+            voice
+            account
+            external-accounts
+            numbers
+            verify
+            vonage-business-cloud/account
+            vonage-business-cloud/extension
+            vonage-business-cloud/user
+            application.v2
+          ].freeze
+
+          def self.match?(definition, code_language = nil)
+            if code_language.nil?
+              products_with_code_language[:definition].match?(definition)
+            else
+              products_with_code_language[:definition].match?(definition) &&
+                products_with_code_language[:code_language].match?(code_language)
+            end
+          end
+
+          def self.list
+            OPEN_API_PRODUCTS
+          end
+
+          def self.products
+            { definition: Regexp.new("^(#{OPEN_API_PRODUCTS.join('|')})$") }
+          end
+
+          def self.errors_available
+            all = OPEN_API_PRODUCTS.dup.concat(['application'])
+            { definition: Regexp.new(all.join('|')) }
+          end
+
+          def self.products_with_code_language
+            products.merge(CodeLanguageAPI.route_constraint)
+          end
+
+          def self.find_all_versions(name)
+            # Remove the .v2 etc if needed
+            name = name.gsub(/(\.v\d+)/, '')
+
+            matches = OPEN_API_PRODUCTS.select do |s|
+              s.start_with?(name) && !s.include?("#{name}/")
+            end
+
+            matches = matches.map do |s|
+              m = /\.v(\d+)/.match(s)
+              next { 'version' => '1', 'name' => s } unless m
+              { 'version' => m[1], 'name' => s }
+            end
+
+            matches.sort_by { |v| v['version'] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/constraints/redirector.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+
+module Nexmo
+  module OAS
+    module Renderer
+      module Constraints
+        class Redirector
+          REDIRECTS = YAML.load_file(File.expand_path("../config/redirects.yml", __dir__)) || {}
+
+          def self.find(request)
+            REDIRECTS[request.path] || false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/decorators/response_parser_decorator.rb

@@ -0,0 +1,55 @@
+require 'rouge'
+require 'neatjson'
+require_relative '../services/oas_parser'
+
+module Nexmo
+  module OAS
+    module Renderer
+      class ResponseParserDecorator < ::OasParser::ResponseParser
+        def formatted_json
+          JSON.neat_generate(parse, {
+            wrap: true,
+            after_colon: 1,
+          })
+        end
+
+        def formatted_xml(xml_options = {})
+          xml_options[:root] = xml_options['name'] if xml_options
+          xml_string = xml(xml_options)
+          xml_string.gsub!(%r{^(\s+?)(<(?:\w|\=|\"|\_|\s)+?\>)(.+?)(</.+?>)}).each do |s|
+            indentation = $1
+            indentation_plus_one = "#{$1}  "
+            opening_tag = $2
+            content = $3
+            closing_tag = $4
+
+            next(s) if (indentation.size + opening_tag.size + content.size) < 60
+
+            next "#{indentation}#{opening_tag}\n#{indentation_plus_one}#{content}\n#{indentation}#{closing_tag}"
+          end
+
+          xml_string
+        end
+
+        def html(format = 'application/json', xml_options: nil)
+          formatter = Rouge::Formatters::HTML.new
+
+          case format
+          when 'application/json'
+            lexer = Rouge::Lexer.find('json')
+            highlighted_response = formatter.format(lexer.lex(formatted_json))
+          when 'text/xml', 'application/xml'
+            lexer = Rouge::Lexer.find('xml')
+            highlighted_response = formatter.format(lexer.lex(formatted_xml(xml_options)))
+          end
+
+          output = <<~HEREDOC
+      <pre class="highlight json"><code>#{highlighted_response}</code></pre>
+          HEREDOC
+
+          output
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/filters/anchor.rb

@@ -0,0 +1,17 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Anchor < Banzai::Filter
+          def call(input)
+            input.gsub(/^[\u{2693}](.+?)\n/) do
+              <<~HEREDOC
+                <a name="#{$1.parameterize}"></a>
+              HEREDOC
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/filters/audio.rb

@@ -0,0 +1,21 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Audio < Banzai::Filter
+          def call(input)
+            input.gsub(/[u{🔈}]\[(.+?)\]/) do
+              audio = <<~HEREDOC
+                <audio controls>
+                  <source src="#{$1}" type="audio/mpeg">
+                </audio>
+              HEREDOC
+
+              "FREEZESTART#{Base64.urlsafe_encode64(audio)}FREEZEEND"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/filters/block_escape.rb

@@ -0,0 +1,24 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class BlockEscape < Banzai::Filter
+          def call(input)
+            # Freeze to prevent Markdown formatting
+            input.gsub(/````\n(.+?)````/m) do |_s|
+              lexer = Rouge::Lexer.find('text')
+              formatter = Rouge::Formatters::HTML.new
+              highlighted_source = formatter.format(lexer.lex($1))
+
+              output = <<~HEREDOC
+                <pre class="highlight #{lexer.tag}"><code>#{highlighted_source}</code></pre>
+              HEREDOC
+
+              "FREEZESTART#{Base64.urlsafe_encode64(output)}FREEZEEND"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/filters/break.rb

@@ -0,0 +1,13 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Break < Banzai::Filter
+          def call(input)
+            input.gsub('§', '<br>')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/filters/code.rb

@@ -0,0 +1,64 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Code < Banzai::Filter
+          def call(input)
+            input.gsub(/(?!.*snippet)```code(.+?)```/m) do |_s|
+              config = YAML.safe_load($1)
+
+              if config['config']
+                configs = YAML.load_file("#{API.root}/config/code_examples.yml")
+                config = config['config'].split('.').inject(configs) { |h, k| h[k] }
+              end
+
+              code = File.read("#{API.root}/#{config['source']}")
+              language = File.extname("#{API.root}/#{config['source']}")[1..-1]
+              lexer = language_to_lexer(language)
+
+              total_lines = code.lines.count
+
+              # Minus one since lines are not zero-indexed
+              from_line = (config['from_line'] || 1) - 1
+              to_line = (config['to_line'] || total_lines) - 1
+
+              code = code.lines[from_line..to_line].join
+              code.unindent! if config['unindent']
+
+              highlighted_source = highlight(code, lexer)
+
+              <<~HEREDOC
+        <pre class="highlight #{lexer.tag}"><code>#{highlighted_source}</code></pre>
+              HEREDOC
+            end
+          end
+
+          private
+
+          def highlight(source, lexer)
+            formatter = Rouge::Formatters::HTML.new
+            formatter.format(lexer.lex(source))
+          end
+
+          def language_to_lexer_name(language)
+            if language_configuration[language]
+              language_configuration[language]['lexer']
+            else
+              language
+            end
+          end
+
+          def language_to_lexer(language)
+            language = language_to_lexer_name(language)
+            return Rouge::Lexers::PHP.new({ start_inline: true }) if language == 'php'
+            Rouge::Lexer.find(language.downcase) || Rouge::Lexer.find('text')
+          end
+
+          def language_configuration
+            @language_configuration ||= YAML.load_file("#{API.root}/config/code_languages.yml")
+          end
+        end
+      end
+    end
+  end
+end