openstax_content 0.0.1

data/README.md

@@ -0,0 +1,2 @@
+# content-ruby
+Ruby bindings to read and parse the OpenStax ABL and the content archive

data/lib/openstax/content.rb

@@ -0,0 +1,14 @@
+module OpenStax
+  module Content
+    class << self
+      attr_accessor :abl_url, :archive_path, :bucket_name, :domain, :exercises_search_api_url,
+                    :logger, :s3_region, :s3_access_key_id, :s3_secret_access_key
+
+      def configure
+        yield self
+      end
+    end
+  end
+end
+
+Dir["#{__dir__}/content/**/*.rb"].each { |file| require file }

data/lib/openstax/content/abl.rb

@@ -0,0 +1,13 @@
+class OpenStax::Content::Abl
+  def body
+    @body ||= JSON.parse(Faraday.get(OpenStax::Content.abl_url).body).deep_symbolize_keys
+  end
+
+  def approved_books
+    body[:approved_books]
+  end
+
+  def approved_versions
+    body[:approved_versions]
+  end
+end

data/lib/openstax/content/archive.rb

@@ -0,0 +1,104 @@
+require 'addressable/uri'
+require 'faraday'
+
+class OpenStax::Content::Archive
+  def initialize(version)
+    @version = version
+    @slugs = {}
+  end
+
+  def base_url
+    @base_url ||= "https://#{OpenStax::Content.domain}/#{
+                  OpenStax::Content.archive_path}/#{@version}"
+  end
+
+  def url_for(object)
+    return if object.nil?
+
+    begin
+      uri = Addressable::URI.parse object
+    rescue Addressable::URI::InvalidURIError
+      begin
+        uri = Addressable::URI.parse "/#{object}"
+      rescue Addressable::URI::InvalidURIError
+        OpenStax::Content.logger.warn { "Invalid url: \"#{object}\" in archive link" }
+
+        return object
+      end
+    end
+
+    if uri.absolute?
+      OpenStax::Content.logger.warn do
+        "#{self.class.name} received an unexpected absolute URL in url_for: \"#{object}\""
+      end
+
+      # Force absolute URLs to be https
+      uri.scheme = 'https'
+      return uri.to_s
+    end
+
+    if uri.path.empty?
+      OpenStax::Content.logger.warn do
+        "#{self.class.name} received an unexpected fragment-only URL in url_for: \"#{object}\""
+      end
+
+      return object
+    end
+
+    if uri.path.start_with?('../')
+      uri.path = uri.path.sub('..', '')
+      "#{base_url}#{uri.to_s}"
+    else
+      uri.path = "#{uri.path.chomp('.json').chomp('.xhtml')}.json"
+
+      uri.path.start_with?('/') ? "#{base_url}/contents#{uri.to_s}" :
+                                  "#{base_url}/contents/#{uri.to_s}"
+    end
+  end
+
+  def fetch(object)
+    url = url_for object
+    OpenStax::Content.logger.debug { "Fetching #{url}" }
+    Faraday.get(url).body
+  end
+
+  def json(object)
+    begin
+      JSON.parse(fetch(object)).tap do |hash|
+        @slugs[object] = hash['slug']
+      end
+    rescue JSON::ParserError => err
+      raise "OpenStax Content Archive returned invalid JSON for #{url_for object}: #{err.message}"
+    end
+  end
+
+  def s3
+    @s3 ||= OpenStax::Content::S3.new
+  end
+
+  def add_latest_book_version_if_missing(object)
+    book_id, page_id = object.split(':', 2)
+    book_uuid, book_version = book_id.split('@', 2)
+    return object unless book_version.nil? && s3.bucket_configured?
+
+    s3.ls(@version).each do |book|
+      uuid, version = book.split('@')
+      next unless uuid == book_uuid
+
+      book_version = version
+      break
+    end
+
+    book_id = "#{book_uuid}@#{book_version}".chomp('@')
+    "#{book_id}:#{page_id}".chomp(':')
+  end
+
+  def slug(object)
+    @slugs[object] ||= begin
+      object_with_version = add_latest_book_version_if_missing object
+      slug = json(object_with_version)['slug']
+      @slugs[object_with_version] = slug if object_with_version != object
+      slug
+    end
+  end
+end

data/lib/openstax/content/book.rb

@@ -0,0 +1,70 @@
+require_relative 'archive'
+require_relative 'book_part'
+
+class OpenStax::Content::Book
+  def initialize(
+    archive_version:, uuid: nil, version: nil, hash: nil, title: nil, tree: nil, root_book_part: nil
+  )
+    @uuid            = uuid || (hash || {})['id']
+    raise ArgumentError, 'Either uuid or hash with id key is required' if @uuid.nil?
+
+    @version         = version || (hash || {})['version']
+    raise ArgumentError, 'Either version or hash with version key is required' if @version.nil?
+
+    @archive_version = archive_version
+    @hash            = hash
+    @title           = title
+    @tree            = tree
+    @root_book_part  = root_book_part
+  end
+
+  attr_reader :archive_version, :uuid, :version
+
+  def archive
+    @archive ||= OpenStax::Content::Archive.new archive_version
+  end
+
+  def url
+    @url ||= archive.url_for "#{uuid}@#{version}"
+  end
+
+  def url_fragment
+    @url_fragment ||= url.chomp('.json')
+  end
+
+  def baked
+    @baked ||= hash['baked']
+  end
+
+  def collated
+    @collated ||= hash.fetch('collated', false)
+  end
+
+  def hash
+    @hash ||= archive.json url
+  end
+
+  def uuid
+    @uuid ||= hash.fetch('id')
+  end
+
+  def short_id
+    @short_id ||= hash['shortId']
+  end
+
+  def version
+    @version ||= hash.fetch('version')
+  end
+
+  def title
+    @title ||= hash.fetch('title')
+  end
+
+  def tree
+    @tree ||= hash.fetch('tree')
+  end
+
+  def root_book_part
+    @root_book_part ||= OpenStax::Content::BookPart.new(hash: tree, is_root: true, book: self)
+  end
+end

data/lib/openstax/content/book_part.rb

@@ -0,0 +1,47 @@
+require_relative 'title'
+require_relative 'page'
+
+class OpenStax::Content::BookPart
+  def initialize(hash: {}, is_root: false, book: nil)
+    @hash = hash
+    @is_root = is_root
+    @book = book
+  end
+
+  attr_reader :hash, :is_root, :book
+
+  def parsed_title
+    @parsed_title ||= OpenStax::Content::Title.new hash.fetch('title')
+  end
+
+  def book_location
+    @book_location ||= parsed_title.book_location
+  end
+
+  def title
+    @title ||= parsed_title.text
+  end
+
+  # Old content used to have id == "subcol" for units and chapters
+  # If we encounter that, just assign a random UUID to them
+  def uuid
+    @uuid ||= begin
+      uuid = hash['id']
+      uuid.nil? || uuid == 'subcol' ? SecureRandom.uuid : uuid.split('@').first
+    end
+  end
+
+  def contents
+    @contents ||= hash.fetch('contents')
+  end
+
+  def parts
+    @parts ||= contents.map do |hash|
+      if hash.has_key? 'contents'
+        self.class.new book: book, hash: hash
+      else
+        OpenStax::Content::Page.new book: book, hash: hash
+      end
+    end
+  end
+end

data/lib/openstax/content/custom_css.rb

@@ -0,0 +1,9 @@
+require 'singleton'
+
+class OpenStax::Content::CustomCss
+  include Singleton
+
+  define_method(:'has-descendants') do |node_set, selector, number = 1|
+    node_set.select { |node| node.css(selector).size >= number }
+  end
+end

data/lib/openstax/content/fragment.rb

@@ -0,0 +1,19 @@
+# All fragment subclasses must be serializable with to_yaml and YAML.load
+# Nokogiri nodes are not serializable, so they must be processed in the initialize method
+class OpenStax::Content::Fragment
+  attr_reader :title, :labels, :node_id
+
+  def initialize(node:, title: nil, labels: nil)
+    @title  = title
+    @labels = labels || []
+    @node_id = node[:id]
+  end
+
+  def blank?
+    false
+  end
+
+  def html?
+    false
+  end
+end

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

@@ -0,0 +1,67 @@
+require_relative 'html'
+
+class OpenStax::Content::Fragment::Embedded < OpenStax::Content::Fragment::Html
+  # Used to get the title
+  TITLE_CSS = '[data-type="title"]'
+
+  # Used to get the title if there are no title nodes
+  LABEL_ATTRIBUTE = '[data-label]'
+
+  # CSS to find embedded content urls
+  TAGGED_URL_CSS = 'iframe.os-embed, a.os-embed, .os-embed iframe, .os-embed a'
+  UNTAGGED_URL_CSS = 'iframe, a'
+
+  CLASS_ATTRIBUTES = [ :iframe_classes, :iframe_title, :default_width, :default_height ]
+
+  class << self
+    attr_accessor *CLASS_ATTRIBUTES
+
+    def inherited(subclass)
+      CLASS_ATTRIBUTES.each do |class_attribute|
+        subclass.send "#{class_attribute}=", send(class_attribute)
+      end
+    end
+  end
+
+  self.iframe_classes = ['os-embed']
+  self.iframe_title = ''
+
+  CLASS_ATTRIBUTES.each do |class_attribute|
+    define_method(class_attribute) { self.class.send class_attribute }
+  end
+
+  attr_reader :url, :width, :height
+
+  def initialize(node:, title: nil, labels: nil)
+    super
+
+    @title ||= begin
+      title_nodes = @node.css(TITLE_CSS)
+      titles = title_nodes.empty? ? @node.css(LABEL_ATTRIBUTE).map do |label|
+        label.attr('data-label')
+      end : title_nodes.map { |node| node.content.strip }
+      titles.uniq.join('; ')
+    end
+
+    url_node = @node.at_css(TAGGED_URL_CSS) || @node.css(UNTAGGED_URL_CSS).last
+
+    @width = url_node&.[]('width') || default_width
+    @height = url_node&.[]('height') || default_height
+    @url = url_node&.[]('src') || url_node&.[]('href')
+
+    if url_node&.name == 'iframe'
+      node_classes = url_node['class'].to_s.split(' ') + iframe_classes
+      url_node['class'] = node_classes.uniq.join(' ')
+      url_node['title'] ||= iframe_title
+      # To always force the default iframe size, change ||= to =
+      url_node['width'] ||= default_width
+      url_node['height'] ||= default_height
+    end
+
+    @to_html = @node.to_html
+  end
+
+  def blank?
+    url.nil? || url.empty?
+  end
+end

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

@@ -0,0 +1,56 @@
+require_relative '../fragment'
+
+class OpenStax::Content::Fragment::Exercise < OpenStax::Content::Fragment
+  # CSS to find the embed code attributes
+  EXERCISE_EMBED_URL_CSS = 'a[href^="#"]'
+
+  # Regex to extract the appropriate tag from the embed code(s)
+  EXERCISE_EMBED_URL_REGEXES = {
+    tag: /\A#ost\/api\/ex\/([\w\s-]+)\z/,
+    nickname: /\A#exercises?\/([\w\s-]+)\z/
+  }
+
+  # CSS to find the exercise embed queries after the urls are absolutized
+  ABSOLUTIZED_EMBED_URL_CSS = 'a[href*="/api/exercises"]'
+
+  # Regex to extract the appropriate embed queries from the absolutized urls
+  ABSOLUTIZED_EMBED_URL_REGEX = \
+    /\/api\/exercises\/?\?q=(tag|nickname)(?::|%3A)(?:"|%22)?([\w\s%-]+?)(?:"|%22)?\z/
+
+  attr_reader :embed_queries
+
+  # This code is run from lib/openstax/cnx/v1/page.rb during import
+  def self.absolutize_exercise_urls!(node)
+    uri = Addressable::URI.parse OpenStax::Content.exercises_search_api_url
+
+    node.css(EXERCISE_EMBED_URL_CSS).each do |anchor|
+      href = anchor.attribute('href')
+
+      EXERCISE_EMBED_URL_REGEXES.each do |field, regex|
+        embed_match = regex.match(href.value)
+        next if embed_match.nil?
+
+        uri.query_values = { q: "#{field}:\"#{embed_match[1]}\"" }
+        href.value = uri.to_s
+        anchor['data-type'] = 'exercise'
+        break
+      end
+    end
+  end
+
+  def initialize(node:, title: nil, labels: [])
+    super
+
+    @embed_queries = node.css(ABSOLUTIZED_EMBED_URL_CSS).map do |anchor|
+      url = anchor.attribute('href').value
+      match = ABSOLUTIZED_EMBED_URL_REGEX.match(url)
+      next if match.nil?
+
+      [ match[1].to_sym, URI.decode_www_form_component(match[2]) ]
+    end.compact
+  end
+
+  def blank?
+    embed_queries.empty? && (node_id.nil? || node_id.empty?)
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'addressable/uri'
+
+require_relative '../fragment'
+
+class OpenStax::Content::Fragment::Html < OpenStax::Content::Fragment
+  attr_reader :to_html
+
+  def initialize(node:, title: nil, labels: nil)
+    super
+
+    @node = Nokogiri::HTML.fragment node.to_html
+    @to_html = @node.to_html
+  end
+
+  def as_json(*args)
+    # Don't attempt to serialize @node (it would fail)
+    super.except('node')
+  end
+
+  def html?
+    !to_html.empty?
+  end
+
+  def blank?
+    !html?
+  end
+
+  def node
+    @node ||= Nokogiri::HTML.fragment to_html
+  end
+
+  def has_css?(css, custom_css)
+    !node.at_css(css, custom_css).nil?
+  end
+
+  def append(new_node)
+    (node.at_css('body') || node.root) << new_node
+
+    @to_html = node.to_html
+  end
+
+  def transform_links!
+    node.css('[href]').each do |link|
+      href = link.attributes['href']
+      uri = Addressable::URI.parse(href.value) rescue nil
+
+      # Modify only fragment-only links
+      next if uri.nil? || uri.absolute? || !uri.path.empty?
+
+      # Abort if there is no target or it contains double quotes
+      # or it's still present in this fragment
+      target = uri.fragment
+      next if target.nil? || target.empty? || target.include?('"') ||
+              node.at_css("[id=\"#{target}\"], [name=\"#{target}\"]")
+
+      # Change the link to point to the reference view
+      href.value = "#{@reference_view_url}##{target}"
+    end unless @reference_view_url.nil?
+
+    @to_html = node.to_html
+  end
+end