nexmo_markdown_renderer 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61beb60888700c64e9a5840c98ebc4d7ce06de47e5f1d8385c6a85f675d2d5f6
-  data.tar.gz: bc5037d6894fb0b33c8aa56d0a4325d954757d925775133bab16dde6ac0f044f
+  metadata.gz: fe1875b3974959e1290b19d8e480b455fa5259b78567b607a4b66b86634ccfad
+  data.tar.gz: 9e33c425c055ef2b52ac3e9abf70c596bcf86ad92f0f8ea4f69ea7732f3001ed
 SHA512:
-  metadata.gz: 43a9a7d862fe6d7bb7aef8c2b2b77c863f5bfd985f8c8ab80954a12c7cfcb8a490dccc69baecfd55593c7ca80887f2a5d345482e29edc0067192b8b55c6243b9
-  data.tar.gz: 3b8e9f3becb2f3ffe7d54a48f7400df6f48efd85a1da6578d130051de18962b3a4aba3d3f0210f9fc693e9970adf298461a72e69e5eecac7748e752634bb72e8
+  metadata.gz: 25002e68f5f4db9e9de3d9360a82b3d93c4de70e56a00bdffa6e09ed89a0967a115c50f5b13cd875cfc386c66bbc359b15d5d191619be4f0f3420d250c04786c
+  data.tar.gz: c2b6fc824c865d72f523e50a56b74647393bb8fb98fe9e63f96d48435867511eeb141f6d856ac47c6eae2d8661fdbbeb5d53d557dab5307c5a5525da775291b2

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

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/use_case.rb

@@ -20,23 +20,12 @@ module Nexmo
 
       def subtitle
         normalized_products = products.map do |product|
-          normalise_product_title(product)
+          Product.normalize_title(product)
         end
 
         normalized_products.sort.to_sentence
       end
 
-      def normalise_product_title(product)
-        return 'SMS' if product == 'messaging/sms'
-        return 'Voice' if product == 'voice/voice-api'
-        return 'Number Insight' if product == 'number-insight'
-        return 'Messages' if product == 'messages'
-        return 'Dispatch' if product == 'dispatch'
-        return 'Client SDK' if product == 'client-sdk'
-        return 'Subaccounts' if product == 'account/subaccounts'
-        product.camelcase
-      end
-
       def self.by_product(product, use_cases = [])
         use_cases = all if use_cases.empty?
         use_cases.select do |use_case|
@@ -63,7 +52,7 @@ module Nexmo
           document = File.read(document_path)
           frontmatter = YAML.safe_load(document)
 
-          Nexmo::Markdown::UseCase.new({
+          new({
             title: frontmatter['title'],
             description: frontmatter['description'],
             external_link: frontmatter['external_link'],
@@ -75,8 +64,6 @@ module Nexmo
         end
       end
 
-      private
-
       private_class_method def self.files
         Dir.glob("#{origin}/**/*.md")
       end

data/lib/nexmo_markdown_renderer/services/doc_finder.rb

@@ -120,6 +120,11 @@ module Nexmo
       def self.strip_root_and_language(root:, language:, document:)
         document.sub(%r{#{root}\/}, '').sub(%r{#{language}\/}, '')
       end
+
+      def self.code_languages_for_tutorial(path:)
+        key = strip_root_and_language(root: '/', document: path, language: ::I18n.default_locale)
+        dictionary.keys.select { |k| k.include?(key) }
+      end
     end
   end
 end

data/lib/nexmo_markdown_renderer.rb

@@ -6,10 +6,12 @@ require 'nokogiri'
 require 'open-uri'
 require 'active_model'
 require 'i18n'
+
 require_relative 'nexmo_markdown_renderer/config/load_config'
 require_relative 'nexmo_markdown_renderer/initializers/redcarpet'
 require_relative 'nexmo_markdown_renderer/initializers/i18n'
 require_relative 'nexmo_markdown_renderer/core_ext/string'
+
 require_relative 'nexmo_markdown_renderer/services/code_snippet_renderer/base'
 require_relative 'nexmo_markdown_renderer/services/code_snippet_renderer/android'
 require_relative 'nexmo_markdown_renderer/services/code_snippet_renderer/curl'
@@ -22,9 +24,20 @@ require_relative 'nexmo_markdown_renderer/services/code_snippet_renderer/php'
 require_relative 'nexmo_markdown_renderer/services/code_snippet_renderer/python'
 require_relative 'nexmo_markdown_renderer/services/code_snippet_renderer/ruby'
 require_relative 'nexmo_markdown_renderer/services/code_snippet_renderer/swift'
+
 require_relative 'nexmo_markdown_renderer/services/doc_finder'
 require_relative 'nexmo_markdown_renderer/services/doc_finder/doc'
-Dir[File.join(__dir__, 'nexmo_markdown_renderer/models', '*.rb')].each { |file| require_relative file }
+
+require_relative 'nexmo_markdown_renderer/models/code_language'
+require_relative 'nexmo_markdown_renderer/models/code_snippet'
+require_relative 'nexmo_markdown_renderer/models/concept'
+require_relative 'nexmo_markdown_renderer/models/tutorial'
+require_relative 'nexmo_markdown_renderer/models/tutorial/file_loader'
+require_relative 'nexmo_markdown_renderer/models/tutorial/metadata'
+require_relative 'nexmo_markdown_renderer/models/tutorial/prerequisite'
+require_relative 'nexmo_markdown_renderer/models/tutorial/task'
+require_relative 'nexmo_markdown_renderer/models/use_case'
+
 Dir[File.join(__dir__, 'nexmo_markdown_renderer/filters', '*.rb')].each { |file| require_relative file }
 Dir[File.join(__dir__, 'nexmo_markdown_renderer/filters/i18n', '*.rb')].each { |file| require_relative file }
 require_relative 'nexmo_markdown_renderer/markdown_renderer'

data/lib/version.rb

@@ -1,7 +1,7 @@
 # :nocov:
 module Nexmo
   module Markdown
-    VERSION = '0.2.2'
+    VERSION = '0.3.0'
   end
 end
 # :nocov:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexmo_markdown_renderer
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Nexmo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-06 00:00:00.000000000 Z
+date: 2020-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: banzai
@@ -278,6 +278,10 @@ files:
 - lib/nexmo_markdown_renderer/models/code_snippet.rb
 - lib/nexmo_markdown_renderer/models/concept.rb
 - lib/nexmo_markdown_renderer/models/tutorial.rb
+- lib/nexmo_markdown_renderer/models/tutorial/file_loader.rb
+- lib/nexmo_markdown_renderer/models/tutorial/metadata.rb
+- lib/nexmo_markdown_renderer/models/tutorial/prerequisite.rb
+- lib/nexmo_markdown_renderer/models/tutorial/task.rb
 - lib/nexmo_markdown_renderer/models/use_case.rb
 - lib/nexmo_markdown_renderer/services/code_snippet_renderer/android.rb
 - lib/nexmo_markdown_renderer/services/code_snippet_renderer/base.rb