hs-cli 0.1.2

data/lib/hs/elements/table.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module HS
+  class Table < HS::Element
+    def tag_name
+      'table'
+    end
+  end
+
+  class Thead < HS::Element
+    def tag_name
+      'thead'
+    end
+  end
+
+  class Tbody < HS::Element
+    def tag_name
+      'tbody'
+    end
+  end
+
+  class Tr < HS::Element
+    def tag_name
+      'tr'
+    end
+  end
+
+  class Th < HS::Element
+    def tag_name
+      'th'
+    end
+  end
+
+  class Td < HS::Element
+    def tag_name
+      'td'
+    end
+  end
+end

data/lib/hs/elements/text.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'hs/preview/element_preview'
+
+module HS
+  class Text
+    include ElementPreview
+
+    attr_accessor :text
+
+    def initialize(args)
+      args.each do |key, val|
+        instance_variable_set("@#{key}", val)
+      end
+    end
+
+    def preview
+      text_preview(text)
+    end
+  end
+end

data/lib/hs/elements/ul.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module HS
+  class Ul < HS::Element
+    def tag_name
+      'ul'
+    end
+  end
+end

data/lib/hs/loaders/chapter_loader.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'hs/loaders/xml_parser'
+require 'hs/loaders/element_loader'
+
+module HS
+  module ChapterLoader
+    include HS::XMLParser
+    include HS::ElementLoader
+
+    def load_chapter(course, xml)
+      create_chapter(course, parse_xml(xml))
+    end
+
+    private
+
+    def create_chapter(course, data) # rubocop:disable Metrics/MethodLength
+      chapter = HS::Chapter.new(course, slug: data[:slug])
+
+      data[:_children].each do |child|
+        case child[:_name]
+        when :title
+          chapter.title = get_text(child)
+        when :intro
+          chapter.intro = load_element(child)
+        when :modules
+          # TODO: extract :modules
+          nil
+        else
+          element = load_element(child)
+          chapter.content << element if element
+        end
+      end
+
+      chapter
+    end
+  end
+end

data/lib/hs/loaders/course_loader.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'hs/loaders/xml_parser'
+
+module HS
+  module CourseLoader
+    include HS::XMLParser
+
+    def load_course(xml, &block)
+      create_course(parse_xml(xml), &block)
+    end
+
+    private
+
+    def create_course(data) # rubocop:disable Metrics/MethodLength
+      course = HS::Course.new(slug: data[:slug])
+
+      data[:_children].each do |child|
+        case child[:_name]
+        when :title
+          course.title = get_text(child)
+        when :chapters
+          if block_given?
+            files = child[:_children].map { |c| c[:file] }.compact
+
+            files.each do |file|
+              yield course, file
+            end
+          end
+        end
+      end
+
+      course
+    end
+  end
+end

data/lib/hs/loaders/element_loader.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module HS
+  module ElementLoader
+    def load_element(data)
+      name = data[:_name]
+      element = initialize_element(name, data)
+      children = load_elements(data[:_children])
+      children.each { |child| element.children << child }
+
+      element
+    end
+
+    def load_elements(data)
+      return [] unless data
+      data.map { |child_data| load_element(child_data) }
+    end
+
+    private
+
+    def get_params(data, names = %i[class_name style])
+      names.map do |name|
+        data[name] ? [name, data[name]] : nil
+      end.compact.to_h
+    end
+
+    def initialize_header(data)
+      HS::Header.new(get_params(data, %i[level class_name style]))
+    end
+
+    def initialize_element(name, data)
+      send("initialize_#{name}", data)
+    end
+
+    def initialize_text(data)
+      HS::Text.new(text: data[:text])
+    end
+
+    def initialize_p(data)
+      HS::Paragraph.new(get_params(data))
+    end
+
+    def initialize_note(data)
+      HS::Note.new(get_params(data))
+    end
+
+    def initialize_intro(data)
+      HS::Intro.new(get_params(data))
+    end
+
+    def initialize_em(data)
+      HS::Emphasize.new(get_params(data))
+    end
+
+    def initialize_link(data)
+      HS::Link.new(get_params(data, %i[to class_name style]))
+    end
+
+    def initialize_original(data)
+      HS::Original.new(get_params(data))
+    end
+
+    def initialize_strong(data)
+      HS::Strong.new(get_params(data))
+    end
+
+    def initialize_ul(data)
+      HS::Ul.new(get_params(data))
+    end
+
+    def initialize_ol(data)
+      HS::Ol.new(get_params(data))
+    end
+
+    def initialize_li(data)
+      HS::Li.new(get_params(data))
+    end
+
+    def initialize_image(data)
+      HS::Image.new(get_params(data, %i[src class_name style]))
+    end
+
+    def initialize_code(data)
+      HS::Code.new(get_params(data, %i[lang class_name style]))
+    end
+
+    def initialize_dd(data)
+      HS::Dd.new(get_params(data))
+    end
+
+    def initialize_dl(data)
+      HS::Dl.new(get_params(data))
+    end
+
+    def initialize_dt(data)
+      HS::Dt.new(get_params(data))
+    end
+
+    def initialize_table(data)
+      HS::Table.new(get_params(data))
+    end
+
+    def initialize_thead(data)
+      HS::Thead.new(get_params(data))
+    end
+
+    def initialize_tbody(data)
+      HS::Tbody.new(get_params(data))
+    end
+
+    def initialize_tr(data)
+      HS::Tr.new(get_params(data))
+    end
+
+    def initialize_th(data)
+      HS::Th.new(get_params(data))
+    end
+
+    def initialize_td(data)
+      HS::Td.new(get_params(data))
+    end
+
+    def initialize_br(_data)
+      HS::Br.new # no params!
+    end
+  end
+end

data/lib/hs/loaders/xml_parser.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'nokogiri'
+
+module HS
+  module XMLParser
+    def parse_xml(xml)
+      doc = Nokogiri::XML(xml) do |config|
+        config.options = Nokogiri::XML::ParseOptions::STRICT
+      end
+
+      to_object_notation(doc.root)
+    end
+
+    # Text content of the node.
+    # Note, that we don't go deep into element tree.
+    def get_text(object)
+      object[:_children].map { |obj| obj[:text] }.compact.join(' ')
+    end
+
+    private
+
+    def attributes_hash(xml)
+      xml.attributes.map do |key, attr|
+        [key.underscore.to_sym, attr.value]
+      end.to_h
+    end
+
+    def to_object_notation(xml)
+      class_name = xml.class.name.split('::').last.downcase
+      send("#{class_name}_to_object_notation", xml)
+    end
+
+    def element_to_object_notation(xml)
+      data = attributes_hash(xml)
+      data[:_name] = xml.name.underscore.to_sym
+      data[:_children] = to_object_notation(xml.children)
+
+      data
+    end
+
+    def cdata_to_object_notation(xml)
+      text_to_object_notation(xml)
+    end
+
+    def text_to_object_notation(xml)
+      {
+        _name: :text,
+        text: xml.text
+      }
+    end
+
+    def nodeset_to_object_notation(xml)
+      xml.map { |node| to_object_notation(node) }.compact
+    end
+
+    def comment_to_object_notation(_xml)
+      nil
+    end
+  end
+end

data/lib/hs/preview/chapter_preview.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'hs/preview/html_preview'
+
+module HS
+  module ChapterPreview
+    include HS::HTMLPreview
+
+    def preview
+      html_preview do
+        body_element
+      end
+    end
+
+    def toc_preview
+      "<li><a href=\"/#{slug}\">#{title.strip}</a></li>"
+    end
+
+    def save_preview
+      file = "#{HS::Config.preview_dir}/#{slug}.html"
+      File.open(file, 'w') { |f| f.write(preview) }
+    end
+
+    private
+
+    def body_element
+      [
+        '<body>',
+        title_preview,
+        intro_preview,
+        content_preview,
+        '</body>'
+      ]
+    end
+
+    def intro_preview
+      return unless intro
+      intro.preview
+    end
+
+    def title_preview
+      "<h1 class=\"title\">#{title.strip}</h1>"
+    end
+
+    def content_preview
+      content.map(&:preview).compact.join
+    end
+  end
+end

data/lib/hs/preview/course_preview.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'hs/preview/html_preview'
+
+module HS
+  module CoursePreview
+    include HS::HTMLPreview
+
+    def preview
+      html_preview do
+        body_element
+      end
+    end
+
+    def save_preview
+      file = "#{HS::Config.preview_dir}/index.html"
+      File.open(file, 'w') { |f| f.write(preview) }
+    end
+
+    private
+
+    def body_element
+      [
+        '<body>',
+        title_preview,
+        toc_preview,
+        '</body>'
+      ].join("\n")
+    end
+
+    def title_preview
+      "  <h1 class=\"title\">#{title.strip}</h1>"
+    end
+
+    def toc_preview
+      [
+        '  <ul>',
+        chapters.map(&:toc_preview).join("\n"),
+        '  </ul>'
+      ].join("\n")
+    end
+  end
+end

data/lib/hs/preview/element_preview.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module HS
+  module ElementPreview
+    def text_preview(text)
+      return unless text
+      CGI.escapeHTML(text)
+    end
+
+    def element_preview(tag_name, params, children)
+      [
+        element_start(tag_name, params, children),
+        element_content(children),
+        element_end(tag_name, children)
+      ].join
+    end
+
+    private
+
+    def element_start(tag, params, children)
+      start = "<#{tag}"
+
+      unless params.empty?
+        params_str = params.map { |k, v| "#{k}=\"#{v}\"" }.join(' ')
+        start = "#{start} #{params_str}"
+      end
+
+      return "#{start} />" if children.empty?
+      "#{start}>"
+    end
+
+    def element_content(children)
+      return if children.empty?
+      children.map(&:preview).compact.join
+    end
+
+    def element_end(tag, children)
+      return if children.empty?
+
+      "</#{tag}>"
+    end
+  end
+end

data/lib/hs/preview/html_preview.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module HS
+  module HTMLPreview
+    def html_preview
+      body = yield
+      [
+        '<html>',
+        head_element,
+        body,
+        '</html>'
+      ].compact.join("\n")
+    end
+
+    private
+
+    def head_element
+      [
+        '<head>',
+        '<meta charset="utf-8"/> ',
+        '<meta name="viewport" content="width=device-width, initial-scale=1"/>',
+        '<link rel="stylesheet" href="/default.css"/>',
+        '</head>'
+      ].join("\n")
+    end
+  end
+end

data/lib/hs/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HS
+  VERSION = '0.1.2'
+end

data/lib/hs.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'hs/version'
+require 'hs/config'
+
+require 'hs/course'
+require 'hs/chapter'
+
+require 'hs/elements/element'
+require 'hs/elements/br'
+require 'hs/elements/code'
+require 'hs/elements/dd'
+require 'hs/elements/dl'
+require 'hs/elements/dt'
+require 'hs/elements/emphasize'
+require 'hs/elements/header'
+require 'hs/elements/image'
+require 'hs/elements/intro'
+require 'hs/elements/li'
+require 'hs/elements/link'
+require 'hs/elements/note'
+require 'hs/elements/ol'
+require 'hs/elements/original'
+require 'hs/elements/paragraph'
+require 'hs/elements/strong'
+require 'hs/elements/table'
+require 'hs/elements/text'
+require 'hs/elements/ul'