lcms-engine 0.1.0

data/lib/doc_template/tags/activity_metadata_section_tag.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class ActivityMetadataSectionTag < BaseTag
+      include DocTemplate::Tags::Helpers
+      include ERB::Util
+
+      TAG_NAME = 'activity-metadata-section'
+      TEMPLATES = { default: 'group-math.html.erb',
+                    gdoc: 'gdoc/group-math.html.erb' }.freeze
+
+      def parse(node, opts = {})
+        @opts = opts
+        @section = @opts[:sections].level1_by_title(@opts[:value])
+        @anchor = @section.anchor
+        @materials = @section.material_ids
+
+        parse_foundational
+
+        before_materials = ''
+        if (with_materials = @section.material_ids.any?)
+          before_materials = content_until_materials node
+          before_materials = parse_nested before_materials.to_s, opts
+        end
+
+        content = content_until_break node
+        content.scan(DocTemplate::FULL_TAG).select { |t| t.first == ActivityMetadataTypeTag::TAG_NAME }.each do |(_, a)|
+          @section.add_activity opts[:activity].find_by_anchor(a)
+        end
+        content = parse_nested content.to_s, opts
+        params = {
+          before_materials: before_materials,
+          # TODO: check maybe it's ok to move it somewhere else,
+          # fixed at #692 bc with new section we always have some garbage before activity
+          content: DocTemplate.sanitizer.strip_html(content),
+          foundational_skills: opts[:foundational_skills],
+          placeholder: placeholder_id,
+          react_props: {
+            activity: {
+              title: @section.title
+            },
+            group: true,
+            material_ids: @section.material_ids
+          },
+          section: @section,
+          with_materials: with_materials
+        }
+        @content = parse_template params, template_name(opts)
+        replace_tag node
+        self
+      end
+
+      private
+
+      attr_accessor :opts, :section
+
+      def parse_foundational
+        return unless opts[:value] == 'foundational-skills'
+
+        # Extend object to store `lesson_objective` (#162)
+        section.class.attribute :lesson_objective, String
+        section.lesson_objective = DocTemplate.sanitizer
+                                     .strip_html_element(opts[:foundational_metadata].lesson_objective)
+        # Extend object to store `lesson_standard` (#386)
+        section.class.attribute :lesson_standard, String
+        section.lesson_standard = DocTemplate.sanitizer
+                                    .strip_html_element(opts[:foundational_metadata].lesson_standard)
+        opts[:sections].add_break
+        opts[:foundational_skills] = true
+      end
+    end
+  end
+
+  Template.register_tag(Tags::ActivityMetadataSectionTag::TAG_NAME, Tags::ActivityMetadataSectionTag)
+end

data/lib/doc_template/tags/activity_metadata_type_tag.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class ActivityMetadataTypeTag < BaseTag
+      include DocTemplate::Tags::Helpers
+      include ERB::Util
+
+      TAG_NAME = 'activity-metadata-type'
+      TASK_RE = /(\[task:\s(#)\])/i
+      TEMPLATES = {
+        default: 'activity.html.erb',
+        gdoc: 'gdoc/activity.html.erb'
+      }.freeze
+
+      def optional?
+        !!@activity.try(:optional)
+      end
+
+      def parse(node, opts = {})
+        @opts = opts
+        @metadata = opts[:activity]
+        @activity = @metadata.find_by_anchor(opts[:value])
+        @anchor = @activity.anchor
+
+        content = DocTemplate.sanitizer.strip_html(content_until_break(node))
+        content = parse_nested content.to_s, opts
+        params = {
+          activity: @activity,
+          content: DocTemplate.sanitizer.strip_html_element(content),
+          placeholder: placeholder_id
+        }
+
+        # Extend basic params set with additional which can be customized
+        params.merge! extended_parse_params
+
+        @content = parse_template params, template_name(opts)
+        @materials = @activity.try(:material_ids) || []
+        replace_tag node
+        self
+      end
+
+      private
+
+      attr_reader :activity, :opts
+
+      def extended_parse_params
+        custom_params = ::DocTemplate::Tags.config[TAG_NAME]['extend-params-with'].to_s
+        return extended_params_default if custom_params.blank?
+
+        mod, method = custom_params.split('.')
+        mod.constantize.send method
+      end
+
+      def extended_params_default
+        if @activity.respond_to?(:activity_guidance)
+          @activity[:activity_guidance] = DocTemplate.sanitizer.strip_html_element(@activity[:activity_guidance])
+        end
+
+        {
+          foundational: opts[:foundational_skills],
+          priority_description: priority_description(activity),
+          priority_icon: priority_icon(activity),
+          react_props: {
+            activity: {
+              title: @activity.title,
+              type: @activity.activity_type
+            },
+            material_ids: @activity.material_ids
+          }
+        }
+      end
+    end
+  end
+
+  Template.register_tag(Tags::ActivityMetadataTypeTag::TAG_NAME, Tags::ActivityMetadataTypeTag)
+end

data/lib/doc_template/tags/answer_space_tag.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class AnswerSpaceTag < BaseTag
+      SPACE_SIZE = {
+        s: 5, # small = 5 lines
+        m: 10, # medium = 10 lines
+        l: 20, # large = 20 lines
+      }.freeze
+      TAG_NAME = 'answer-space'
+
+      def parse(node, opts = {})
+        num_of_lines = SPACE_SIZE[opts[:value].try(:to_sym)]
+        if num_of_lines
+          space = '<br>' * num_of_lines
+          @content = node.to_html.sub(/\[#{TAG_NAME}:\s?[s|m|l]\]/i, space)
+        end
+        replace_tag node
+        self
+      end
+    end
+  end
+
+  Template.register_tag(Tags::AnswerSpaceTag::TAG_NAME, Tags::AnswerSpaceTag)
+end

data/lib/doc_template/tags/base_tag.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class BaseTag
+      SOFT_RETURN_RE = /([[:graph:]]+\[|\][[:graph:]]+)/
+      UNICODE_SPACES_RE = /(\u0020|\u00A0|\u1680|\u180E|[\u2000-\u200B]|\u202F|\u205F|\u3000|\uFEFF)/
+
+      attr_reader :anchor, :content
+
+      class << self
+        def parse(node, opts = {})
+          new.parse(node, opts)
+        end
+
+        def tag_with_html_regexp
+          raise NotImplementedError unless const_defined?(:TAG_NAME)
+
+          @tag_with_html_regexp ||= /\[[^\]]*#{self::TAG_NAME}[[^\:]]*:?\s?[^\]]*\]/i
+        end
+
+        def template_path_for(name)
+          File.join ::Lcms::Engine::Engine.root.join('lib', 'doc_template', 'templates'), name
+        end
+      end
+
+      #
+      # Precede the specified element with tag's placeholder
+      #
+      def before_tag(node)
+        node.before Nokogiri::HTML.fragment(placeholder)
+      end
+
+      def check_tag_soft_return(node)
+        # need to remove unicode spaces bc they're not handled by [[:graph:]]
+        return unless node.content.gsub(UNICODE_SPACES_RE, '') =~ SOFT_RETURN_RE
+
+        raise ::DocumentError,
+              "Soft return for #{self.class::TAG_NAME} detected: #{node.content}, use hard return instead"
+      end
+
+      def content_until_break(node)
+        [].tap do |result|
+          check_tag_soft_return(node)
+          while (sibling = node.next_sibling)
+            break if include_break?(sibling)
+
+            result << sibling.to_html
+            sibling.remove
+          end
+        end.join
+      end
+
+      def content_until_materials(node)
+        [].tap do |result|
+          check_tag_soft_return(node)
+          while (sibling = node.next_sibling)
+            break if include_break_for?(sibling, 'stop_materials_tags')
+
+            result << sibling.to_html
+            sibling.remove
+          end
+        end.join
+      end
+
+      def ela2?(metadata)
+        metadata.resource_subject == 'ela' && metadata.grade == '2'
+      end
+
+      def ela6?(metadata)
+        metadata.resource_subject == 'ela' && metadata.grade == '6'
+      end
+
+      def gdoc?(opts)
+        opts[:context_type].to_s.casecmp('gdoc').zero?
+      end
+
+      def include_break?(node)
+        include_break_for? node, 'stop_tags'
+      end
+
+      def include_break_for?(node, key)
+        stop_tags = Array.wrap ::DocTemplate::Tags.config[self.class::TAG_NAME.downcase][key]
+        return false if stop_tags.empty?
+
+        tags = stop_tags.map { |t| ::DocTemplate::Tags.const_get(t)::TAG_NAME }.join('|')
+
+        result = node.content =~ /\[\s*(#{tags})/i
+        check_tag_soft_return(node) if result
+        result
+      end
+
+      def materials
+        @materials || []
+      end
+
+      def parse(node, _options = {})
+        @result = node
+        remove_tag
+        self
+      end
+
+      def parse_nested(node, opts = {})
+        if node == opts[:parent_node]
+          opts[:iteration] = opts[:iteration].to_i + 1
+          if opts[:iteration] > DocTemplate::Document::MAX_PARSE_ITERATIONS
+            raise ::DocumentError, "Loop detected for node:<br>#{node}"
+          end
+        end
+        parsed = ::DocTemplate::Document.parse(Nokogiri::HTML.fragment(node), opts.merge(level: 1))
+        # add the parts to the parent document
+        opts[:parent_document].parts += parsed.parts if opts[:parent_document]
+        parsed.render
+      end
+
+      def parse_template(context, template_name)
+        @tmpl = context
+        template = File.read template_path(template_name)
+        ERB.new(template).result(binding)
+      end
+
+      def placeholder
+        @placeholder ||= "{{#{placeholder_id}}}"
+      end
+
+      def placeholder_id
+        @placeholder_id ||= "#{self.class.name.demodulize.underscore}_#{SecureRandom.hex(10)}"
+      end
+
+      def render
+        @result.to_s.presence || placeholder
+      end
+
+      #
+      # Replace the tag element with its placeholder. Or inline the
+      # tag if requested
+      #
+      def replace_tag(node)
+        replacement = @opts&.[](:explicit_render) ? content : Nokogiri::HTML.fragment(placeholder)
+        node.replace replacement
+      end
+
+      def tag_data
+        {}
+      end
+
+      #
+      # First look for the template override inside possible gems
+      # And use standard one if not found
+      #
+      def template_name(opts)
+        context = opts.fetch(:context_type, :default).to_s
+        override =
+          ::DocTemplate::Tags.config.dig(self.class::TAG_NAME.to_s.downcase, 'templates', context)
+        override.presence || self.class::TEMPLATES[context.to_sym]
+      end
+
+      def template_path(name)
+        custom_path =
+          Array.wrap(::DocTemplate::Tags.config['templates_paths']).detect do |path|
+            File.exist?(File.join path.to_s, name)
+          end
+        custom_path.present? ? File.join(custom_path, name) : self.class.template_path_for(name)
+      end
+
+      private
+
+      def remove_tag
+        start_tag_index = @result.children.index(@result.at_xpath(STARTTAG_XPATH))
+        end_tag_index = @result.children.index(@result.at_xpath(ENDTAG_XPATH))
+        @result.children[start_tag_index..end_tag_index].each do |node|
+          if node.content.match?(/.+\[[^\]]+\]|\[[^\]]+\].+/)
+            # a tag followed or preceeded by anything else
+            # removes the tag itself - everything between `[` and `]`
+            node.content = node.content.sub(/\[[^\[\]]+\]/, '')
+          elsif (data = node.content.match(/^([^\[]*)\[|\]([^\[]*)$/))
+            # if node contains open or closing tag bracket with general
+            # text outside the bracket itself
+            if (new_content = data[1].presence || data[2]).blank?
+              node.remove
+            else
+              node.content = new_content
+            end
+          else
+            node.remove
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doc_template/tags/block_tag.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class BlockTag < BaseTag
+      END_VALUE = 'end'
+
+      def no_end_tag_for(node)
+        msg = "No tag with END value for: #{self.class::TAG_NAME.upcase}<br>" \
+              "<em>#{node.parent.try(:inner_html)}</em>"
+        raise DocumentError, msg
+      end
+
+      #
+      # Collects all the nodes before the closing tag
+      #
+      def block_nodes(node)
+        end_tag_found = false
+        tag_node = node
+
+        # we have to collect all nodes until the we find the end tag
+        nodes = [].tap do |result|
+          check_tag_soft_return(node)
+          while (node = node.next_sibling)
+            if node.content.match?(end_tag_re)
+              end_tag_found = true
+              check_tag_soft_return(node)
+              node.remove
+              break
+            end
+            node = yield(node) if block_given?
+            result << node
+          end
+        end
+
+        no_end_tag_for(tag_node) unless end_tag_found
+
+        nodes
+      end
+
+      private
+
+      def end_tag_re
+        @end_tag_re ||= /\[#{self.class::TAG_NAME}:\s*#{END_VALUE}\]/i
+      end
+    end
+  end
+end

data/lib/doc_template/tags/callout_tag.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module DocTemplate
+  module Tags
+    class CalloutTag < TableTag
+      TAG_NAME = 'callout'
+      TEMPLATES = {
+        default: 'callout.html.erb',
+        gdoc: 'gdoc/callout.html.erb'
+      }.freeze
+
+      def parse_table(table)
+        header, content = fetch_content(table)
+        params = {
+          content: content,
+          header: header,
+          subject: @opts[:metadata].resource_subject
+        }
+        new_content = parse_template params, template_name(@opts)
+
+        @opts[:parent_node] = new_content
+        parsed_content = parse_nested new_content, @opts
+
+        # Place placeholder where it should be
+        before_tag(previous_non_empty(table) || table)
+
+        # returns the generated content to be stored as part
+        @content = parsed_content
+        table.remove
+      end
+
+      private
+
+      def fetch_content(node)
+        [node.at_xpath('.//tr[2]/td').try(:content) || '',
+         node.at_xpath('.//tr[3]/td').try(:inner_html) || '']
+      end
+
+      def previous_non_empty(node)
+        while (node = node.previous_sibling)
+          break unless node.content.squish.blank?
+        end
+        node
+      end
+    end
+
+    Template.register_tag(Tags::CalloutTag::TAG_NAME, CalloutTag)
+  end
+end