nexmo_markdown_renderer 0.0.1

data/lib/nexmo_markdown_renderer/filters/tooltip_filter.rb

@@ -0,0 +1,18 @@
+module Nexmo
+  module Markdown
+    class TooltipFilter < 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="/symbol/volta-icons.svg#Vlt-icon-help-negative"/></svg>
+            </span>
+          HEREDOC
+    
+          "FREEZESTART#{Base64.urlsafe_encode64(tooltip)}FREEZEEND"
+        end
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/filters/unfreeze_filter.rb

@@ -0,0 +1,16 @@
+module Nexmo
+  module Markdown
+    class UnfreezeFilter < 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

data/lib/nexmo_markdown_renderer/filters/use_case_list_filter.rb

@@ -0,0 +1,20 @@
+module Nexmo
+  module Markdown
+    class UseCaseListFilter < Banzai::Filter
+      def call(input)
+        input.gsub(/```use_cases(.+?)```/m) do |_s|
+          config = YAML.safe_load($1)
+          @product = config['product']
+          @use_cases = Nexmo::Markdown::UseCase.by_product(@product)
+    
+          # Default to plain layout, but allow people to override it
+          config['layout'] = 'list/plain' unless config['layout']
+    
+          erb = File.read("#{GEM_ROOT}/lib/nexmo_markdown_renderer/views/use_case/#{config['layout']}.html.erb")
+          html = ERB.new(erb).result(binding)
+          "FREEZESTART#{Base64.urlsafe_encode64(html)}FREEZEEND"
+        end
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/initializers/doc_finder.rb

@@ -0,0 +1,5 @@
+Nexmo::Markdown::DocFinder.configure do |config|
+  config.paths << "#{ENV['DOCS_BASE_PATH']}/_documentation"
+  config.paths << "#{ENV['DOCS_BASE_PATH']}/_use_cases"
+  config.paths << "#{ENV['DOCS_BASE_PATH']}/_tutorials"
+end

data/lib/nexmo_markdown_renderer/initializers/i18n.rb

@@ -0,0 +1,4 @@
+require 'i18n'
+
+I18n.load_path += Dir[File.join("#{GEM_ROOT}/config/locales".freeze, '*.yml'.freeze)]
+I18n.default_locale = :en

data/lib/nexmo_markdown_renderer/initializers/redcarpet.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/markdown_renderer.rb

@@ -0,0 +1,47 @@
+module Nexmo
+  module Markdown
+    class Renderer < Banzai::Pipeline
+      def initialize(options = {})
+        super(
+          # As Markdown
+          FrontmatterFilter,
+          PhpInlinerFilter,
+          InlineEscapeFilter,
+          BlockEscapeFilter,
+          ScreenshotFilter,
+          AnchorFilter,
+          AudioFilter,
+          DynamicContentFilter,
+          TooltipFilter,
+          CollapsibleFilter,
+          TabFilter.new(options),
+          CodeSnippetsFilter.new(options),
+          CodeSnippetFilter.new(options),
+          CodeFilter,
+          IndentFilter,
+          ModalFilter,
+          JsSequenceDiagramFilter,
+          MermaidFilter,
+          PartialFilter.new(options),
+          TechioFilter,
+          UseCaseListFilter,
+          CodeSnippetListFilter,
+          ConceptListFilter.new(options),
+          LanguageFilter,
+          ColumnsFilter,
+          MarkdownFilter.new(options),
+    
+          # As HTML
+          HeadingFilter,
+          LabelFilter.new(options),
+          BreakFilter,
+          UnfreezeFilter,
+          IconFilter,
+          ExternalLinkFilter
+        )
+      end
+
+
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/models/code_language.rb

@@ -0,0 +1,79 @@
+module Nexmo
+  module Markdown
+    class CodeLanguage
+      include ActiveModel::Model
+      attr_accessor :key, :label, :type, :dependencies, :unindent, :icon, :run_command
+      attr_writer :weight, :linkable, :languages, :lexer
+    
+      def weight
+        @weight || 999
+      end
+    
+      def linkable?
+        return true if @linkable.nil?
+        @linkable
+      end
+    
+      def lexer
+        return Rouge::Lexers::PHP.new({ start_inline: true }) if @lexer == 'php'
+        Rouge::Lexer.find(@lexer) || Rouge::Lexer.find('text')
+      end
+    
+      def languages
+        @languages ||= []
+        @languages.map do |language|
+          self.class.find(language)
+        end
+      end
+    
+      def self.languages
+        where_type('languages')
+      end
+    
+      def self.frameworks
+        where_type('platforms')
+      end
+    
+      def self.terminal_programs
+        where_type('terminal_programs')
+      end
+    
+      def self.data
+        where_type('data')
+      end
+    
+      def self.all
+        languages + frameworks + terminal_programs + data
+      end
+    
+      def self.exists?(key)
+        all.detect { |lang| lang.key == key }
+      end
+    
+      def self.find(key)
+        raise 'Key is missing' unless key
+        code_language = all.detect { |lang| lang.key == key }
+        raise "Language #{key} does not exist." unless code_language
+        code_language
+      end
+    
+      def self.linkable
+        all.select(&:linkable?)
+      end
+    
+      def self.route_constraint
+        { code_language: Regexp.new(linkable.map(&:key).compact.join('|')) }
+      end
+    
+      private_class_method def self.where_type(type)
+        config[type].map do |key, attributes|
+          new(attributes.merge({ key: key, type: type }))
+        end
+      end
+    
+      private_class_method def self.config
+        @config ||= YAML.load_file('./config/code_languages.yml')
+      end
+    end    
+  end
+end

data/lib/nexmo_markdown_renderer/models/code_snippet.rb

@@ -0,0 +1,72 @@
+module Nexmo
+  module Markdown
+    class CodeSnippet
+      include ActiveModel::Model
+      attr_accessor :title, :product, :category, :navigation_weight, :document_path, :url
+    
+      def self.by_product(product)
+        all.select do |block|
+          block.product == product
+        end
+      end
+    
+      def self.all
+        blocks = files.map do |document_path|
+          document = File.read(document_path)
+          product = extract_product(document_path)
+    
+          frontmatter = YAML.safe_load(document)
+    
+          Nexmo::Markdown::CodeSnippet.new({
+            title: frontmatter['title'],
+            navigation_weight: frontmatter['navigation_weight'] || 999,
+            product: product,
+            document_path: document_path,
+            category: extract_category(document_path),
+            url: generate_url(document_path),
+          })
+        end
+    
+        blocks.sort_by(&:navigation_weight)
+      end
+    
+      def self.generate_url(path)
+        '/' + path.gsub(%r{#{origin}/\w{2}/}, '').gsub('.md', '')
+      end
+    
+      def self.extract_product(path)
+        # Remove the prefix
+        path = path.gsub!(%r{#{origin}/\w{2}/}, '')
+    
+        # Each file is in the form code-snippets/<title>.md, so let's remove everything after code-snippets
+        path = path.gsub(%r{/code-snippets/.*}, '')
+    
+        path
+      end
+    
+      def self.extract_category(path)
+        # Remove the prefix
+        path = path.gsub(%r{#{origin}/\w{2}/}, '')
+    
+        # Each file is in the form code-snippets/<title>.md, so let's capture everything after code-snippets
+        path = path.gsub(%r{.*/code-snippets/(.*)$}, '\1')
+    
+        parts = path.split('/')
+        parts = parts[0...-1]
+    
+        return nil if parts.empty?
+    
+        parts.join('/').tr('-', ' ').humanize
+      end
+    
+      def self.files
+        Dir.glob("#{origin}/**/code-snippets/**/*.md")
+      end
+    
+      def self.origin
+        "#{ENV['DOCS_BASE_PATH']}/_documentation"
+      end
+    end
+    
+  end
+end

data/lib/nexmo_markdown_renderer/models/concept.rb

@@ -0,0 +1,83 @@
+module Nexmo
+  module Markdown
+    class Concept
+      include ActiveModel::Model
+    
+      ORIGIN = "#{ENV['DOCS_BASE_PATH']}/_documentation".freeze
+    
+      FILES = [
+        Dir.glob("#{ORIGIN}/#{::I18n.default_locale}/**/guides/**/*.md"),
+        Dir.glob("#{ORIGIN}/#{::I18n.default_locale}/**/concepts/**/*.md"),
+      ].flatten
+    
+      attr_accessor :title, :product, :description, :navigation_weight, :document_path, :url, :ignore_in_list
+    
+      def self.by_name(names, language)
+        matches = all(language).select do |block|
+          concept = "#{block.product}/#{block.filename}"
+          match = names.include?(concept)
+          names.delete(concept) if match
+          match
+        end
+    
+        raise "Could not find concepts: #{names.join(', ')}" unless names.empty?
+        matches
+      end
+    
+      def self.by_product(product, language)
+        all(language).select do |block|
+          block.product == product
+        end
+      end
+    
+      def filename
+        Pathname(document_path).basename.to_s.gsub('.md', '')
+      end
+    
+      def self.all(language)
+        blocks = files(language).map do |document_path|
+          document = File.read(document_path)
+          product = extract_product(document_path)
+    
+          frontmatter = YAML.safe_load(document)
+    
+          Nexmo::Markdown::Concept.new({
+            title: frontmatter['title'],
+            description: frontmatter['description'],
+            navigation_weight: frontmatter['navigation_weight'] || 999,
+            ignore_in_list: frontmatter['ignore_in_list'],
+            product: product,
+            document_path: document_path,
+            url: generate_url(document_path, language),
+          })
+        end
+    
+        blocks.sort_by(&:navigation_weight)
+      end
+    
+      def self.generate_url(path, language)
+        '/' + path.gsub("#{ORIGIN}/#{language}/", '').gsub('.md', '')
+      end
+    
+      def self.extract_product(path)
+        # Remove the prefix
+        path = path.gsub!(%r{#{ORIGIN}\/[a-z]{2}\/}, '')
+    
+        # Each file is in the form guides/<title>.md, so let's remove the last two segments
+        parts = path.split('/')
+        parts = parts[0...-2]
+    
+        # What's left once we remove the start and end of the path is our product name. This could be any number
+        # of parts, but it's generally 1-2
+        parts.join('/')
+      end
+    
+      def self.files(language)
+        FILES.each_with_object([]) do |file, array|
+          document = file.gsub("#{ORIGIN}/#{::I18n.default_locale}/", '')
+          array << Nexmo::Markdown::DocFinder.find(root: ORIGIN, document: document, language: language)
+        end
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/models/tutorial.rb

@@ -0,0 +1,148 @@
+module Nexmo
+  module Markdown
+    class Tutorial
+      include ActiveModel::Model
+      attr_accessor :raw, :name, :current_step, :current_product, :title, :description, :products, :subtasks, :prerequisites
+    
+      def content_for(step_name)
+        if ['introduction', 'conclusion'].include? step_name
+          raise "Invalid step: #{step_name}" unless raw[step_name]
+    
+          return raw[step_name]['content']
+        end
+    
+        path = Nexmo::Markdown::DocFinder.find(
+          root: self.class.task_content_path,
+          document: step_name,
+          language: ::I18n.locale
+        )
+    
+        File.read(path)
+      end
+    
+      def first_step
+        subtasks.first['path']
+      end
+    
+      def prerequisite?
+        prerequisites.pluck('path').include?(@current_step)
+      end
+    
+      def next_step
+        current_task_index = subtasks.pluck('path').index(@current_step)
+        return nil unless current_task_index
+    
+        subtasks[current_task_index + 1]
+      end
+    
+      def previous_step
+        current_task_index = subtasks.pluck('path').index(@current_step)
+        return nil unless current_task_index
+        return nil if current_task_index <= 0
+    
+        subtasks[current_task_index - 1]
+      end
+    
+      def self.load(name, current_step, current_product = nil)
+        document_path = Nexmo::Markdown::DocFinder.find(
+          root: 'config/tutorials',
+          document: name,
+          language: ::I18n.default_locale,
+          format: 'yml'
+        )
+        config = YAML.safe_load(File.read(document_path))
+        current_product ||= config['products'].first
+    
+        Nexmo::Markdown::Tutorial.new({
+          raw: config,
+          name: name,
+          current_step: current_step,
+          current_product: current_product,
+          title: config['title'],
+          description: config['description'],
+          products: config['products'],
+          prerequisites: load_prerequisites(config['prerequisites'], current_step),
+          subtasks: load_subtasks(config['introduction'], config['prerequisites'], config['tasks'], config['conclusion'], current_step),
+        })
+      end
+    
+      def self.load_prerequisites(prerequisites, current_step)
+        return [] unless prerequisites
+    
+        prerequisites.map do |t|
+          t_path = Nexmo::Markdown::DocFinder.find(
+            root: task_content_path,
+            document: t,
+            language: ::I18n.locale
+          )
+          raise "Prerequisite not found: #{t}" unless File.exist? t_path
+    
+          content = File.read(t_path)
+          prereq = YAML.safe_load(content)
+          {
+            'path' => t,
+            'title' => prereq['title'],
+            'description' => prereq['description'],
+            'is_active' => t == current_step,
+            'content' => content,
+          }
+        end
+      end
+    
+      def self.load_subtasks(introduction, prerequisites, tasks, conclusion, current_step)
+        tasks ||= []
+    
+        tasks = tasks.map do |t|
+          t_path = Nexmo::Markdown::DocFinder.find(
+            root: task_content_path,
+            document: t,
+            language: ::I18n.locale
+          )
+          raise "Subtask not found: #{t}" unless File.exist? t_path
+    
+          subtask_config = YAML.safe_load(File.read(t_path))
+          {
+            'path' => t,
+            'title' => subtask_config['title'],
+            'description' => subtask_config['description'],
+            'is_active' => t == current_step,
+          }
+        end
+    
+        if prerequisites
+          tasks.unshift({
+            'path' => 'prerequisites',
+            'title' => 'Prerequisites',
+            'description' => 'Everything you need to complete this task',
+            'is_active' => current_step == 'prerequisites',
+          })
+        end
+    
+        if introduction
+          tasks.unshift({
+            'path' => 'introduction',
+            'title' => introduction['title'],
+            'description' => introduction['description'],
+            'is_active' => current_step == 'introduction',
+          })
+        end
+    
+        if conclusion
+          tasks.push({
+            'path' => 'conclusion',
+            'title' => conclusion['title'],
+            'description' => conclusion['description'],
+            'is_active' => current_step == 'conclusion',
+          })
+        end
+    
+        tasks
+      end
+    
+      def self.task_content_path
+        "#{ENV['DOCS_BASE_PATH']}/_tutorials"
+      end
+    end
+    
+  end
+end