nexmo_markdown_renderer 0.2.1 → 0.4.1

data/lib/nexmo_markdown_renderer/filters/utils.rb

@@ -0,0 +1,50 @@
+module Nexmo
+  module Markdown
+    class Utils
+      def self.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("#{Nexmo::Markdown::Config.docs_base_path}/#{code['source']}").lines.count}"
+          end
+        end
+
+        start_section + file_section + line_section
+      end
+
+      def self.generate_code_block(language, input, unindent)
+        return '' unless input
+        filename = "#{Nexmo::Markdown::Config.docs_base_path}/#{input['source']}"
+        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
+        formatter = Rouge::Formatters::HTML.new
+        formatter.format(lexer.lex(code))
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/models/code_language.rb

@@ -72,7 +72,7 @@ module Nexmo
       end
     
       private_class_method def self.config
-        @config ||= YAML.load_file('./config/code_languages.yml')
+        @config ||= YAML.load_file("#{Nexmo::Markdown::Config.docs_base_path}/config/code_languages.yml")
       end
     end    
   end

data/lib/nexmo_markdown_renderer/models/tutorial.rb

@@ -2,68 +2,109 @@ module Nexmo
   module Markdown
     class Tutorial
       include ActiveModel::Model
-      attr_accessor :raw, :name, :current_step, :current_product, :title, :description, :products, :subtasks, :prerequisites
+
+      attr_reader :name, :current_step
+      delegate :path, :yaml, to: :@file_loader
+      delegate :available_code_languages, to: :metadata
+
+      def initialize(name:, current_step:, current_product: nil, code_language: nil)
+        @name         = name
+        @current_step = current_step
+        @product      = current_product
+        @language     = code_language
+        @file_loader  = load_file!
+      end
+
+      def metadata
+        @metadata ||= Metadata.new(name: name)
+      end
+
+      def current_product
+        @current_product ||= @product || metadata.default_product
+      end
+
+      def code_language
+        @code_language ||= @language || metadata.code_language
+      end
+
+      def title
+        @title ||= yaml['title'] || metadata.title
+      end
+
+      def description
+        @description ||= yaml['description'] || metadata.description
+      end
+
+      def products
+        @products ||= yaml['products'] || metadata.products
+      end
+
+      def prerequisites
+        @prerequisites ||= (yaml['prerequisites'] || []).map do |prereq|
+          Prerequisite.new(name: prereq, code_language: code_language, current_step: current_step)
+        end
+      end
 
       def content_for(step_name)
         if ['introduction', 'conclusion'].include? step_name
-          raise "Invalid step: #{step_name}" unless raw[step_name]
+          raise "Invalid step: #{step_name}" unless yaml[step_name]
 
-          return raw[step_name]['content']
+          return yaml[step_name]['content']
         end
 
         path = Nexmo::Markdown::DocFinder.find(
           root: self.class.task_content_path,
           document: step_name,
-          language: ::I18n.locale
+          language: ::I18n.locale,
+          code_language: code_language
         ).path
 
         File.read(path)
       end
 
       def first_step
-        subtasks.first['path']
+        subtasks.first&.name
       end
 
       def prerequisite?
-        prerequisites.pluck('path').include?(@current_step)
+        prerequisites.map(&:name).include?(@current_step)
       end
 
       def next_step
-        current_task_index = subtasks.pluck('path').index(@current_step)
+        current_task_index = subtasks.map(&:name).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)
+        current_task_index = subtasks.map(&:name).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'
-        ).path
-        config = YAML.safe_load(File.read(document_path))
-        current_product ||= config['products'].first
-
-        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),
-        })
+      def subtasks
+        @subtasks ||= begin
+          tasks = []
+
+          (yaml['tasks'] || []).map do |t|
+            tasks.push(
+              Task.make_from(
+                name: t,
+                code_language: code_language,
+                current_step: current_step
+              )
+            )
+          end
+
+          tasks.unshift(prerequisite_task)
+          tasks.unshift(introduction_task)
+          tasks.push(conclusion_task)
+
+          tasks.compact
+        end
       end
 
       def self.load_prerequisites(prerequisites, current_step)
@@ -89,60 +130,63 @@ module Nexmo
         end
       end
 
-      def self.load_subtasks(introduction, prerequisites, tasks, conclusion, current_step)
-        tasks ||= []
+      def prerequisite_task
+        return if prerequisites.empty?
 
-        tasks = tasks.map do |t|
-          t_path = Nexmo::Markdown::DocFinder.find(
-            root: task_content_path,
-            document: t,
-            language: ::I18n.locale
-          ).path
-          raise "Subtask not found: #{t}" unless File.exist? t_path
+        Task.new(
+          name: 'prerequisites',
+          title: 'Prerequisites',
+          description: 'Everything you need to complete this task',
+          current_step: current_step
+        )
+      end
 
-          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
+      def introduction_task
+        return unless yaml['introduction']
 
-        if prerequisites
-          tasks.unshift({
-            'path' => 'prerequisites',
-            'title' => 'Prerequisites',
-            'description' => 'Everything you need to complete this task',
-            'is_active' => current_step == 'prerequisites',
-          })
-        end
+        Task.new(
+          name: 'introduction',
+          title: yaml['introduction']['title'],
+          description: yaml['introduction']['description'],
+          current_step: current_step
+        )
+      end
 
-        if introduction
-          tasks.unshift({
-            'path' => 'introduction',
-            'title' => introduction['title'],
-            'description' => introduction['description'],
-            'is_active' => current_step == 'introduction',
-          })
-        end
+      def conclusion_task
+        return unless yaml['conclusion']
 
-        if conclusion
-          tasks.push({
-            'path' => 'conclusion',
-            'title' => conclusion['title'],
-            'description' => conclusion['description'],
-            'is_active' => current_step == 'conclusion',
-          })
-        end
+        Task.new(
+          name: 'conclusion',
+          title: yaml['conclusion']['title'],
+          description: yaml['conclusion']['description'],
+          current_step: current_step
+        )
+      end
+
+      def self.load(name, current_step, current_product = nil, code_language = nil)
+        new(
+          name: name,
+          current_step: current_step,
+          current_product: current_product,
+          code_language: code_language
+        )
+      end
 
-        tasks
+      def load_file!
+        Tutorial::FileLoader.new(
+          root: self.class.tutorials_path,
+          code_language: code_language,
+          doc_name: name
+        )
       end
 
       def self.task_content_path
         "#{Nexmo::Markdown::Config.docs_base_path}/_tutorials"
       end
-    end
 
+      def self.tutorials_path
+        'config/tutorials'
+      end
+    end
   end
 end

data/lib/nexmo_markdown_renderer/models/tutorial/file_loader.rb

@@ -0,0 +1,32 @@
+module Nexmo
+  module Markdown
+    class Tutorial::FileLoader
+      attr_reader :root, :code_language, :doc_name, :format
+
+      def initialize(root:, code_language:, doc_name:, format: 'yml')
+        @root          = root
+        @code_language = code_language
+        @doc_name      = doc_name
+        @format        = format
+      end
+
+      def path
+        @path ||= Nexmo::Markdown::DocFinder.find(
+          root: root,
+          document: doc_name,
+          language: ::I18n.locale,
+          code_language: code_language,
+          format: format
+        ).path
+      end
+
+      def content
+        @content ||= File.read(path)
+      end
+
+      def yaml
+        @yaml ||= YAML.safe_load(content)
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/models/tutorial/metadata.rb

@@ -0,0 +1,57 @@
+module Nexmo
+  module Markdown
+    class Tutorial::Metadata
+      attr_reader :name, :file_loader
+      delegate :path, :yaml, to: :file_loader
+
+      def initialize(name:)
+        @name        = name
+        @file_loader = load_file!
+      end
+
+      def products
+        @products ||= yaml['products'] || []
+      end
+
+      def title
+        @title ||= yaml['title']
+      end
+
+      def description
+        @description ||= yaml['description']
+      end
+
+      def external_link
+        @external_link ||= yaml['external_link']
+      end
+
+      def available_code_languages
+        @available_code_languages ||= begin
+                                        DocFinder
+                                          .code_languages_for_tutorial(path: path.sub('.yml', '/'))
+                                          .map { |file_path| File.basename(Pathname.new(file_path).basename, '.yml') }
+                                          .sort_by { |l| CodeLanguage.find(l).weight }
+                                      end
+      end
+
+      def code_language
+        @code_language ||= begin
+                             available_code_languages
+                               .min_by { |k| CodeLanguage.languages.map(&:key).index(k) }
+                           end
+      end
+
+      def default_product
+        @default_product ||= products.first
+      end
+
+      def load_file!
+        Tutorial::FileLoader.new(
+          root: Tutorial.tutorials_path,
+          code_language: nil,
+          doc_name: @name
+        )
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/models/tutorial/prerequisite.rb

@@ -0,0 +1,35 @@
+module Nexmo
+  module Markdown
+    class Tutorial::Prerequisite
+      delegate :content, :yaml, to: :@file_loader
+
+      def initialize(current_step:, code_language:, name:)
+        @current_step  = current_step
+        @code_language = code_language
+        @name          = name
+        @file_loader   = load_file!
+      end
+
+      def title
+        @title ||= yaml['title']
+      end
+
+      def description
+        @description ||= yaml['description']
+      end
+
+      def active?
+        @name == @current_step
+      end
+
+      def load_file!
+        Tutorial::FileLoader.new(
+          root: Tutorial.task_content_path,
+          code_language: nil,
+          doc_name: @name,
+          format: 'md'
+        )
+      end
+    end
+  end
+end

data/lib/nexmo_markdown_renderer/models/tutorial/task.rb

@@ -0,0 +1,49 @@
+module Nexmo
+  module Markdown
+    class Tutorial::Task
+      attr_reader :name, :title, :description, :current_step
+
+      def initialize(name:, title:, description:, current_step:)
+        @name         = name
+        @title        = title
+        @description  = description
+        @current_step = current_step
+      end
+
+      def active?
+        @name == @current_step
+      end
+
+      def self.make_from(name:, code_language:, current_step:)
+        file_loader = Tutorial::FileLoader.new(
+          root: Tutorial.task_content_path,
+          doc_name: name,
+          code_language: code_language,
+          format: 'md'
+        )
+
+        new(
+          name: name,
+          title: file_loader.yaml['title'],
+          description: file_loader.yaml['description'],
+          current_step: current_step
+        )
+      end
+
+      def ==(other)
+        name == other.name &&
+          title == other.title &&
+          description == other.description &&
+          current_step == other.current_step
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        name.hash ^ title.hash ^ description.hash ^ current_step.hash
+      end
+    end
+  end
+end