nexmo-oas-renderer 0.7.1 → 0.8.0

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

@@ -1,13 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

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

@@ -1,194 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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