openstax_content 0.0.1

data/lib/openstax/content/fragment/interactive.rb

@@ -0,0 +1,36 @@
+require_relative 'embedded'
+
+class OpenStax::Content::Fragment::Interactive < OpenStax::Content::Fragment::Embedded
+  # CSS to find interactive containers (anything inside may be replaced with an iframe)
+  CONTAINER_CSS = 'figure.ost-embed-container, .os-figure:has-descendants("a.os-interactive-link"), figure:has-descendants("a.os-interactive-link")'
+
+  # CSS to find links to be embedded inside containers
+  TAGGED_LINK_CSS = 'a.os-embed, a.os-interactive-link'
+  UNTAGGED_LINK_CSS = 'a'
+
+  self.default_width = 960
+  self.default_height = 560
+  self.iframe_classes += ['interactive']
+
+  # This code is run from lib/openstax/cnx/v1/page.rb during import
+  def self.replace_interactive_links_with_iframes!(node)
+    containers = node.css(CONTAINER_CSS, OpenStax::Content::CustomCss.instance)
+
+    containers.each do |container|
+      link_node = node.at_css(TAGGED_LINK_CSS) || node.css(UNTAGGED_LINK_CSS).last
+
+      next if link_node.nil?
+
+      # Build iframe based on the link's URL
+      iframe = Nokogiri::XML::Node.new('iframe', node.document)
+      iframe['title'] = 'Interactive Simulation'
+      iframe['src'] = link_node['href']
+      iframe['class'] = iframe_classes.join(' ')
+      iframe['width'] = default_width
+      iframe['height'] = default_height
+
+      # Replace the container with the new iframe
+      container.replace(iframe)
+    end
+  end
+end

data/lib/openstax/content/fragment/optional_exercise.rb

@@ -0,0 +1,4 @@
+require_relative 'exercise'
+
+class OpenStax::Content::Fragment::OptionalExercise < OpenStax::Content::Fragment::Exercise
+end

data/lib/openstax/content/fragment/reading.rb

@@ -0,0 +1,9 @@
+require_relative 'html'
+
+class OpenStax::Content::Fragment::Reading < OpenStax::Content::Fragment::Html
+  def initialize(node:, title: nil, labels: nil, reference_view_url: nil)
+    super node: node, title: title, labels: labels
+
+    @reference_view_url = reference_view_url
+  end
+end

data/lib/openstax/content/fragment/video.rb

@@ -0,0 +1,8 @@
+require_relative 'embedded'
+
+class OpenStax::Content::Fragment::Video < OpenStax::Content::Fragment::Embedded
+  self.default_width = 560
+  self.default_height = 315
+  self.iframe_classes += ['video']
+  self.iframe_title = "Video"
+end

data/lib/openstax/content/fragment_splitter.rb

@@ -0,0 +1,193 @@
+require 'nokogiri'
+require_relative 'fragment/reading'
+require_relative 'custom_css'
+
+class OpenStax::Content::FragmentSplitter
+  attr_reader :processing_instructions, :reference_view_url
+
+  def initialize(processing_instructions, reference_view_url)
+    @processing_instructions = processing_instructions.map do |processing_instruction|
+      OpenStruct.new(processing_instruction.to_h).tap do |pi_struct|
+        pi_struct.fragments = [pi_struct.fragments].flatten.map do |fragment|
+          fragment.to_s.split('_').map(&:capitalize).join
+        end unless pi_struct.fragments.nil?
+        pi_struct.only = [pi_struct.only].flatten.map(&:to_s) unless pi_struct.only.nil?
+        pi_struct.except = [pi_struct.except].flatten.map(&:to_s) unless pi_struct.except.nil?
+      end
+    end
+
+    @reference_view_url = reference_view_url
+  end
+
+  # Splits the given root node into fragments according to the processing instructions
+  def split_into_fragments(root, type = nil)
+    result = [root.dup]
+    type_string = type.to_s
+
+    pis = processing_instructions.reject do |processing_instruction|
+      processing_instruction.css.nil? ||
+      processing_instruction.css.empty? ||
+      processing_instruction.fragments.nil? ||
+      processing_instruction.fragments == ['Node'] ||
+      (!processing_instruction.only.nil? && !processing_instruction.only.include?(type_string)) ||
+      (!processing_instruction.except.nil? && processing_instruction.except.include?(type_string))
+    end
+
+    @media_nodes = []
+
+    pis.each { |processing_instruction| result = process_array(result, processing_instruction) }
+
+    # Flatten, remove empty nodes and transform remaining nodes into reading fragments
+    result.map do |obj|
+      next obj unless obj.is_a?(Nokogiri::XML::Node)
+      next if obj.content.nil? || obj.content.strip.empty?
+
+      OpenStax::Content::Fragment::Reading.new node: obj, reference_view_url: reference_view_url
+    end.compact.tap do |result|
+      @media_nodes.each do |node|
+        # Media processing instructions
+        node.css('[id], [name]', custom_css).each do |linkable|
+          css_array = []
+          css_array << "[href$=\"##{linkable[:id]}\"]" unless linkable[:id].nil?
+          css_array << "[href$=\"##{linkable[:name]}\"]" unless linkable[:name].nil?
+          css = css_array.join(', ')
+
+          result.select(&:html?)
+                .select { |fragment| fragment.has_css? css, custom_css }
+                .each   { |fragment| fragment.append node.dup }
+        end
+      end
+
+      result.select(&:html?).each(&:transform_links!)
+    end
+  end
+
+  protected
+
+  def custom_css
+    OpenStax::Content::CustomCss.instance
+  end
+
+  # Returns an instance of the given fragment class
+  def get_fragment_instance(fragment_name, node, labels)
+    fragment_class = OpenStax::Content::Fragment.const_get fragment_name
+    args = { node: node, labels: labels }
+    args[:reference_view_url] = reference_view_url \
+      if fragment_class.is_a? OpenStax::Content::Fragment::Reading
+    fragment = fragment_class.new args
+    fragment unless fragment.blank?
+  end
+
+  # Recursively removes a node and its empty parents
+  def recursive_compact(node, root)
+    return if node == root
+
+    parent = node.parent
+    node.remove
+
+    recursive_compact(parent, root) if parent && (parent.content.nil? || parent.content.empty?)
+  end
+
+  # Recursively removes all siblings before a node and its parents
+  def remove_before(node, root)
+    return if node == root
+
+    parent = node.parent
+    siblings = parent.children
+    index = siblings.index(node)
+    parent.children = siblings.slice(index..-1)
+    remove_before(parent, root)
+  end
+
+  # Recursively removes all siblings after a node and its parents
+  def remove_after(node, root)
+    return if node == root
+
+    parent = node.parent
+    siblings = parent.children
+    index = siblings.index(node)
+    parent.children = siblings.slice(0..index)
+    remove_after(parent, root)
+  end
+
+  # Process a single Nokogiri::XML::Node
+  def process_node(root, processing_instruction)
+    # Find first match
+    node = root.at_css(processing_instruction.css, custom_css)
+
+    # Base case
+    return [ root ] if node.nil?
+
+    num_fragments = processing_instruction.fragments.size
+
+    if num_fragments == 0 # No splitting needed
+      # Remove the match node and any empty parents from the tree
+      recursive_compact(node, root)
+
+      # Repeat the processing until no more matches
+      process_node(root, processing_instruction)
+    else
+      compact_before = true
+      compact_after = true
+
+      # Check for special fragment cases (node)
+      fragments = []
+      processing_instruction.fragments.each_with_index do |fragment, index|
+        if fragment == 'Node'
+          if index == 0
+            # fragments: [node, anything] - Don't remove node from root before fragments
+            compact_before = false
+          elsif index == num_fragments - 1
+            # fragments: [anything, node] - Don't remove node from root after fragments
+            compact_after = false
+          else
+            # General case
+            # Make a copy of the current node (up to the root), but remove all other nodes
+            root_copy = root.dup
+            node_copy = root_copy.at_css(processing_instruction.css, custom_css)
+
+            remove_before(node_copy, root_copy)
+            remove_after(node_copy, root_copy)
+
+            fragments << root_copy
+          end
+        elsif fragment == 'Media'
+          @media_nodes << node
+        else
+          fragments << get_fragment_instance(fragment, node, processing_instruction.labels)
+        end
+      end
+
+      # Need to split the node tree
+      # Copy the node content and find the same match in the copy
+      root_copy = root.dup
+      node_copy = root_copy.at_css(processing_instruction.css, custom_css)
+
+      # One copy retains the content before the match;
+      # the other retains the content after the match
+      remove_after(node, root)
+      remove_before(node_copy, root_copy)
+
+      # Remove the match, its copy and any empty parents from the 2 trees
+      recursive_compact(node, root) if compact_before
+      recursive_compact(node_copy, root_copy) if compact_after
+
+      # Repeat the processing until no more matches
+      [ root ] + fragments + process_node(root_copy, processing_instruction)
+    end
+  end
+
+  # Recursively process an array of Nodes and Fragments
+  def process_array(array, processing_instruction)
+    array.flat_map do |obj|
+      case obj
+      when Array
+        process_array(obj, processing_instruction)
+      when Nokogiri::XML::Node
+        process_node(obj, processing_instruction)
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/openstax/content/page.rb

@@ -0,0 +1,201 @@
+require_relative 'title'
+require_relative 'fragment/interactive'
+require_relative 'fragment/exercise'
+
+class OpenStax::Content::Page
+  # Start parsing here
+  ROOT_CSS = 'html > body'
+
+  # Find snap lab notes
+  SNAP_LAB_CSS = '.snap-lab'
+  SNAP_LAB_TITLE_CSS = '[data-type="title"]'
+
+  # Find nodes that define relevant tags
+  LO_DEF_NODE_CSS = '.ost-learning-objective-def'
+  STD_DEF_NODE_CSS = '.ost-standards-def'
+  TEKS_DEF_NODE_CSS = '.ost-standards-teks'
+  APBIO_DEF_NODE_CSS = '.ost-standards-apbio'
+
+  STD_NAME_NODE_CSS = '.ost-standards-name'
+  STD_DESC_NODE_CSS = '.ost-standards-description'
+
+  # Find specific tags and extract the relevant parts
+  LO_REGEX = /ost-tag-lo-([\w+-]+)/
+  STD_REGEX = /ost-tag-std-([\w+-]+)/
+  TEKS_REGEX = /ost-tag-(teks-[\w+-]+)/
+
+  def self.feature_node(node, feature_ids)
+    feature_ids = [feature_ids].flatten
+    return if feature_ids.empty?
+
+    feature_id_css = feature_ids.map { |feature_id| "##{feature_id}" }.join(', ')
+    node.at_css(feature_id_css)
+  end
+
+  def initialize(book: nil, hash: {}, uuid: nil, url: nil, title: nil, content: nil)
+    @uuid    = uuid || hash['id']&.split('@', 2)&.first
+    raise ArgumentError, 'Either uuid or hash with id key is required' if @uuid.nil?
+
+    @book    = book
+    @hash    = hash
+    @url     = url
+    @title   = title || hash['title']
+    @content = content
+  end
+
+  attr_accessor :chapter_section
+  attr_reader :uuid, :hash
+
+  def book
+    raise ArgumentError, 'Book was not specified' if @book.nil?
+
+    @book
+  end
+
+  def url
+    @url ||= "#{book.url_fragment}:#{uuid}.json"
+  end
+
+  def parsed_title
+    @parsed_title ||= OpenStax::Content::Title.new @title
+  end
+
+  def book_location
+    parsed_title.book_location
+  end
+
+  def title
+    parsed_title.text
+  end
+
+  def full_hash
+    @full_hash ||= book.archive.json url
+  end
+
+  def short_id
+    @short_id ||= full_hash.fetch('shortId', nil)
+  end
+
+  def content
+    @content ||= full_hash.fetch('content')
+  end
+
+  def doc
+    @doc ||= Nokogiri::HTML(content)
+  end
+
+  def root
+    @root ||= doc.at_css(ROOT_CSS)
+  end
+
+  def footnotes
+    @footnotes ||= doc.css('[role=doc-footnote]')
+  end
+
+  # Replaces links to embeddable sims (and maybe videos in the future) with iframes
+  # Changes exercise urls in the doc to be absolute
+  def convert_content!
+    OpenStax::Content::Fragment::Interactive.replace_interactive_links_with_iframes!(doc)
+    OpenStax::Content::Fragment::Exercise.absolutize_exercise_urls!(doc)
+    map_note_format!(doc)
+    @content = doc.to_html
+    @root = nil
+  end
+
+  def snap_lab_nodes
+    root.css(SNAP_LAB_CSS)
+  end
+
+  def snap_lab_title(snap_lab)
+    snap_lab.at_css(SNAP_LAB_TITLE_CSS).try(:text)
+  end
+
+  def los
+    @los ||= tags.select { |tag| tag[:type] == :lo }.map { |tag| tag[:value] }
+  end
+
+  def aplos
+    @aplos ||= tags.select { |tag| tag[:type] == :aplo }.map { |tag| tag[:value] }
+  end
+
+  def tags
+    return @tags.values unless @tags.nil?
+
+    # Start with default cnxmod tag
+    cnxmod_value = "context-cnxmod:#{uuid}"
+    @tags = { cnxmod_value => { value: cnxmod_value, type: :cnxmod } }
+
+    # Extract tag name and description from .ost-standards-def and .os-learning-objective-def.
+
+    # LO tags
+    root.css(LO_DEF_NODE_CSS).each do |node|
+      klass = node.attr('class')
+      lo_value = LO_REGEX.match(klass).try(:[], 1)
+      next if lo_value.nil?
+
+      teks_value = TEKS_REGEX.match(klass).try(:[], 1)
+      description = node.content.strip
+
+      @tags[lo_value] = {
+        value: lo_value,
+        description: description,
+        teks: teks_value,
+        type: :lo
+      }
+    end
+
+    # Other standards
+    root.css(STD_DEF_NODE_CSS).each do |node|
+      klass = node.attr('class')
+      name = node.at_css(STD_NAME_NODE_CSS).try(:content).try(:strip)
+      description = node.at_css(STD_DESC_NODE_CSS).try(:content).try(:strip)
+      value = nil
+
+      if node.matches?(TEKS_DEF_NODE_CSS)
+        value = TEKS_REGEX.match(klass).try(:[], 1)
+        type = :teks
+      elsif node.matches?(APBIO_DEF_NODE_CSS)
+        value = LO_REGEX.match(klass).try(:[], 1)
+        type = :aplo
+      end
+
+      next if value.nil?
+
+      @tags[value] = {
+        value: value,
+        name: name,
+        description: description,
+        type: type
+      }
+    end
+
+    @tags.values
+  end
+
+  protected
+
+  # Adds a container div around note content for styling
+  def map_note_format!(node)
+    note_selector = <<-eos
+      .note:not(.learning-objectives),
+      .example,
+      .grasp-check,
+      [data-type="note"],
+      [data-element-type="check-understanding"]
+    eos
+
+    note_selector = note_selector.gsub(/\s+/, "")
+
+    node.css(note_selector).each do |note|
+      note.set_attribute('data-tutor-transform', true)
+      body = Nokogiri::XML::Node.new('div', doc)
+      body.set_attribute('data-type', 'content')
+
+      content = note.css('>*:not([data-type=title])')
+      content.unlink()
+
+      body.children = content
+      note.add_child(body)
+    end
+  end
+end