nexmo_markdown_renderer 0.0.1

data/lib/nexmo_markdown_renderer/core_ext/html.rb

@@ -0,0 +1,7 @@
+require 'redcarpet'
+require 'rouge'
+require 'rouge/plugins/redcarpet'
+
+class HTML < Redcarpet::Render::HTML
+  include Rouge::Plugins::Redcarpet
+end

data/lib/nexmo_markdown_renderer/core_ext/string.rb

@@ -0,0 +1,14 @@
+class String
+  def render_markdown(options = {})
+    Nexmo::Markdown::Renderer.new(options).call(self).html_safe
+  end
+
+  def unindent
+    indent = squeeze("\n").lines.map { |line| line.index(/[^\s]/) }.compact.min || 0
+    gsub(/^[[:blank:]]{#{indent}}/, '')
+  end
+
+  def unindent!
+    replace(unindent)
+  end
+end

data/lib/nexmo_markdown_renderer/filters/anchor_filter.rb

@@ -0,0 +1,14 @@
+module Nexmo
+  module Markdown
+    class AnchorFilter < Banzai::Filter
+      def call(input)
+        input.gsub(/^[\u{2693}](.+?)\n/) do
+          <<~HEREDOC
+            <a name="#{$1.parameterize}"></a>
+          HEREDOC
+        end
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/filters/audio_filter.rb

@@ -0,0 +1,18 @@
+module Nexmo
+  module Markdown
+    class AudioFilter < Banzai::Filter
+      def call(input)
+        input.gsub(/[u{🔈}]\[(.+?)\]/) do
+          audio = <<~HEREDOC
+            <audio controls>
+              <source src="#{$1}" type="audio/mpeg">
+            </audio>
+          HEREDOC
+    
+          "FREEZESTART#{Base64.urlsafe_encode64(audio)}FREEZEEND"
+        end
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/filters/block_escape_filter.rb

@@ -0,0 +1,21 @@
+module Nexmo
+  module Markdown
+    class BlockEscapeFilter < Banzai::Filter
+      def call(input)
+        # Freeze to prevent Markdown formatting
+        input.gsub(/````\n(.+?)````/m) do |_s|
+          lexer = Rouge::Lexer.find('text')
+          formatter = Rouge::Formatters::HTML.new
+          highlighted_source = formatter.format(lexer.lex($1))
+    
+          output = <<~HEREDOC
+            <pre class="highlight #{lexer.tag}"><code>#{highlighted_source}</code></pre>
+          HEREDOC
+    
+          "FREEZESTART#{Base64.urlsafe_encode64(output)}FREEZEEND"
+        end
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/filters/break_filter.rb

@@ -0,0 +1,10 @@
+module Nexmo
+  module Markdown
+    class BreakFilter < Banzai::Filter
+      def call(input)
+        input.gsub('§', '<br>')
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/filters/code_filter.rb

@@ -0,0 +1,62 @@
+module Nexmo
+  module Markdown
+    class CodeFilter < Banzai::Filter
+      def call(input)
+        input.gsub(/(?!.*snippet)```code(.+?)```/m) do |_s|
+          config = YAML.safe_load($1)
+    
+          if config['config']
+            configs = YAML.load_file("#{ENV['DOCS_BASE_PATH']}/config/code_examples.yml")
+            config = config['config'].split('.').inject(configs) { |h, k| h[k] }
+          end
+    
+          code = File.read("#{ENV['DOCS_BASE_PATH']}/#{config['source']}")
+          language = File.extname("#{ENV['DOCS_BASE_PATH']}/#{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("#{GEM_ROOT}/config/code_languages.yml")
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/filters/code_snippet_filter.rb

@@ -0,0 +1,187 @@
+module Nexmo
+  module Markdown
+    class CodeSnippetFilter < 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 = 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
+    
+          prereqs = (application_html + dependency_html + client_html).strip
+          prereqs = "<h2>#{::I18n.t('.filters.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 = "#{ENV['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)
+      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
+      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)
+      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)
+      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
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/filters/code_snippet_list_filter.rb

@@ -0,0 +1,26 @@
+module Nexmo
+  module Markdown
+    class CodeSnippetListFilter < Banzai::Filter
+      def call(input)
+        input.gsub(/```code_snippet_list(.+?)```/m) do |_s|
+          config = YAML.safe_load($1)
+          @product = config['product']
+          @blocks = Nexmo::Markdown::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("#{GEM_ROOT}/lib/nexmo_markdown_renderer/views/code_snippets/list/plain.html.erb")
+          html = ERB.new(erb).result(binding)
+          "FREEZESTART#{Base64.urlsafe_encode64(html)}FREEZEEND"
+        end
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/filters/code_snippets_filter.rb

@@ -0,0 +1,170 @@
+module Nexmo
+  module Markdown
+    class CodeSnippetsFilter < 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
+    
+        generate_html_content(html)
+      end
+    
+      def generate_html_content(html)
+        @document = Nokogiri::HTML::DocumentFragment.parse(html)
+        @tabs = @document.at_css('.Vlt-tabs__header--bordered')
+        @tabs_content = @document.at_css('.Vlt-tabs__content')
+    
+        tab_maker
+    
+        source = @document.to_html
+    
+        "#{@indentation}FREEZESTART#{Base64.urlsafe_encode64(source)}FREEZEEND"
+      end
+    
+      def contents
+        list = content_from_source
+        list ||= []
+    
+        list = sort_contents(list)
+        resolve_active_tab(list)
+    
+        list
+      end
+    
+      def tab_maker
+        contents.each do |content|
+          create_tabs(content)
+          create_content(content)
+        end
+      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 = "#{ENV['DOCS_BASE_PATH']}/#{@config['source']}/*.yml"
+    
+        files = Dir[source_path]
+        raise "No .yml files found for #{@config['source']} code snippets" if files.empty?
+    
+        generate_content(files)
+      end
+    
+      def generate_content(files)
+        files.map do |content_path|
+          source = File.read(content_path)
+    
+          # Load the defaults for this language
+          filename = File.basename(content_path, '.yml')
+          defaults = Nexmo::Markdown::CodeLanguage.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 = render_single_snippet(content, parent_config)
+    
+          content[:body] = Nexmo::Markdown::Renderer.new(options).call(source)
+    
+          content
+        end
+      end
+    
+      def render_single_snippet(content, parent_config)
+        <<~HEREDOC
+          ```single_code_snippet
+          #{content.to_yaml}\n#{parent_config}
+          ```
+        HEREDOC
+      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