nexmo-oas-renderer 0.1.0

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

@@ -0,0 +1,15 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class PHPInliner < Banzai::Filter
+          def call(input)
+            input.gsub(/(```php)\n/) do
+              "#{$1}?start_inline=1\n"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Screenshot < Banzai::Filter
+          def call(input)
+            input.gsub(/```screenshot(.+?)```/m) do |_s|
+              config = YAML.safe_load($1)
+              if config['image'] && File.file?(config['image'])
+                "![Screenshot](#{config['image'].gsub('public', '')})"
+              else
+                <<~HEREDOC
+                  ## Missing image
+                  To fix this run:
+                  ```
+                  $ rake screenshots:update
+                  ```
+                HEREDOC
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,250 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Tab < Banzai::Filter
+          def call(input)
+            input.gsub(/^(\s*)```tabbed_(examples|content)(.+?)```/m) do |_s|
+              @indentation = $1
+              @mode = $2
+              @config = YAML.safe_load($3)
+              validate_config
+              html
+            end
+          end
+
+          private
+
+          def create_tabs(content)
+            tab = Nokogiri::XML::Element.new 'div', @document
+            tab['class'] = 'Vlt-tabs__link'
+            tab['class'] += ' Vlt-tabs__link_active' if content[:active]
+
+            if content[:language]
+              tab['data-language'] = content[:language].key
+              tab['data-language-type'] = content[:language].type
+              tab['data-language-linkable'] = content[:language].linkable?
+            end
+
+            if content[:platform]
+              tab['data-language'] = content[:platform].languages.map(&:key).join(',')
+              tab['data-platform'] = content[:platform].key
+              tab['data-platform-type'] = content[:platform].type
+              tab['data-platform-linkable'] = content[:platform].linkable?
+            end
+
+            tab_link = Nokogiri::XML::Element.new 'span', @document
+            if content[:language]
+              # We don't currently have icons for JSON/XML
+              if ['json', 'xml'].include? content[:language].key.downcase
+                tab_link.content = content[:tab_title]
+              elsif content[:language].key == 'objective_c' || content[:language].key == 'swift'
+                tab_link.inner_html = '<svg><use xlink:href="/assets/images/brands/ios.svg#ios" /></svg><span>' + content[:tab_title] + '</span>'
+              else
+                tab_link.inner_html = "<svg><use xlink:href=\"/assets/images/brands/#{content[:language].key}.svg##{content[:language].key}\" /></svg><span>" + content[:tab_title] + '</span>'
+              end
+            elsif content[:platform]
+              tab_link.inner_html = "<svg><use xlink:href=\"/assets/images/brands/#{content[:platform].key}.svg##{content[:platform].key}\" /></svg><span>" + content[:tab_title] + '</span>'
+            else
+              tab_link.content = content[:tab_title]
+            end
+
+            tab.add_child(tab_link)
+            @tabs.add_child(tab)
+          end
+
+          def create_content(content)
+            tabs_panel = Nokogiri::XML::Element.new 'div', @document
+            tabs_panel['class'] = 'Vlt-tabs__panel'
+            tabs_panel['class'] += ' Vlt-tabs__panel_active' if content[:active]
+
+            element = Nokogiri::XML::Element.new 'p', @document
+            element['aria-labelledby'] = "\"#{content[:id]}\""
+            element['aria-hidden'] = true
+            element.inner_html = content[:body]
+
+            tabs_panel.add_child(element)
+            @tabs_content.add_child(tabs_panel)
+          end
+
+          def tabbed_code_examples?
+            @mode == 'examples'
+          end
+
+          def tabbed_content?
+            @mode == 'content'
+          end
+
+          def html
+            html = <<~HEREDOC
+              <div class="Vlt-tabs">
+                <div class="Vlt-tabs__header Vlt-tabs__header--bordered"></div>
+                  <div class="Vlt-tabs__content">
+                  </div>
+              </div>
+            HEREDOC
+
+            @document = Nokogiri::HTML::DocumentFragment.parse(html)
+            @tabs = @document.at_css('.Vlt-tabs__header')
+            @tabs_content = @document.at_css('.Vlt-tabs__content')
+
+            contents.each do |content|
+              create_tabs(content)
+              create_content(content)
+            end
+
+            source = @document.to_html
+
+            "#{@indentation}FREEZESTART#{Base64.urlsafe_encode64(source)}FREEZEEND"
+          end
+
+          def contents
+            list = content_from_source if @config['source']
+            list = content_from_tabs if @config['tabs']
+
+            list ||= []
+
+            return list unless list.any?
+
+            list = resolve_language(list)
+
+            if tabbed_code_examples?
+              list = format_code(list)
+              list = resolve_code(list)
+              list = resolve_tab_title(list)
+            end
+
+            list = sort_contents(list)
+            resolve_active_tab(list)
+
+            list
+          end
+
+          def validate_config
+            return if @config && (@config['source'] || @config['tabs'])
+            raise 'Source or tabs must be present in this tabbed_example config'
+          end
+
+          def content_from_source
+            source_path = @config['source']
+            source_path += '/*' if tabbed_code_examples?
+            source_path += '/*.md' if tabbed_content?
+
+            files = Dir[source_path]
+            raise "Empty content_from_source file list in #{source_path}" if files.empty?
+            files.map do |content_path|
+              raise "Could not find content_from_source file: #{content_path}" unless File.exist? content_path
+              source = File.read(content_path)
+
+              content = {
+                id: SecureRandom.hex,
+                source: source,
+              }
+
+              if tabbed_code_examples?
+                language_key = File.basename(content_path, '.*').downcase
+                content[:language_key] = language_key
+              end
+
+              if tabbed_content?
+                content[:frontmatter] = YAML.safe_load(source)
+                content[:language_key] = content[:frontmatter]['language']
+                content[:platform_key] = content[:frontmatter]['platform']
+                content[:tab_title] = content[:frontmatter]['title']
+                content[:body] = MarkdownPipeline.new(options).call(source)
+              end
+
+              content
+            end
+          end
+
+          def content_from_tabs
+            @config['tabs'].map do |title, config|
+              file_path = config['source']
+              raise "Could not find content_from_tabs file: #{config['source']}" unless File.exist? file_path
+              source = File.read(file_path)
+
+              config.symbolize_keys.merge({
+                id: SecureRandom.hex,
+                source: source,
+                language_key: title.dup.downcase,
+              })
+            end
+          end
+
+          def resolve_language(contents)
+            contents.map do |content|
+              if content[:language_key]
+                content[:language] = CodeLanguageAPI.find(content[:language_key])
+              end
+
+              if content[:platform_key]
+                content[:platform] = CodeLanguageAPI.find(content[:platform_key])
+              end
+
+              content
+            end
+          end
+
+          def format_code(contents)
+            contents.each do |content|
+              if content[:from_line] || content[:to_line]
+                lines = content[:source].lines
+                total_lines = lines.count
+                from_line = (content[:from_line] || 1) - 1
+                to_line = (content[:to_line] || total_lines) - 1
+                content[:source] = lines[from_line..to_line].join
+              end
+
+              content[:source].unindent! if content[:unindent]
+            end
+          end
+
+          def resolve_code(contents)
+            contents.map do |content|
+              @formatter ||= Rouge::Formatters::HTML.new
+              lexer = content[:language].lexer
+              highlighted_source = @formatter.format(lexer.lex(content[:source]))
+              body = <<~HEREDOC
+                <pre class="highlight #{content[:language_key]}"><code>#{highlighted_source}</code></pre>
+              HEREDOC
+
+              content.merge!({ body: body })
+            end
+          end
+
+          def resolve_tab_title(contents)
+            contents.map do |content|
+              content.merge!({ tab_title: content[:language].label })
+            end
+          end
+
+          def sort_contents(contents)
+            contents.sort_by do |content|
+              next content[:language].weight if content[:language]
+              next content[:frontmatter]['menu_weight'] || 999 if content[:frontmatter]
+              999
+            end
+          end
+
+          def resolve_active_tab(contents)
+            active_index = nil
+
+            if options[:code_language]
+              contents.each_with_index do |content, index|
+                %i[language_key platform_key].each do |key|
+                  active_index = index if content[key] == options[:code_language].key
+                end
+              end
+            end
+
+            @tabs['data-has-initial-tab'] = active_index.present?
+            active_index ||= 0
+
+            contents[active_index][:active] = true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Techio < Banzai::Filter
+          def call(input)
+            input.gsub(/```techio(.+?)```/m) do |_s|
+              config = YAML.safe_load($1)
+
+              techio = <<~HEREDOC
+                <div class="techio-container">
+                  <iframe width="100%" frameborder="0" scrolling="no" allowtransparency="true" style="visibility: hidden" src="https://tech.io/playground-widget#{config['path']}/#{config['title']}"></iframe>
+                  <script>if(typeof window.techioScriptInjected==="undefined"){window.techioScriptInjected=true;var d=document,s=d.createElement("script");s.src="https://files.codingame.com/codingame/iframe-v-1-4.js";(d.head||d.body).appendChild(s);}</script>
+                </div>
+              HEREDOC
+
+              "FREEZESTART#{Base64.urlsafe_encode64(techio)}FREEZEEND"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Tooltip < Banzai::Filter
+          def call(input)
+            input.gsub(/\^\[([a-zA-Z0-9\s:\-]+)\]\((.+?)\)/) do
+              tooltip = <<~HEREDOC
+                <span class="Vlt-tooltip Vlt-tooltip--top" title="#{$2}" tabindex="0">
+                  #{$1}&nbsp;
+                  <svg class="Vlt-icon Vlt-icon--smaller Vlt-icon--text-bottom Vlt-blue" aria-hidden="true"><use xlink:href="/assets/symbol/volta-icons.svg#Vlt-icon-help-negative"/></svg>
+                </span>
+              HEREDOC
+
+              "FREEZESTART#{Base64.urlsafe_encode64(tooltip)}FREEZEEND"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class TutorialLink < Banzai::Filter
+          def call(input)
+            @input = input
+
+            document.css('a').each_with_index do |link, _index|
+              if link['href']&.start_with?('/tutorials/')
+                link['data-turbolinks'] = 'false'
+              end
+            end
+
+            @document.to_html
+          end
+
+          private
+
+          def document
+            @document ||= Nokogiri::HTML::DocumentFragment.parse(@input)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require_relative '../models/tutorial'
+require 'banzai'
+require 'yaml'
+
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Tutorials < Banzai::Filter
+          def call(input)
+            input.gsub(/```tutorials(.+?)```/m) do |_s|
+              config = YAML.safe_load($1)
+              @product = config['product']
+              @tutorials = Models::Tutorial.by_product(@product)
+
+              # Default to plain layout, but allow people to override it
+              config['layout'] = 'list/plain' unless config['layout']
+
+              erb = File.read("#{API.root}/views/tutorials/#{config['layout']}.html.erb")
+              html = ERB.new(erb).result(binding)
+              "FREEZESTART#{Base64.urlsafe_encode64(html)}FREEZEEND"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Unfreeze < Banzai::Filter
+          def call(input)
+            input.gsub!('FREEZESTARTFREEZEEND', '')
+            input.gsub!('<p>FREEZESTART', 'FREEZESTART')
+            input.gsub!('FREEZEEND</p>', 'FREEZEEND')
+
+            input.gsub!(/FREEZESTART(.+?)FREEZEEND/m) do |_s|
+              Base64.urlsafe_decode64($1).force_encoding(Encoding::UTF_8)
+            end
+            input
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class UserPersonalization < Banzai::Filter
+          def call(input)
+            return input unless options[:current_user]
+            return input if options[:current_user].api_key.blank?
+            return input if options[:current_user].api_secret.blank?
+
+            @input = input
+            document.css('pre code').each do |code|
+              html = code.to_s
+
+              html.gsub!(/(['|"])?NEXMO_API_(KEY|SECRET)['|"]?/) do
+                quote = $1 || "'"
+                value = (
+                  case $2
+                when 'KEY' then options[:current_user].api_key
+                when 'SECRET' then options[:current_user].api_secret
+                end
+                )
+                "#{quote}#{value}#{quote}"
+              end
+
+              html.gsub!('NEXMO_API_SECRET', "'#{options[:current_user].api_secret}'")
+
+              code.replace(html)
+            end
+
+            @document.to_html
+          end
+
+          private
+
+          def document
+            @document ||= Nokogiri::HTML::DocumentFragment.parse(@input)
+          end
+        end
+      end
+    end
+  end
+end