nexmo_markdown_renderer 0.2.1 → 0.4.1

data/lib/nexmo_markdown_renderer/filters/code_snippet/run.rb

@@ -0,0 +1,29 @@
+module Nexmo
+  module Markdown
+    module Filters
+      module CodeSnippet
+        class Run
+          include OcticonsHelper
+          include Renderable
+
+          def initialize(config, snippet)
+            @config  = config
+            @snippet = snippet
+          end
+
+          def run_command
+            @run_command ||= begin
+              if @config['run_command']
+                @config['run_command'].gsub('{filename}', file_name)
+              end
+            end
+          end
+
+          def render
+            renderer.run_command(run_command, file_name, @config['code']['source']).to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/filters/code_snippet_filter.rb

@@ -5,183 +5,46 @@ module Nexmo
 
       def call(input)
         input.gsub(/```single_code_snippet(.+?)```/m) do |_s|
-          config = YAML.safe_load($1)
+          @config = YAML.safe_load($1)
+          @binding = ::Nexmo::Markdown::Filters::CodeSnippet::Binding.new(@config)
 
-          @renderer = get_renderer(config['language'])
+          return instructions if @config['code_only']
 
-          lexer = Nexmo::Markdown::CodeLanguage.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("#{GEM_ROOT}/lib/nexmo_markdown_renderer/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("#{GEM_ROOT}/lib/nexmo_markdown_renderer/views/code_snippets/_code_only.html.erb")
-          else
-            erb = File.read("#{GEM_ROOT}/lib/nexmo_markdown_renderer/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
+          "#{prerequisites}#{instructions}#{run}"
+        end
+      end
 
-          prereqs = (application_html + dependency_html + client_html).strip
+      def prerequisites
+        @prerequisites ||= begin
+          prereqs = [application_html, install_dependencies, import_dependencies, initialize_dependencies].join.strip
           prereqs = "<h2>#{::I18n.t('.filters.prerequisites')}</h2>#{prereqs}" unless prereqs.empty?
-          prereqs + code_html + run_html
+          prereqs
         end
       end
 
-      private
-
-      def highlight(source, lexer)
-        formatter = Rouge::Formatters::HTML.new
-        formatter.format(lexer.lex(source))
+      def application_html
+        @application_html ||= ::Nexmo::Markdown::Filters::CodeSnippet::CreateApplication.new(@config['application']).render
       end
 
-      def generate_code_block(language, input, unindent)
-        filename = "#{Nexmo::Markdown::Config.docs_base_path}/#{input['source']}"
-        return '' unless input
-        raise "CodeSnippetFilter - Could not load #{filename} for language #{language}" unless File.exist?(filename)
-
-        code = File.read(filename)
-        lexer = Nexmo::Markdown::CodeLanguage.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)
+      def install_dependencies
+        @install_dependencies ||= ::Nexmo::Markdown::Filters::CodeSnippet::InstallDependencies.new(@config['dependencies'], @binding).render
       end
 
-      def get_renderer(language)
-        language = 'dotnet' if language == 'csharp'
-        case language
-        when 'curl'
-          Nexmo::Markdown::CodeSnippetRenderer::Curl
-        when 'node'
-          Nexmo::Markdown::CodeSnippetRenderer::Javascript
-        when 'javascript'
-          Nexmo::Markdown::CodeSnippetRenderer::Javascript
-        when 'java'
-          Nexmo::Markdown::CodeSnippetRenderer::Java
-        when 'dotnet'
-          Nexmo::Markdown::CodeSnippetRenderer::Dotnet
-        when 'python'
-          Nexmo::Markdown::CodeSnippetRenderer::Python
-        when 'ruby'
-          Nexmo::Markdown::CodeSnippetRenderer::Ruby
-        when 'php'
-          Nexmo::Markdown::CodeSnippetRenderer::Php
-        when 'android'
-          Nexmo::Markdown::CodeSnippetRenderer::Android
-        when 'kotlin'
-          Nexmo::Markdown::CodeSnippetRenderer::Kotlin
-        when 'objective_c'
-          Nexmo::Markdown::CodeSnippetRenderer::ObjectiveC
-        when 'swift'
-          Nexmo::Markdown::CodeSnippetRenderer::Swift
-        else
-          raise "Unknown language: #{language}"
-        end
+      def import_dependencies
+        @import_dependencies ||= ::Nexmo::Markdown::Filters::CodeSnippet::ImportDependencies.new(@config['import_dependencies'], @binding).render
       end
 
-      def generate_dependencies(language, dependencies)
-        # The only valid dependency for curl examples is `JWT`
-        if dependencies.map(&:upcase).include?('JWT')
-          title = ::I18n.t('filters.generate_your_jwt')
-        else
-          title = ::I18n.t('filters.install_dependencies')
-        end
-        deps = @renderer.dependencies(dependencies)
-        id = SecureRandom.hex
-        erb = File.read("#{GEM_ROOT}/lib/nexmo_markdown_renderer/views/code_snippets/_dependencies.html.erb")
-        ERB.new(erb).result(binding)
+      def initialize_dependencies
+        @initialize_dependencies ||= ::Nexmo::Markdown::Filters::CodeSnippet::InitializeDependencies.new(@config['client'], @binding).render
       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("#{GEM_ROOT}/lib/nexmo_markdown_renderer/views/code_snippets/_application_#{app['type']}.html.erb")
-        elsif ['messages', 'dispatch'].include? app['type']
-          erb = File.read("#{GEM_ROOT}/lib/nexmo_markdown_renderer/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)
+      def instructions
+        @instructions ||= ::Nexmo::Markdown::Filters::CodeSnippet::Instructions.new(@config, @binding).render
       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"
-        repo_path = '\\0blob/master/'
-        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
+      def run
+        @run ||= ::Nexmo::Markdown::Filters::CodeSnippet::Run.new(@config, @binding).render
       end
     end
-
   end
 end

data/lib/nexmo_markdown_renderer/filters/concerns/prism_code_snippet.rb

@@ -0,0 +1,22 @@
+module Nexmo
+  module Markdown
+    module Concerns
+      module PrismCodeSnippet
+        def code_snippet_body(lexer, body)
+          <<~HEREDOC
+            <pre class="#{prism_css_classes(lexer)}"><code>#{body}</code></pre>
+          HEREDOC
+        end
+
+        def code_language_to_prism(code_language)
+          code_language == 'objective_c' && 'objectivec' || code_language
+        end
+
+        def prism_css_classes(lexer)
+          code_language = code_language_to_prism(lexer.tag)
+          "main-code Vlt-prism--dark language-#{code_language} Vlt-prism--copy-disabled"
+        end
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/filters/markdown_filter.rb

@@ -1,16 +1,17 @@
 module Nexmo
   module Markdown
     class MarkdownFilter < Banzai::Filter
+
       def call(input)
         markdown.render(input)
       end
-    
+
       private
-    
+
       def renderer
         @renderer ||= VoltaRender.new(options)
       end
-    
+
       def markdown
         @markdown ||= Redcarpet::Markdown.new(renderer, {
           no_intra_emphasis: true,
@@ -27,17 +28,19 @@ module Nexmo
     end
 
     class VoltaRender < HTML
+      include Nexmo::Markdown::Concerns::PrismCodeSnippet
+
       def initialize(options)
         @options = options
         super(options)
       end
-    
+
       def paragraph(text)
         return text if @options[:skip_paragraph_surround]
-    
+
         "<p>#{text}</p>"
       end
-    
+
       def table(header, body)
         '<div class="Vlt-table Vlt-table--bordered">' \
         '<table>' \
@@ -46,7 +49,7 @@ module Nexmo
         '</table>' \
         '</div>'
       end
-    
+
       def block_quote(quote)
         '<div class="Vlt-callout Vlt-callout--tip">' \
           '<i></i>' \
@@ -55,7 +58,7 @@ module Nexmo
           '</div>' \
         '</div>'
       end
-    
+
       def image(link, _title, _alt_text)
         '<figure>' \
           '<img src="'\
@@ -63,7 +66,7 @@ module Nexmo
           '" alt="#{alt_text}">' \
         '</figure>'
       end
-    
+
       def list(contents, list_type)
         if "#{list_type}" == 'unordered'
           '<ul class="Vlt-list Vlt-list--simple">' \
@@ -86,7 +89,7 @@ module Nexmo
           code.gsub! /^    /, "\t"
         end
 
-        formatter = ::Rouge::Formatters::HTMLLegacy.new(:css_class => "Vlt-prism--dark language-#{lexer.tag} Vlt-prism--copy-disabled")
+        formatter = ::Rouge::Formatters::HTMLLegacy.new(:css_class => prism_css_classes(lexer))
         formatter.format(lexer.lex(code))
       end
     end

data/lib/nexmo_markdown_renderer/filters/partial_filter.rb

@@ -5,7 +5,7 @@ module Nexmo
         input.gsub(/```partial(.+?)```/m) do |_s|
           config = YAML.safe_load($1)
           file_path = if config['source'].starts_with? 'app/views'
-                        config['source']
+                        "#{Rails.root}/#{config['source']}"
                       else
                         "#{Nexmo::Markdown::Config.docs_base_path}/#{config['source']}"
                       end

data/lib/nexmo_markdown_renderer/filters/screenshot_filter.rb

@@ -4,7 +4,7 @@ module Nexmo
       def call(input)
         input.gsub(/```screenshot(.+?)```/m) do |_s|
           config = YAML.safe_load($1)
-          if config['image'] && File.file?(config['image'])
+          if config['image'] && File.file?("#{Nexmo::Markdown::Config.docs_base_path}/#{config['image']}")
             "![Screenshot](#{config['image'].gsub('public', '')})"
           else
             <<~HEREDOC

data/lib/nexmo_markdown_renderer/filters/tab_filter.rb

@@ -1,16 +1,18 @@
 module Nexmo
   module Markdown
     class TabFilter < Banzai::Filter
+      include Nexmo::Markdown::Concerns::PrismCodeSnippet
+
       def call(input)
         input.gsub(/^(\s*)```tabbed_(examples|content|folder)(.+?)```/m) do |_s|
           @indentation = $1
           @mode = $2
           @config = YAML.safe_load($3)
-    
+
           if tabbed_folder?
-            raise "#{@config['source']} is not a directory" unless File.directory? "#{Nexmo::Markdown::Config.docs_base_path}/#{@config['source']}"
-    
-            @tabbed_config = YAML.safe_load(File.read("#{Nexmo::Markdown::Config.docs_base_path}/#{@config['source']}/.config.yml"))
+            raise "#{@config['source']} is not a directory" unless File.directory? "#{@config['source']}"
+
+            @tabbed_config = YAML.safe_load(File.read("#{@config['source']}/.config.yml"))
             @path = @config['source']
             validate_folder_config
           else
@@ -19,28 +21,28 @@ module Nexmo
           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]
         tab['role'] = 'tab'
-    
+
         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
@@ -48,6 +50,8 @@ module Nexmo
             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>'
+          elsif content[:language].key == 'kotlin'
+            tab_link.inner_html = "<img class=\"Vlt-icon Vlt-icon--small\" src=\"/assets/images/brands/kotlin.svg#kotlin\" /><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
@@ -56,37 +60,37 @@ module Nexmo
         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 tabbed_folder?
         @mode == 'folder'
       end
-    
+
       def html
         html = <<~HEREDOC
           <div class="Vlt-tabs">
@@ -95,97 +99,97 @@ module Nexmo
               </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_folder if tabbed_folder?
         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 validate_folder_config
         return if @tabbed_config && @tabbed_config['tabbed'] == true
-    
+
         raise 'Tabbed must be set to true in the folder config YAML file'
       end
-    
+
       def content_from_source
         source_path = "#{Nexmo::Markdown::Config.docs_base_path}/#{@config['source']}"
         source_path += '/*' if tabbed_code_examples?
         source_path += '/*.md' if tabbed_content?
-    
+
         files = Dir.glob(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)
-    
+
           next generate_tabbed_code_examples(source, content_path) if tabbed_code_examples?
-    
+
           generate_tabbed_content(source) if tabbed_content?
         end
       end
-    
+
       def content_from_folder
-        source_path = "#{Nexmo::Markdown::Config.docs_base_path}/#{@config['source']}"
+        source_path = "#{@config['source']}"
         source_path += '/*.md'
-    
+
         files = Dir.glob(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)
-    
+
           generate_tabbed_content(source)
         end
       end
-    
+
       def content_from_tabs
         @config['tabs'].map do |title, config|
           raise "Could not find content_from_tabs file: #{Nexmo::Markdown::Config.docs_base_path}/#{@config['source']}" unless File.exist? "#{Nexmo::Markdown::Config.docs_base_path}/#{@config['source']}"
-    
+
           source = File.read("#{Nexmo::Markdown::Config.docs_base_path}/#{@config['source']}")
-    
+
           config.symbolize_keys.merge({
             id: SecureRandom.hex,
             source: source,
@@ -193,22 +197,22 @@ module Nexmo
           })
         end
       end
-    
+
       def generate_tabbed_content(source)
         content = {
           id: SecureRandom.hex,
           source: source,
         }
-    
+
         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] = Nexmo::Markdown::Renderer.new(options).call(source)
-    
+
         content
       end
-    
+
       def generate_tabbed_code_examples(source, content_path)
         content = {
           id: SecureRandom.hex,
@@ -216,24 +220,24 @@ module Nexmo
         }
         language_key = File.basename(content_path, '.*').downcase
         content[:language_key] = language_key
-    
+
         content
       end
-    
+
       def resolve_language(contents)
         contents.map do |content|
           if content[:language_key]
             content[:language] = CodeLanguage.find(content[:language_key])
           end
-    
+
           if content[:platform_key]
             content[:platform] = CodeLanguage.find(content[:platform_key])
           end
-    
+
           content
         end
       end
-    
+
       def format_code(contents)
         contents.each do |content|
           if content[:from_line] || content[:to_line]
@@ -243,43 +247,42 @@ module Nexmo
             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="Vlt-prism--dark language-#{lexer.tag} Vlt-prism--copy-disabled"><code>#{highlighted_source}</code></pre>
-          HEREDOC
-    
+
+          body = code_snippet_body(lexer, highlighted_source)
+
           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|
@@ -287,10 +290,10 @@ module Nexmo
             end
           end
         end
-    
+
         @tabs['data-has-initial-tab'] = active_index.present?
         active_index ||= 0
-    
+
         contents[active_index][:active] = true
       end
     end