openstax_kitchen 1.0.0

data/lib/kitchen/element_enumerator.rb

@@ -0,0 +1,12 @@
+module Kitchen
+  class ElementEnumerator < ElementEnumeratorBase
+
+    def self.factory
+      ElementEnumeratorFactory.new(
+        sub_element_class: Element,
+        enumerator_class: self
+      )
+    end
+
+  end
+end

data/lib/kitchen/element_enumerator_base.rb

@@ -0,0 +1,101 @@
+module Kitchen
+  class ElementEnumeratorBase < Enumerator
+
+    def initialize(size=nil, css_or_xpath: nil, upstream_enumerator: nil)
+      @css_or_xpath = css_or_xpath
+      @upstream_enumerator = upstream_enumerator
+      super(size)
+    end
+
+    def search_history
+      (@upstream_enumerator&.search_history || SearchHistory.empty).add(@css_or_xpath)
+    end
+
+    def terms(css_or_xpath=nil, &block)
+      chain_to(TermElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    def pages(css_or_xpath=nil, &block)
+      chain_to(PageElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    def chapters(css_or_xpath=nil, &block)
+      chain_to(ChapterElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    # use block_error_if
+    def figures(css_or_xpath=nil, &block)
+      chain_to(FigureElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    def notes(css_or_xpath=nil, &block)
+      chain_to(NoteElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    def tables(css_or_xpath=nil, &block)
+      chain_to(TableElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    def examples(css_or_xpath=nil, &block)
+      chain_to(ExampleElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    def search(css_or_xpath=nil, &block)
+      chain_to(ElementEnumerator, css_or_xpath: css_or_xpath, &block)
+    end
+
+    def chain_to(enumerator_class, css_or_xpath: nil, &block)
+      raise(RecipeError, "Did you forget a `.each` call on this enumerator?") if block_given?
+
+      enumerator_class.factory.build_within(self, css_or_xpath: css_or_xpath)
+    end
+
+    def first!(missing_message: "Could not return a first result")
+      first || raise(RecipeError, "#{missing_message} matching #{search_history.latest} " \
+                                  "inside [#{search_history.upstream}]")
+    end
+
+    # Removes enumerated elements from their parent and places them on the specified clipboard
+    #
+    # @param to [Symbol, String, Clipboard, nil] the name of the clipboard (or a Clipboard
+    #   object) to cut to. String values are converted to symbols. If not provided, the
+    #   elements are placed on a new clipboard.
+    # @return [Clipboard] the clipboard
+    #
+    def cut(to: nil)
+      to ||= Clipboard.new
+      self.each do |element|
+        element.cut(to: to)
+      end
+      to
+    end
+
+    # Makes a copy of the enumerated elements and places them on the specified clipboard.
+    #
+    # @param to [Symbol, String, Clipboard, nil] the name of the clipboard (or a Clipboard
+    #   object) to copy to.  String values are converted to symbols.  If not provided, the
+    #   copies are placed on a new clipboard.
+    # @return [Clipboard] the clipboard
+    #
+    def copy(to: nil)
+      to ||= Clipboard.new
+      self.each do |element|
+        element.copy(to: to)
+      end
+      to
+    end
+
+    def trash
+      self.each(&:trash)
+    end
+
+    def [](index)
+      to_a[index]
+    end
+
+    def to_s
+      self.map(&:to_s).join("")
+    end
+
+  end
+end

data/lib/kitchen/element_enumerator_factory.rb

@@ -0,0 +1,111 @@
+module Kitchen
+  class ElementEnumeratorFactory
+
+    attr_reader :default_css_or_xpath
+    attr_reader :enumerator_class
+    attr_reader :sub_element_class
+    attr_reader :detect_sub_element_class
+
+    def initialize(default_css_or_xpath: nil, sub_element_class: nil,
+                   enumerator_class:, detect_sub_element_class: false)
+      @default_css_or_xpath = default_css_or_xpath
+      @sub_element_class = sub_element_class
+      @enumerator_class = enumerator_class
+      @detect_sub_element_class = detect_sub_element_class
+    end
+
+    # TODO spec this!
+    def apply_default_css_or_xpath_and_normalize(css_or_xpath=nil)
+      css_or_xpath ||= "$"
+      [css_or_xpath].flatten.each {|item| item.gsub!(/\$/, [default_css_or_xpath].flatten.join(", ")) }
+      [css_or_xpath].flatten
+    end
+
+    def build_within(enumerator_or_element, css_or_xpath: nil)
+      css_or_xpath = apply_default_css_or_xpath_and_normalize(css_or_xpath)
+
+      case enumerator_or_element
+      when ElementBase
+        build_within_element(enumerator_or_element, css_or_xpath: css_or_xpath)
+      when ElementEnumeratorBase
+        build_within_other_enumerator(enumerator_or_element, css_or_xpath: css_or_xpath)
+      end
+    end
+
+    def or_with(other_factory)
+      self.class.new(
+        default_css_or_xpath: default_css_or_xpath + ", " + other_factory.default_css_or_xpath,
+        enumerator_class: TypeCastingElementEnumerator,
+        detect_sub_element_class: true
+      )
+    end
+
+    protected
+
+    def build_within_element(element, css_or_xpath:)
+      enumerator_class.new(css_or_xpath: css_or_xpath) do |block|
+        grand_ancestors = element.ancestors
+        parent_ancestor = Ancestor.new(element)
+
+        num_sub_elements = 0
+
+        element.raw.search(*css_or_xpath).each_with_index do |sub_node, index|
+          sub_element = ElementFactory.build_from_node(
+                          node: sub_node,
+                          document: element.document,
+                          element_class: sub_element_class,
+                          default_short_type: Utils.search_path_to_type(css_or_xpath),
+                          detect_element_class: detect_sub_element_class
+                        )
+
+          # If the provided `css_or_xpath` has already been counted, we need to uncount
+          # them on the ancestors so that when they are counted again below, the counts
+          # are correct.  Only do this on the first loop!
+          if index == 0
+            if element.have_sub_elements_already_been_counted?(css_or_xpath)
+              grand_ancestors.values.each do |ancestor|
+                ancestor.decrement_descendant_count(
+                  sub_element.short_type,
+                  by: element.number_of_sub_elements_already_counted(css_or_xpath)
+                )
+              end
+            end
+          end
+
+          # Record this sub element's ancestors and increment their descendant counts
+          sub_element.add_ancestors(grand_ancestors, parent_ancestor)
+          sub_element.count_as_descendant
+
+          # Remember how this sub element was found so can trace search history given
+          # any element.
+          sub_element.css_or_xpath_that_found_me = css_or_xpath
+
+          # Count runs through this loop for below
+          num_sub_elements += 1
+
+          # Mark the location so that if there's an error we can show the developer where.
+          sub_element.document.location = sub_element
+
+          block.yield(sub_element)
+        end
+
+        element.remember_that_sub_elements_are_already_counted(
+          css_or_xpath: css_or_xpath, count: num_sub_elements
+        )
+      end
+    end
+
+    def build_within_other_enumerator(other_enumerator, css_or_xpath:)
+      # Return a new enumerator instance that internally iterates over `other_enumerator`
+      # running a new enumerator for each element returned by that other enumerator.
+      enumerator_class.new(css_or_xpath: css_or_xpath, upstream_enumerator: other_enumerator) do |block|
+        other_enumerator.each do |element|
+          build_within_element(element, css_or_xpath: css_or_xpath).each do |sub_element|
+            block.yield(sub_element)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/kitchen/element_factory.rb

@@ -0,0 +1,32 @@
+module Kitchen
+  class ElementFactory
+
+    ELEMENT_CLASSES = ElementBase.descendants
+
+    def self.specific_element_class_for_node(node)
+      ELEMENT_CLASSES.find do |klass|
+        klass.is_the_element_class_for?(node)
+      end || Element
+    end
+
+    def self.build_from_node(node:,
+                             document:,
+                             element_class: nil,
+                             default_short_type: nil,
+                             detect_element_class: false)
+      element_class ||= detect_element_class ?
+                        specific_element_class_for_node(node) :
+                        Element
+
+      if element_class == Element
+        element_class.new(node: node,
+                              document: document,
+                              short_type: default_short_type)
+      else
+        element_class.new(node: node,
+                              document: document)
+      end
+    end
+
+  end
+end

data/lib/kitchen/errors.rb

@@ -0,0 +1,4 @@
+module Kitchen
+  class RecipeError < StandardError; end
+  class ElementNotFoundError < StandardError; end
+end

data/lib/kitchen/example_element.rb

@@ -0,0 +1,20 @@
+module Kitchen
+  class ExampleElement < ElementBase
+
+    def initialize(node:, document: nil)
+      super(node: node,
+            document: document,
+            enumerator_class: ExampleElementEnumerator,
+            short_type: :example)
+    end
+
+    def titles
+      search("span[data-type='title']")
+    end
+
+    def self.is_the_element_class_for?(node)
+      node['data-type'] == "example"
+    end
+
+  end
+end

data/lib/kitchen/example_element_enumerator.rb

@@ -0,0 +1,13 @@
+module Kitchen
+  class ExampleElementEnumerator < ElementEnumeratorBase
+
+    def self.factory
+      ElementEnumeratorFactory.new(
+        default_css_or_xpath: "div[data-type='example']", # TODO element.document.selectors.example
+        sub_element_class: ExampleElement,
+        enumerator_class: self
+      )
+    end
+
+  end
+end

data/lib/kitchen/figure_element.rb

@@ -0,0 +1,20 @@
+module Kitchen
+  class FigureElement < ElementBase
+
+    def initialize(node:, document: nil)
+      super(node: node,
+            document: document,
+            enumerator_class: FigureElementEnumerator,
+            short_type: :figure)
+    end
+
+    def caption
+      first("figcaption")
+    end
+
+    def self.is_the_element_class_for?(node)
+      node.name == "figure"
+    end
+
+  end
+end

data/lib/kitchen/figure_element_enumerator.rb

@@ -0,0 +1,13 @@
+module Kitchen
+  class FigureElementEnumerator < ElementEnumeratorBase
+
+    def self.factory
+      ElementEnumeratorFactory.new(
+        default_css_or_xpath: "figure", # TODO get from config?
+        sub_element_class: FigureElement,
+        enumerator_class: self
+      )
+    end
+
+  end
+end

data/lib/kitchen/mixins/block_error_if.rb

@@ -0,0 +1,19 @@
+module Kitchen
+  module Mixins
+    module BlockErrorIf
+
+      def block_error_if(block_given)
+        calling_method = begin
+          this_method_location_index = caller_locations.find_index do |location|
+            location.label == "block_error_if"
+          end
+
+          caller_locations[(this_method_location_index || -1) + 1].label
+        end
+
+        raise(RecipeError, "The `#{calling_method}` method does not take a block argument") if block_given
+      end
+
+    end
+  end
+end

data/lib/kitchen/note_element.rb

@@ -0,0 +1,43 @@
+module Kitchen
+  class NoteElement < ElementBase
+
+    TITLE_TRANSLATION_KEYS = %w(
+      link-to-learning
+      everyday-life
+      sciences-interconnect
+      chemist-portrait
+    )
+
+    def initialize(node:, document: nil)
+      super(node: node,
+            document: document,
+            enumerator_class: NoteElementEnumerator,
+            short_type: :note)
+    end
+
+    def title
+      block_error_if(block_given?)
+      first("[data-type='title']")
+    end
+
+    def indicates_autogenerated_title?
+      translation_key_in(TITLE_TRANSLATION_KEYS).present?
+    end
+
+    def autogenerated_title
+      translation_key = translation_key_in(TITLE_TRANSLATION_KEYS)
+      I18n.t(:"notes.#{document.short_name}.#{translation_key}", default: :"notes.#{translation_key}")
+    end
+
+    def translation_key_in(possible_translation_keys)
+      keys = possible_translation_keys & classes
+      raise("too many translation keys: #{keys.join(', ')}") if keys.many?
+      keys.first
+    end
+
+    def self.is_the_element_class_for?(node)
+      node['data-type'] == "note"
+    end
+
+  end
+end

data/lib/kitchen/note_element_enumerator.rb

@@ -0,0 +1,13 @@
+module Kitchen
+  class NoteElementEnumerator < ElementEnumeratorBase
+
+    def self.factory
+      ElementEnumeratorFactory.new(
+        default_css_or_xpath: "div[data-type='note']", # TODO get from config?
+        sub_element_class: NoteElement,
+        enumerator_class: self
+      )
+    end
+
+  end
+end

data/lib/kitchen/oven.rb

@@ -0,0 +1,61 @@
+module Kitchen
+  class Oven
+
+    def self.bake(input_file:,
+                  config_file: nil,
+                  recipes:,
+                  output_file:)
+
+      profile = BakeProfile.new
+      profile.started!
+
+      nokogiri_doc = File.open(input_file) do |f|
+        profile.opened!
+        Nokogiri::XML(f).tap { profile.parsed! }
+      end
+
+      config = config_file.nil? ? nil : Config.new_from_file(File.open(config_file))
+
+      doc = Kitchen::Document.new(
+        nokogiri_document: nokogiri_doc,
+        config: config
+      )
+
+      [recipes].flatten.each do |recipe|
+        recipe.document = doc
+        recipe.bake
+      end
+      profile.baked!
+
+      File.open(output_file, "w") do |f|
+        f.write doc.to_xhtml(indent:2)
+      end
+      profile.written!
+
+      profile
+    end
+
+    class BakeProfile
+      def started!; @started_at = Time.now; end
+      def opened!;  @opened_at = Time.now;  end
+      def parsed!;  @parsed_at = Time.now;  end
+      def baked!;   @baked_at = Time.now;   end
+      def written!; @written_at = Time.now; end
+
+      def open_seconds;  @opened_at  - @started_at; end
+      def parse_seconds; @parsed_at  - @opened_at;  end
+      def bake_seconds;  @baked_at   - @parsed_at;  end
+      def write_seconds; @written_at - @baked_at;   end
+
+      def to_s
+        <<~STRING
+          Open:  #{open_seconds} s
+          Parse: #{parse_seconds} s
+          Bake:  #{bake_seconds} s
+          Write: #{write_seconds} s
+        STRING
+      end
+    end
+
+  end
+end