nexmo-oas-renderer 0.1.0

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

@@ -0,0 +1,194 @@
+require 'octicons_helper'
+
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class CodeSnippet < Banzai::Filter
+          include OcticonsHelper
+
+          def call(input)
+            input.gsub(/```single_code_snippet(.+?)```/m) do |_s|
+              config = YAML.safe_load($1)
+
+              @renderer = get_renderer(config['language'])
+
+              lexer = CodeLanguageAPI.find(config['language']).lexer
+              lang = config['title'].delete('.')
+
+              application_html = generate_application_block(config['application'])
+
+              # Read the client
+              if config['client']
+                highlighted_client_source = generate_code_block(config['language'], config['client'], config['unindent'])
+              end
+
+              # Read the code
+              highlighted_code_source = generate_code_block(config['language'], config['code'], config['unindent'])
+
+              dependency_html = ''
+              if config['dependencies']
+                dependency_html = generate_dependencies(lexer.tag, config['dependencies'])
+              end
+
+              source_url = generate_source_url(config['code'])
+
+              client_html = ''
+              if highlighted_client_source
+                client_url = generate_source_url(config['client'])
+                id = SecureRandom.hex
+                create_instructions = @renderer.create_instructions(config['file_name']).render_markdown
+                erb = File.read("#{API.root}/views/code_snippets/_configure_client.html.erb")
+                client_html = ERB.new(erb).result(binding)
+              end
+
+              add_instructions = @renderer.add_instructions(config['file_name']).render_markdown
+              if config['code_only']
+                erb = File.read("#{API.root}/views/code_snippets/_code_only.html.erb")
+              else
+                erb = File.read("#{API.root}/views/code_snippets/_write_code.html.erb")
+              end
+
+              code_html = ERB.new(erb).result(binding)
+
+              return code_html if config['code_only']
+
+              config['run_command'] = config['run_command'].gsub('{filename}', config['file_name']) if config['run_command']
+              run_html = @renderer.run_command(config['run_command'], config['file_name'], config['code']['source']).to_s
+
+              prereqs = (application_html + dependency_html + client_html).strip
+              prereqs = "<h2>Prerequisites</h2>#{prereqs}" unless prereqs.empty?
+              prereqs + code_html + run_html
+            end
+          end
+
+          private
+
+          def highlight(source, lexer)
+            formatter = Rouge::Formatters::HTML.new
+            formatter.format(lexer.lex(source))
+          end
+
+          def generate_code_block(language, input, unindent)
+            filename = input['source']
+            return '' unless input
+            raise "CodeSnippetFilter - Could not load #{filename} for language #{language}" unless File.exist?(filename)
+
+            code = File.read(filename)
+            lexer = CodeLanguageAPI.find(language).lexer
+
+            total_lines = code.lines.count
+
+            # Minus one since lines are not zero-indexed
+            from_line = (input['from_line'] || 1) - 1
+            to_line = (input['to_line'] || total_lines) - 1
+
+            code = code.lines[from_line..to_line].join
+            code.unindent! if unindent
+
+            highlight(code, lexer)
+          end
+
+          def get_renderer(language)
+            language = 'dotnet' if language == 'csharp'
+            case language
+            when 'curl'
+              CodeSnippetRenderer::Curl
+            when 'node'
+              CodeSnippetRenderer::Javascript
+            when 'javascript'
+              CodeSnippetRenderer::Javascript
+            when 'java'
+              CodeSnippetRenderer::Java
+            when 'dotnet'
+              CodeSnippetRenderer::Dotnet
+            when 'python'
+              CodeSnippetRenderer::Python
+            when 'ruby'
+              CodeSnippetRenderer::Ruby
+            when 'php'
+              CodeSnippetRenderer::Php
+            when 'android'
+              CodeSnippetRenderer::Android
+            when 'kotlin'
+              CodeSnippetRenderer::Kotlin
+            when 'objective_c'
+              CodeSnippetRenderer::ObjectiveC
+            when 'swift'
+              CodeSnippetRenderer::Swift
+            else
+              raise "Unknown language: #{language}"
+            end
+          end
+
+          def generate_dependencies(language, dependencies)
+            # The only valid dependency for curl examples is `JWT`
+            dependencies = dependencies.map(&:upcase)
+            if dependencies.include?('JWT')
+              title = 'Generate your JWT'
+            else
+              title = 'Install dependencies'
+            end
+            deps = @renderer.dependencies(dependencies)
+            id = SecureRandom.hex
+            erb = File.read("#{API.root}/views/code_snippets/_dependencies.html.erb")
+            ERB.new(erb).result(binding)
+          end
+
+          def generate_application_block(app)
+            return '' unless app
+
+            base_url = 'http://demo.ngrok.io'
+            base_url = 'https://example.com' if app['disable_ngrok']
+
+            app['name'] = 'ExampleProject' unless app['name']
+
+            # We should remove this default once we're sure that all Code Snippets
+            # have a type set e.g audit
+            app['type'] ||= 'voice'
+
+            if ['voice', 'rtc'].include? app['type']
+              app['event_url'] = "#{base_url}/webhooks/events" unless app['event_url']
+              app['answer_url'] = "#{base_url}/webhooks/answer" unless app['answer_url']
+              erb = File.read("#{API.root}/views/code_snippets/_application_#{app['type']}.html.erb")
+            elsif ['messages', 'dispatch'].include? app['type']
+              erb = File.read("#{API.root}/views/code_snippets/_application_messages_dispatch.html.erb")
+            else
+              raise "Invalid application type when creating code snippet: '#{app['type']}'"
+            end
+
+            id = SecureRandom.hex
+
+            ERB.new(erb).result(binding)
+          end
+
+          def generate_source_url(code)
+            # Source example: .repos/nexmo/nexmo-java-code-snippets/ExampleClass.java
+            # Direct link on GitHub is in form https://github.com/nexmo/nexmo-java-code-snippets/blob/master/ExampleClass.java
+            start_section = 'https://github.com'
+
+            # Insert "blob/master" and strip ".repos" - except dotnet that needs "blob/ASPNET" instead
+            repo_path = '\\0blob/master/'
+            repo_path = '\\0blob/ASPNET/' if code['source'].include?('dotnet')
+            file_section = code['source'].sub('.repos', '').sub(%r{(-quickstart|-code-snippets|-code-snippets)/}, repo_path)
+
+            # Line highlighting
+            line_section = ''
+            if code['from_line']
+              line_section += "#L#{code['from_line']}"
+              if code['to_line']
+                # If we've provided a to_line, use that
+                line_section += "-L#{code['to_line']}" if code['to_line']
+              else
+                # By default we read to the end of the file
+                line_section += "-L#{File.read(code['source']).lines.count}"
+              end
+            end
+
+            start_section + file_section + line_section
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'yaml'
+require 'banzai'
+require_relative '../models/code_snippet'
+
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class CodeSnippetList < Banzai::Filter
+          def call(input)
+            input.gsub(/```code_snippet_list(.+?)```/m) do |_s|
+              config = YAML.safe_load($1)
+              @product = config['product']
+              @blocks = Models::CodeSnippet.by_product(@product)
+
+              # Top level blocks come before subfolder
+              @blocks.sort_by! do |b|
+                sort_array = []
+                sort_array << (b.category ? 1 : 0)
+                sort_array << b.navigation_weight
+                sort_array
+              end
+
+              erb = File.read("#{API.root}/views/code_snippets/list/plain.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/code_snippets.rb

@@ -0,0 +1,158 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class CodeSnippets < Banzai::Filter
+          def call(input)
+            input.gsub(/^(\s*)```code_snippets(.+?)```/m) do |_s|
+              @indentation = $1
+              @config = YAML.safe_load($2)
+              validate_config
+              html
+            end
+          end
+
+          private
+
+          def create_tabs(content)
+            tab = Nokogiri::XML::Element.new 'li', @document
+            tab['class'] = 'Vlt-tabs__link'
+            tab['class'] += ' Vlt-tabs__link_active' if content[:active]
+            tab['aria-selected'] = 'true' if content[:active]
+
+            if content['language']
+              tab['data-language'] = content['language']
+              tab['data-language-type'] = content['language_type']
+              tab['data-language-linkable'] = true
+            end
+
+            tab_link = Nokogiri::XML::Element.new 'a', @document
+            tab_link.inner_html = "<svg><use xlink:href=\"/assets/images/brands/#{content['icon']}.svg##{content['icon']}\" /></svg><span>" + content['title'] + '</span>'
+            tab_link['class'] = 'tab-link'
+
+            tab.add_child(tab_link)
+            @tabs.add_child(tab)
+          end
+
+          def create_content(content)
+            element = Nokogiri::XML::Element.new 'div', @document
+            element['id'] = content['id']
+            element['class'] = 'Vlt-tabs__panel'
+            element['class'] += ' Vlt-tabs__panel_active' if content[:active]
+            element.inner_html = content[:body]
+
+            @tabs_content.add_child(element)
+          end
+
+          def html
+            html = <<~HEREDOC
+              <div class="Vlt-tabs">
+                <div class="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--bordered')
+            @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
+            list ||= []
+
+            return list unless list.any?
+
+            list = sort_contents(list)
+            resolve_active_tab(list)
+
+            list
+          end
+
+          def validate_config
+            return if @config && @config['source']
+            raise 'A source key must be present in this building_blocks config'
+          end
+
+          def content_from_source
+            source_path = "#{@config['source']}/*.yml"
+
+            files = Dir[source_path]
+            raise "No .yml files found for #{@config['source']} code snippets" if files.empty?
+
+            files.map do |content_path|
+              source = File.read(content_path)
+
+              # Load the defaults for this language
+              filename = File.basename(content_path, '.yml')
+              defaults = CodeLanguageAPI.find(filename)
+
+              content = YAML.safe_load(source)
+              content['source'] = source
+              content['id'] = SecureRandom.hex
+              content['title'] ||= defaults.label
+              content['language'] ||= defaults.key
+              content['language_type'] ||= defaults.type
+              content['dependencies'] ||= defaults.dependencies
+              content['icon'] = defaults.icon
+              content['weight'] ||= defaults.weight
+              content['run_command'] ||= defaults.run_command
+              content['unindent'] = defaults.unindent || false
+
+              # If we don't have a file_name in config, use the one in the repo
+              content['file_name'] ||= File.basename(content['code']['source'])
+
+              parent_config = { 'code_only' => @config['code_only'], 'source' => @config['source'].gsub('_examples/', '') }
+              if @config['application']
+                parent_config = parent_config.merge({ 'application' => @config['application'] })
+              end
+
+              parent_config = parent_config.to_yaml.lines[1..-1].join
+
+              source = <<~HEREDOC
+                ```single_code_snippet
+                #{content.to_yaml}\n#{parent_config}
+                ```
+              HEREDOC
+
+              content[:body] = MarkdownPipeline.new(options).call(source)
+
+              content
+            end
+          end
+
+          def sort_contents(contents)
+            contents.sort_by do |content|
+              content['weight']
+            end
+          end
+
+          def resolve_active_tab(contents)
+            active_index = nil
+
+            if options[:code_language]
+              contents.each_with_index do |content, index|
+                active_index = index if content['language'] == options[:code_language].key
+              end
+            end
+
+            @tabs['data-has-initial-tab'] = active_index.present?
+            @tabs['class'] += ' skip-pushstate' if @tabs['data-has-initial-tab']
+            active_index ||= 0
+
+            contents[active_index][:active] = true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Collapsible < Banzai::Filter
+          def call(input)
+            input.gsub(/^\|\s(\#{1,6})(\s)?(.+?)\n^\|\n(.+?)\n\n/m) do |_s|
+              heading = $3
+              body = $4.gsub(/^\|\n/, "\n")
+              body = body.gsub(/^\|\s/, '')
+              parsed_body = MarkdownPipeline.new.call(body)
+
+              <<~HEREDOC
+                <div class="Vlt-accordion Vlt-box Vlt-box--lesspadding Nxd-accordion-emphasis">
+                  <h5 class="Vlt-accordion__trigger"  tabindex="0">#{heading}</h5>
+                  <div class="Vlt-accordion__content Vlt-accordion__content--noborder">
+                    #{parsed_body}
+                  </div>
+                </div>
+              HEREDOC
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Nexmo
+  module OAS
+    module Renderer
+      module Filters
+        class Columns < Banzai::Filter
+          def call(input)
+            input.gsub!(%r{{column\:([1-4])\/([1-4])}\n(.+?){end}}m) do
+              s = []
+              s << row_start if $1 == '1'
+              s << column_start($2)
+              s << $3
+              s << column_end
+              s << row_end if $1 == $2
+              s.join('')
+            end
+
+            input
+          end
+
+          private
+
+          def row_start
+            "FREEZESTART#{Base64.urlsafe_encode64('<div class="row">')}FREEZEEND\n"
+          end
+
+          def row_end
+            close_tag
+          end
+
+          def close_tag
+            "FREEZESTART#{Base64.urlsafe_encode64('</div>')}FREEZEEND"
+          end
+
+          def column_start(columns)
+            html = "<div class='column small-12 medium-#{part_size(columns)}'>"
+            "FREEZESTART#{Base64.urlsafe_encode64(html)}FREEZEEND\n"
+          end
+
+          def column_end
+            "FREEZESTART#{Base64.urlsafe_encode64('</div>')}FREEZEEND\n"
+          end
+
+          def part_size(columns)
+            12 / Integer(columns)
+          end
+        end
+      end
+    end
+  end
+end