lcms-engine 0.1.0

data/lib/doc_template/tags/page_break_tag.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class PageBreakTag < BaseTag
+      CSS_CLASS = 'u-pdf-alwaysbreak'
+      TAG_NAME = /page(-|\s*)break/
+      TAG_SUB = '<p>--GDOC-PAGE-BREAK--</p>'
+
+      def parse(node, opts)
+        check_tag_soft_return(node)
+        @content = if gdoc?(opts)
+                     TAG_SUB
+                   else
+                     %(<div class="#{CSS_CLASS} do-not-strip"></div>)
+                   end
+        replace_tag node
+        self
+      end
+    end
+  end
+
+  Template.register_tag(Tags::PageBreakTag::TAG_NAME, Tags::PageBreakTag)
+end

data/lib/doc_template/tags/pd_tag.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class PdTag < BaseTag
+      include Rails.application.routes.url_helpers
+
+      CG_RE = %r{/content_guides/(\d+)/}i
+      PDF_HTTP_RE = %r{^https?://}i
+      PDF_HTTP_REPLACE_RE = /^http:/i
+      PDF_RE = /\.pdf$/i
+      TAG_NAME = 'pd'
+      TEMPLATES = {
+        default: 'pd.html.erb',
+        gdoc: 'gdoc/pd.html.erb'
+      }.freeze
+      TYPE_CG = 'cg'
+      TYPE_PDF = 'pdf'
+      TYPE_PODCAST = 'podcast'
+      TYPE_YOUTUBE = 'youtube'
+
+      def parse(node, opts = {})
+        @opts = opts
+        @url, @title, @description, @start, @stop = opts[:value].split(';').map(&:strip)
+
+        unless (embeded = fetch_data)
+          node.remove
+          return self
+        end
+
+        params = {
+          description: description,
+          resource: resource,
+          start: start,
+          stop: stop,
+          subject: subject,
+          title: title
+        }.merge(embeded)
+        @content = parse_template params, template_name(opts)
+        replace_tag node
+        self
+      end
+
+      private
+
+      attr_reader :description, :opts, :resource, :start, :stop, :subject, :title, :url
+
+      def embeded_object
+        if url.index('soundcloud.com')
+          embeded_object_soundcloud
+        elsif url.index('youtube.com') || url.index('youtu.be')
+          embeded_object_youtube
+        elsif (id = url.scan(CG_RE).flatten.first)
+          embeded_object_cg(id)
+        elsif url.match?(PDF_RE)
+          embeded_object_pdf
+        end
+      end
+
+      def embeded_object_cg(id)
+        return unless (cg = ContentGuide.find_by(permalink: id) || ContentGuide.find(id))
+
+        @description = @title.presence || cg.description
+        @title = cg.title
+        @resource = cg
+
+        grade = cg.grades.list.first.presence
+        grade = cg.grades.grade_abbr(grade).presence || 'base'
+
+        uri = URI.parse(url)
+        cg_url = uri.path
+        cg_url += "##{uri.fragment}" unless uri.fragment.blank?
+
+        {
+          color: "#{cg.subject}-#{grade}",
+          content_guide: cg,
+          resource_url: content_guide_path(cg.permalink || cg.id, slug: cg.slug),
+          type: TYPE_CG,
+          url: cg_url
+        }
+      end
+
+      def embeded_object_pdf
+        pdf_url = url.match?(PDF_HTTP_RE) ? url : "https://#{url}"
+        pdf_url = pdf_url.sub(PDF_HTTP_REPLACE_RE, 'https:')
+        {
+          type: TYPE_PDF,
+          url: pdf_url
+        }
+      end
+
+      def embeded_object_soundcloud
+        {
+          content: Lcms::Engine::MediaEmbed.soundcloud(url, subject),
+          resource_url: (media_path(resource.id) if resource.present?),
+          type: TYPE_PODCAST
+        }
+      end
+
+      def embeded_object_youtube
+        query = {}.tap do |q|
+          q[:start] = start if start.present?
+          q[:end] = stop if stop.present?
+        end.compact
+        youtube_url = "https://www.youtube.com/embed/#{Lcms::Engine::MediaEmbed.video_id(url)}?#{query.to_query}"
+        {
+          resource_url: (media_path(resource.id) if resource.present?),
+          type: TYPE_YOUTUBE,
+          url: youtube_url
+        }
+      end
+
+      def fetch_data
+        @resource = Lcms::Engine::Resource.find_by url: url
+        if (title.blank? || description.blank?) && resource
+          @title = resource.title if title.blank?
+          @description = resource.teaser if description.blank?
+        end
+
+        @subject = opts[:metadata].resource_subject
+        embeded_object
+      end
+    end
+  end
+
+  Template.register_tag(Tags::PdTag::TAG_NAME, Tags::PdTag)
+end

data/lib/doc_template/tags/position_tag.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class PositionTag < TableTag
+      TAG_NAME = 'position'
+      TEMPLATE = 'position.html.erb'
+
+      def parse_table(table)
+        table.remove && return unless @opts[:parent_tags].try(:include?, Tags::MaterialsTag::TAG_NAME)
+
+        params = {
+          content: table.at_xpath('.//tr[2]/td').inner_html,
+          position: @opts[:value].strip
+        }
+
+        content = parse_template params, TEMPLATE
+        @content = parse_nested(content, @opts)
+        replace_tag table
+      end
+    end
+  end
+
+  # TODO: Currently will work only inside materials tag
+  Template.register_tag(Tags::PositionTag::TAG_NAME, Tags::PositionTag)
+end

data/lib/doc_template/tags/pv_tag.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class PvTag < BaseTag
+      TAG_NAME = 'pv'
+      TEMPLATE = 'pv.html.erb'
+
+      def parse(node, opts = {})
+        config = Tags.config[TAG_NAME.downcase]
+        if config && (data = config[opts[:value].to_s.downcase]).present?
+          @content = parse_template data, TEMPLATE
+          replace_tag node
+        else
+          node.remove
+        end
+
+        self
+      end
+    end
+
+    Template.register_tag(Tags::PvTag::TAG_NAME, PvTag)
+  end
+end

data/lib/doc_template/tags/section_tag.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class SectionTag < BaseTag
+      include DocTemplate::Tags::Helpers
+
+      STUDENT_RE = /^\s*student\s*resources\s*$/i
+      TAG_NAME = 'section'
+      SECTION_REMOVE_RE = /\[#{TAG_NAME}:[^\]]*\]/i
+      TEMPLATES = {
+        default: 'section.html.erb',
+        gdoc: 'gdoc/section.html.erb'
+      }.freeze
+
+      def optional?
+        section.optional
+      end
+
+      def parse(node, opts = {})
+        @opts = opts
+        @section = opts[:agenda].level2_by_title(opts[:value].parameterize)
+        @anchor = @section.anchor
+        @materials = @section.material_ids
+
+        @content = parse_content node, template_name(opts)
+
+        replace_tag node
+        self
+      end
+
+      private
+
+      attr_reader :opts, :section
+
+      def general_params
+        @general_params ||= {
+          placeholder: placeholder_id,
+          priority_description: priority_description(section),
+          priority_icon: priority_icon(section),
+          react_props: {
+            activity: {
+              title: section.title
+            },
+            material_ids: @section.material_ids,
+            color: @section[:use_color]
+          },
+          section: section,
+          section_icons: section_icons(section)
+        }
+      end
+
+      def parse_content(node, template)
+        params = general_params.merge(content: content_until_break(node))
+        params[:metacog] = section.metacognition.original_content&.sub(SECTION_REMOVE_RE, '') if optional?
+        parsed_template = parse_template(params, template)
+        parse_nested parsed_template, opts
+      end
+
+      def section_icons(section)
+        return [] if section.icons.nil?
+
+        section.icons.map { |icon| "#{ICON_PATH}/#{icon}.png" }
+      end
+    end
+  end
+
+  Template.register_tag(Tags::SectionTag::TAG_NAME, Tags::SectionTag)
+end

data/lib/doc_template/tags/smp_tag.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class SmpTag < BlockTag
+      TAG_NAME = 'smp'
+      TEMPLATES = { default: 'smp.html.erb',
+                    gdoc: 'gdoc/smp.html.erb' }.freeze
+
+      def parse(node, opts = {})
+        nodes = block_nodes node
+        nodes.each(&:remove)
+
+        params = {
+          content: parse_nested(nodes.map(&:to_html).join, opts),
+          smp: opts[:value].split(';').map(&:strip)
+        }
+        @content = parse_template(params, template_name(opts))
+        replace_tag node
+        self
+      end
+    end
+  end
+
+  Template.register_tag(Tags::SmpTag::TAG_NAME, Tags::SmpTag)
+end

data/lib/doc_template/tags/source_tag.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class SourceTag < BaseTag
+      TAG_NAME = 'source'
+      TEMPLATE = 'source.html.erb'
+
+      def parse(node, opts = {})
+        # we have to collect all the next siblings until next activity-metadata
+        content = content_until_break node
+        content = parse_nested content.to_s, opts
+        @content = parse_template content, TEMPLATE
+
+        replace_tag node
+        self
+      end
+    end
+  end
+
+  Template.register_tag(Tags::SourceTag::TAG_NAME, Tags::SourceTag)
+end

data/lib/doc_template/tags/standard_tag.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class StandardTag < BaseTag
+      include ERB::Util
+
+      STANDARD_RE = /[^\[\]]*\[(ela\.)?((rl|ri|rf|w|sl|l)\.[^\]]+)\]/i # [rl.2.2a.2]
+      TAG_NAME = /(ela\.)?((rl|ri|rf|w|sl|l)\.[^\]]+)/ # RL.2.4 or ELA.RL.2.4
+      TAG_RE = /\[[^\]]*\]/
+      TAG_SEPARATOR = '[separator]'
+      TEMPLATES = { default: 'standard.html.erb',
+                    gdoc: 'gdoc/standard.html.erb' }.freeze
+
+      def parse(node, opts)
+        @content = render_template node, opts
+        loop do
+          break unless STANDARD_RE =~ @content
+
+          @content = render_template Nokogiri::HTML.fragment(@content), opts
+        end
+
+        # preserve `li` element
+        if node.name == 'li'
+          @result = node.replace "<li class='#{node['class']}'>#{placeholder}</li>"
+        else
+          replace_tag node
+        end
+
+        self
+      end
+
+      private
+
+      # Extracting content outside the tag
+      # TODO: Extract to the parent class
+      def fetch_data(source)
+        @preserved_style = %r{<span (style=[^.>]*)>[^<]+</span>$}.match(source).try(:[], 1)
+        {}.tap do |result|
+          data = source.squish
+                   .sub(TAG_RE, TAG_SEPARATOR)
+                   .split(TAG_SEPARATOR, 2)
+                   .reject(&:blank?)
+          break unless data
+
+          result[:prepend] = data[0]
+          result[:append] = data[1]
+        end
+      end
+
+      def fetch_description(text)
+        return unless (matches = STANDARD_RE.match text)
+
+        name = matches[2].downcase.to_sym
+        Lcms::Engine::Standard.search_by_name(name).first.try(:description)
+      end
+
+      def render_template(node, opts)
+        @data = fetch_data node.inner_html
+        @standard_shortcut = TAG_RE.match(node.content).try(:[], 0).try(:gsub, /[\[\]]/, '')
+        @description = fetch_description node.content
+
+        template = File.read template_path(template_name(opts))
+        ERB.new(template).result(binding).gsub(/\s{2,}</, '<')
+      end
+    end
+  end
+
+  Template.register_tag(Tags::StandardTag::TAG_NAME, Tags::StandardTag)
+end

data/lib/doc_template/tags/table_preserve_alignment_tag.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class TablePreserveAlignmentTag < BaseTag
+      STYLE_RE = /text-align:(left|center|right)/i
+      TAG_NAME = 'table-preserve-alignment'
+
+      def parse(node, _options = {})
+        if (table = find_table node)
+          # inside cells for each `p` with `text-align` css param we add specific class
+          table.xpath('.//p').each do |el|
+            if (m = STYLE_RE.match el['style'])
+              el['style'] = el['style'].sub STYLE_RE, ''
+              el['class'] = "text-#{m[1]}"
+            end
+          end
+
+          @content = table.to_s
+          replace_tag table
+        end
+
+        node.remove
+
+        self
+      end
+
+      private
+
+      def find_table(node)
+        while (node = node.next_sibling)
+          return node if node.name.casecmp('table').zero?
+        end
+      end
+    end
+
+    Template.register_tag(Tags::TablePreserveAlignmentTag::TAG_NAME, TablePreserveAlignmentTag)
+  end
+end

data/lib/doc_template/tags/table_tag.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class TableTag < BaseTag
+      def parse(node, opts = {})
+        unless (table = node.ancestors('table').first)
+          raise ::DocumentError, "Tag #{self.class::TAG_NAME.upcase} placed outside table"
+        end
+
+        @opts = opts
+        parse_table table
+
+        self
+      end
+
+      def parse_table(_table)
+        raise NotImplementedError
+      end
+    end
+  end
+end