nexmo-oas-renderer 0.11.2 → 2.1.1

data/lib/nexmo/oas/renderer/presenters/navigation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../helpers/navigation'
 
 module Nexmo

data/lib/nexmo/oas/renderer/presenters/open_api_specification.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require_relative './endpoint'
 require_relative './response_format'
@@ -9,7 +11,6 @@ module Nexmo
   module OAS
     module Renderer
       module Presenters
-
         class OpenApiSpecification
           extend Forwardable
 
@@ -30,9 +31,11 @@ module Nexmo
           end
 
           def definition_errors
+            return unless errors?
+
             @definition_errors ||= Nexmo::Markdown::Renderer.new.call(
               File.read("#{API.oas_path}/../../errors/#{@definition_name}.md")
-            ) if errors?
+            )
           end
 
           def definition

data/lib/nexmo/oas/renderer/presenters/request_body_raw.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Nexmo
+  module OAS
+    module Renderer
+      module Presenters
+        class RequestBodyRaw
+          def initialize(parameters, options = {}, endpoint = nil)
+            @parameters = parameters
+            @options = options
+            @endpoint = endpoint
+          end
+
+          def to_format(format)
+            return to_urlencoded if format == 'application/x-www-form-urlencoded'
+
+            to_json
+          end
+
+          def to_urlencoded
+            example = ''
+            body = URI.encode_www_form(generate_request)
+            if @endpoint
+              servers = @endpoint.path.servers || @endpoint.definition.servers
+              path = @endpoint.path.path.gsub(/\{(.+?)\}/, ':\1')
+              uri = URI("#{servers[0]['url']}#{path}")
+              example += "#{@endpoint.method.upcase} #{uri.path} HTTP/1.1\n"
+              example += "Host: #{uri.host} \n"
+              example += "Content-Type: application/x-www-form-urlencoded\n"
+              example += "Content-Length: #{body.length}\n"
+              example += "\n"
+            end
+            example += body
+            example
+          end
+
+          def to_json(*_args)
+            JSON.pretty_generate(generate_request)
+          end
+
+          def generate_request(parameters = nil, options = nil)
+            parameters ||= @parameters
+            options ||= @options
+            output = {}
+
+            parameters.each do |parameter|
+              next if options['required_only'] && optional?(parameter, options['required'])
+
+              parameter_name = name(parameter)
+              param = parameter
+
+              # This is all required to handle an edge case where parameter.name is an OasParser::Property
+              # Which happens when you use a oneOf inside items in a property.
+              # I believe this is a bug, but it's a BC break in the parser
+
+              if parameter_name.instance_of?(OasParser::Property)
+                parameter_name = parameter.owner.name
+                param = OasParser::Parameter.new(parameter_name, parameter.schema)
+              end
+
+              if param.raw['items'] && param.raw['example']
+                output[parameter_name] = param.raw['example']
+              elsif param.raw['items'] && param.raw['items']['oneOf']
+                param = param.raw['items']['oneOf'][0]
+                output[parameter_name] = [generate_request(properties(param).map(&:name))]
+              elsif collection?(param) && properties?(param)
+                nested_output = generate_request(properties(param))
+                next unless nested_output.keys.length.positive?
+
+                nested_output = [nested_output] if param.array?
+                output[parameter_name] = nested_output
+              else
+                ex = example(param)
+                next unless ex
+
+                if ex.is_a?(String)
+                  # Remove line breaks
+                  ex = ex.gsub('<br />', ' ')
+                end
+                output[parameter_name] = ex
+              end
+            end
+            output
+          end
+
+          def items(parameter)
+            return parameter['items'] unless parameter.respond_to?(:items)
+
+            parameter.items
+          end
+
+          def example(parameter)
+            return parameter['example'] unless parameter.respond_to?(:example)
+
+            parameter.example
+          end
+
+          def name(parameter)
+            return parameter['name'] unless parameter.respond_to?(:name)
+
+            parameter.name
+          end
+
+          def properties(parameter)
+            return parameter['properties'] unless parameter.respond_to?(:properties)
+
+            parameter.properties
+          end
+
+          def array?(parameter)
+            return parameter['items'] unless parameter.respond_to?(:array?)
+
+            parameter.array?
+          end
+
+          def collection?(parameter)
+            return parameter['properties'] unless parameter.respond_to?(:collection?)
+
+            parameter.collection?
+          end
+
+          def properties?(parameter)
+            return parameter['properties'] unless parameter.respond_to?(:collection?)
+
+            parameter.properties.size.positive?
+          end
+
+          def optional?(parameter, allow_list)
+            return false if allow_list&.include?(name(parameter))
+
+            return false unless parameter.respond_to?(:required)
+
+            return false unless parameter.schema
+
+            !parameter.required
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo/oas/renderer/presenters/response_format.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nexmo
   module OAS
     module Renderer
@@ -7,7 +9,7 @@ module Nexmo
             'application/json' => 'JSON',
             'application/xml' => 'XML',
             'text/xml' => 'XML',
-          }
+          }.freeze
 
           def self.to_dropdown(formats)
             MAPPINGS.slice(*formats)
@@ -18,7 +20,7 @@ module Nexmo
           end
 
           def extract
-            @formats ||= @responses.flat_map(&:formats).uniq
+            @extract ||= @responses.flat_map(&:formats).uniq
           end
         end
       end

data/lib/nexmo/oas/renderer/presenters/response_tab/link.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nexmo
   module OAS
     module Renderer
@@ -19,6 +21,7 @@ module Nexmo
 
             def data_tab_link
               return nil unless @schema['x-tab-id']
+
               @schema['x-tab-id']
             end
 

data/lib/nexmo/oas/renderer/presenters/response_tab/panel.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nexmo
   module OAS
     module Renderer
@@ -6,12 +8,13 @@ module Nexmo
           class Panel
             attr_reader :index
 
-            def initialize(schema:, index:, format:, content:, endpoint:)
+            def initialize(schema:, index:, format:, content:, endpoint:, theme_light: nil) # rubocop:disable Metrics/ParameterLists
               @schema  = schema
               @index   = index
               @format  = format
               @content = content
               @endpoint = endpoint
+              @theme_light = theme_light
             end
 
             def css_classes
@@ -22,15 +25,15 @@ module Nexmo
 
             def content
               if @content == :responses
-                Nexmo::OAS::Renderer::ResponseParserDecorator.
-                  new(@schema).
-                  html(@format, xml_options: @schema['xml'])
+                Nexmo::OAS::Renderer::ResponseParserDecorator
+                  .new(@schema)
+                  .html(@format, xml_options: @schema['xml'], theme_light: @theme_light)
               else
                 [:'open_api/_response_fields', locals: {
                   schema: @schema,
                   index: @index,
                   format: @format,
-                  endpoint: @endpoint
+                  endpoint: @endpoint,
                 }]
               end
             end

data/lib/nexmo/oas/renderer/presenters/response_tabs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './response_tab/link'
 require_relative './response_tab/panel'
 
@@ -8,11 +10,12 @@ module Nexmo
         class ResponseTabs
           attr_reader :format
 
-          def initialize(format, response, content, endpoint)
+          def initialize(format, response, content, endpoint, theme_light: nil)
             @format   = format
             @response = response
             @content  = content
             @endpoint = endpoint
+            @theme_light = theme_light
           end
 
           def tab_links
@@ -33,7 +36,8 @@ module Nexmo
                 index: index,
                 format: @format,
                 content: @content,
-                endpoint: @endpoint
+                endpoint: @endpoint,
+                theme_light: @theme_light
               )
             end
           end

data/lib/nexmo/oas/renderer/presenters/versions.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Nexmo
   module OAS
     module Renderer
       module Presenters
-
         class Versions
           def initialize(definition_name)
             @definition_name = definition_name
@@ -22,28 +23,28 @@ module Nexmo
           def available_versions
             @available_versions ||= begin
                                       matches = definitions.select do |definition|
-                                        definition.starts_with?(base_name) && !definition.include?("#{base_name}/")
+                                        definition.match(/^#{base_name}(\.v\d+)?$/) && !definition.include?("#{base_name}/")
                                       end
 
-                                      matches.map do |definition|
-                                        name = definition.chomp('.yml')
-                                        m = /\.v(\d+)/.match(name)
-                                        next { 'version' => '1', 'name' => name } unless m
-                                        { 'version' => m[1], 'name' => name }
+                                      matches = matches.map do |definition|
+                                        m = /\.v(\d+)/.match(definition)
+                                        next { 'version' => '1', 'name' => definition } unless m
 
-                                      end.sort_by { |v| v['version'] }
+                                        { 'version' => m[1], 'name' => definition }
+                                      end
+
+                                      matches.sort_by { |v| v['version'] }
                                     end
           end
 
           def definitions
             @definitions ||= begin
                                Dir.glob("#{API.oas_path}/**/*.yml").map do |file|
-                                 definition = file.sub("#{API.oas_path}/", '').chomp('.yml')
+                                 file.sub("#{API.oas_path}/", '').chomp('.yml')
                                end
                              end
           end
         end
-
       end
     end
   end

data/lib/nexmo/oas/renderer/public/assets/javascripts/components/format.js

@@ -1,11 +1,14 @@
 class Format {
   constructor() {
-    this.formatSelector = document.getElementsByClassName('js-format-selector')[0]
-    if (this.formatSelector) {
-      this.formatChanged(this.formatSelector.value, false)
-      this.formatSelector.addEventListener('change', (event) => {
-        this.formatChanged(event.target.value)
-      })
+    this.formatSelectors = document.getElementsByClassName('js-format-selector');
+
+    if (this.formatSelectors.length) {
+      this.formatChanged(this.formatSelectors[0].value, false)
+      for (let selector of this.formatSelectors) {
+        selector.addEventListener('change', (event) => {
+          this.formatChanged(event.target.value)
+        })
+      }
 
       this.restoreFormat()
     }
@@ -34,7 +37,9 @@ class Format {
     if (window.localStorage) {
       const format = window.localStorage.getItem('format')
       if (format) {
-        this.formatSelector.value = format
+        for (let selector of this.formatSelectors) {
+          selector.value = format
+        }
         this.formatChanged(format, false)
       }
     }

data/lib/nexmo/oas/renderer/public/assets/javascripts/nexmo-oas-renderer.js

@@ -1,31 +1,65 @@
-document.addEventListener("DOMContentLoaded", function() {
-
-  // Toggle text on accordion button for response fields
-  var responseDescriptionTogglers = document.getElementsByClassName('response-description-toggle');
-
-  Array.from(responseDescriptionTogglers).forEach(function(element) {
-    element.addEventListener('click', function(event) {
-      var text = event.target.textContent;
-      var newText;
-      if (text.indexOf('View') != -1) {
-        newText = text.replace("View", "Hide");
-      } else {
-        newText = text.replace("Hide", "View");
-      }
-      event.target.textContent = newText;
-    });
-  });
+if(document.querySelector(".oas-wrapper")){
+  if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+    var queryString = new URLSearchParams(window.location.search);
+    if (!queryString.get('theme')) {
+      queryString.set("theme", "dark");
+      window.location.search = queryString.toString();
+    }
+  }
 
-  // Handle people clicking on oneOf tabs by changing every one on the page
-  var oneOfTabs = document.querySelectorAll('[data-tab-link]');
-    Array.from(oneOfTabs).forEach(function(element) {
-        element.addEventListener('click', function (event) {
-          var link = event.target.getAttribute('data-tab-link');
-          var matchingTabs = document.querySelectorAll('[data-tab-link="'+link+'"]');
-            Array.from(matchingTabs).forEach(function(element) {
-              element.dispatchEvent(new Event('toggle'));
-            });
+  document.addEventListener("DOMContentLoaded", function() {
+    // Handle people clicking on oneOf tabs by changing every one on the page
+    var oneOfTabs = document.querySelectorAll('[data-tab-link]');
+    Array.from(oneOfTabs).forEach(function (element) {
+      element.addEventListener('click', function (event) {
+        var link = event.target.getAttribute('data-tab-link');
+        var matchingTabs = document.querySelectorAll('[data-tab-link="' + link + '"]');
+        Array.from(matchingTabs).forEach(function (element) {
+          element.dispatchEvent(new Event('toggle'));
         });
+      });
     });
 
-});
+    var toggleTopNav = function(event, closeOnly) {
+
+      if (event) {
+        if (!Array.from(event.target.classList).includes("oas-trigger")) {
+          return;
+        }
+      }
+
+      var c = document.querySelector('.oas-trigger-content');
+      if (closeOnly === true) {
+        c.style.display = "none";
+        return;
+      }
+      c.style.display = c.style.display == 'block' ? 'none' : "block";
+    };
+
+    if (document.querySelector('.oas-trigger')) {
+      document.querySelector('.oas-trigger').addEventListener("click", toggleTopNav);
+    }
+
+    document.querySelectorAll('a').forEach((element) => {
+      var href = element.getAttribute("href");
+      if (!href){ return; }
+      if (href.slice(0,1) !== "#"){ return; }
+      element.addEventListener('click', function (event) {
+        event.preventDefault();
+
+        toggleTopNav(null, true);
+
+        var to = document.querySelector(event.target.hash)
+        history.pushState({}, '', event.target.href);
+        window.scrollTo({
+          top: (window.scrollY + to.getBoundingClientRect().y) - 70,
+          left: 0,
+        })
+
+
+      });
+    });
+
+  });
+}
+