article_fixture_gen 0.1.1

data/lib/article_fixture_gen/data/build_word_list.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'prolog/dry_types'
+
+require_relative './build_fragment_list'
+
+module ArticleFixtureGen
+  module Data
+    # Value object associating a "word" (non-whitespace substring of a text leaf
+    # node) with a DOM position and an index within that leaf node.
+    class WordEntry < Dry::Struct::Value
+      attribute :dom_position, Types::Strict::Array.member(Types::Strict::Int)
+      attribute :word, Types::Strict::String
+      attribute :word_index, Types::Strict::Int.constrained(gteq: 0)
+
+      def <=>(other)
+        WordEntryComparator.call(self, other)
+      end
+    end # class ArticleFixtureGen::Data::WordEntry
+
+    # Compares two WordEntry instances to each other, per comparison interface.
+    class WordEntryComparator
+      def self.call(obj, other)
+        WordEntryComparator.new(obj, other).call
+      end
+
+      def call
+        Internals.first_nonzero([dom_difference, index_difference]) || 0
+        # [dom_difference, index_difference].reject(&:zero?).first
+      end
+
+      protected
+
+      def initialize(obj, other)
+        @obj = obj
+        @other = other
+        self
+      end
+
+      private
+
+      def dom_difference
+        @obj.dom_position <=> @other.dom_position
+      end
+
+      def index_difference
+        @obj.word_index <=> @other.word_index
+      end
+
+      # Stateless methods.
+      module Internals
+        def self.first_nonzero(values)
+          _nonzero_values_for(values).first
+        end
+
+        def self._nonzero_values_for(values)
+          values.select(&:nonzero?)
+        end
+      end
+      private_constant :Internals
+    end # class ArticleFixtureGen::Data::WordEntryComparator
+
+    # Builds an array of WordEntry items, associating fragments of DOM text leaf
+    # nodes with position information of their containing node within the DOM
+    # and of the fragment within a (whitespace-split) array of fragments within
+    # the containing DOM node's text.
+    class BuildWordList
+      def self.call(parent_node:, dom_position: [])
+        BuildWordList.new(parent_node, dom_position).call
+      end
+
+      def call
+        ret = string_items.map do |string_item|
+          Internals.entries_for string_item
+        end
+        ret.flatten
+      end
+
+      protected
+
+      def initialize(parent_node, dom_position)
+        @dom_position = dom_position
+        @parent_node = parent_node
+        self
+      end
+
+      private
+
+      attr_reader :dom_position, :parent_node
+
+      def string_items
+        BuildFragmentList.call(parent_node: parent_node, position: dom_position)
+      end
+
+      # Statelesss methods
+      module Internals
+        def self.entries_for(string_item)
+          EntriesForStringItem.call string_item: string_item
+        end
+      end
+      private_constant :Internals
+
+      # Build an arary of WordEntry instances for "words" in a "string item".
+      class EntriesForStringItem
+        def self.call(string_item:)
+          EntriesForStringItem.new(string_item).call
+        end
+
+        def call
+          words.map { |word| entry_for word }
+        end
+
+        protected
+
+        def initialize(string_item)
+          @position = string_item.position
+          @word_index = 0
+          @words = string_item.string.split
+          self
+        end
+
+        private
+
+        attr_reader :position, :word_index, :words
+
+        def entry_for(word)
+          ret = WordEntry.new entry_params_for(word)
+          @word_index += 1
+          ret
+        end
+
+        def entry_params_for(word)
+          { dom_position: position, word: word, word_index: word_index }
+        end
+      end # class EntriesForStringItem
+      private_constant :EntriesForStringItem
+    end # class ArticleFixtureGen::Data::BuildWordList
+  end
+end

data/lib/article_fixture_gen/data/marker_array.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative './marker_tag_pair'
+
+module ArticleFixtureGen
+  module Data
+    # Builds an array of marker-tag ID strings.
+    # FIXME: This should be `BuildMarkerArray` or similar.
+    class MarkerArray
+      def self.call(attributes:)
+        new(attributes).call
+      end
+
+      def call
+        @attributes.map do |attrib|
+          mtp = MarkerTagPair.call id_string: attrib.id_string
+          NodeFromMarkup.call mtp
+        end
+      end
+
+      protected
+
+      def initialize(attributes)
+        @attributes = attributes
+        self
+      end
+    end # class ArticleFixtureGen::Data::MarkerArray
+  end
+end

data/lib/article_fixture_gen/data/marker_tag_pair.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ArticleFixtureGen
+  module Data
+    # Builds an HTML marker tag pair, either a single MTP or a paired MTP; we
+    # don't care at this level (the conventions for ID attributes distinguishing
+    # one from the other are applied at a higher level).
+    class MarkerTagPair
+      def self.call(id_string:)
+        Internals.to_s(id_string)
+      end
+
+      FORMAT_STR = %(<a href="" id="%s"></a>)
+      private_constant :FORMAT_STR
+
+      # Stateless methods.
+      module Internals
+        def self.to_s(id_attrib)
+          format FORMAT_STR, id_attrib
+        end
+      end
+      private_constant :Internals
+    end # class ArticleFixtureGen::Data::MarkerTagPair
+  end
+end

data/lib/article_fixture_gen/data/mtp_decorated_markup.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative './build_target_entry_list'
+require_relative './marker_array'
+require_relative './node_markup'
+require_relative './replace_child_nodes_using_new_child'
+require_relative './split_text_at_target_word'
+
+module ArticleFixtureGen
+  module Data
+    # Shared logic for marker tag pairs, both single MTPs and paired MTPs. This
+    # has been reworked so that the `attributes` parameter specifies the number
+    # of marker-tag pairs to be generated, by specifying the ID attributes of
+    # each MTP to be generated, working from the end of the content toward the
+    # beginning. From the standpoint of this class and its collaborators, doing
+    # so eliminates any need to differentiate between sMTPs and pMTPs, since
+    # each marker-tag pair is generated based on passed-in information.
+    class MtpDecoratedMarkup
+      def self.call(attributes:, base_markup:)
+        new(attributes).call(base_markup)
+      end
+
+      def call(base_markup)
+        parent_node = NodeFromMarkup.call base_markup
+        add_entries(parent_node)
+        MarkupFromNode.call parent_node
+      end
+
+      protected
+
+      def initialize(attributes)
+        @attributes = attributes
+        @markers = build_markers
+        self
+      end
+
+      private
+
+      attr_reader :attributes, :markers
+
+      def add_entries(parent_node)
+        each_entry_for(parent_node) do |target_entry, index|
+          add_marker(parent_node, target_entry, markers[index])
+        end
+      end
+
+      def add_marker(parent_node, target_entry, marker)
+        ReplaceChildNodesUsingNewChild.call(parent_node, target_entry, marker)
+        self
+      end
+
+      def build_markers
+        MarkerArray.call attributes: attributes
+      end
+
+      def each_entry_for(parent_node)
+        target_entries(parent_node).each_with_index do |target_entry, index|
+          yield target_entry, index
+        end
+      end
+
+      def target_entries(parent_node)
+        BuildTargetEntryList.call(parent_node, attributes.count)
+      end
+    end # class ArticleFixtureGen::Data::MtpDecoratedMarkup
+  end
+end

data/lib/article_fixture_gen/data/node_markup.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'ox'
+
+module ArticleFixtureGen
+  module Data
+    # Render an Ox::Element instance as HTML.
+    class MarkupFromNode
+      DEFAULT_OPTIONS = { indent: -1 }.freeze
+
+      def self.call(node, options = DEFAULT_OPTIONS)
+        Ox.dump(node, options)
+      end
+    end # class ArticleFixtureGen::Data::MarkupFromNode
+
+    # Convert an HTML string to an Ox::Element.
+    # NOTE: HTML *must* comprise a single outermost element, that may have an
+    #       arbitrary number of nested elements within it.
+    class NodeFromMarkup
+      def self.call(markup)
+        Ox.parse(markup)
+      end
+    end # class ArticleFixtureGen::Data::NodeFromMarkup
+  end
+end

data/lib/article_fixture_gen/data/parent_element_for.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ArticleFixtureGen
+  module Data
+    # Given a parent element and an array of integers which fully specify the
+    # DOM position of a node (or element, really), walk the DOM from the given
+    # parent to find the element which contains a node at the specified point
+    # below that parent. This is to work around the fact that Ox maintains no
+    # links between a node (or element) with its parent.
+    class ParentElementFor
+      def self.call(parent, dom_pos_indexes)
+        el = parent
+        dom_pos_indexes[0..-2].each { |index| el = el.nodes[index] }
+        el
+      end
+    end # class ArticleFixtureGen::Data::ParentElementFor
+  end
+end

data/lib/article_fixture_gen/data/pmtp_attributes.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ArticleFixtureGen
+  module Data
+    # Wraps attributes for a single marker-tag pair instance. Initially, the
+    # only attribute supported is `:id_string`.
+    class PmtpAttributes
+      include Enumerable
+
+      def initialize(config:)
+        @items = build_all_items(config.pmtp_count, config.pmtp_text)
+        self
+      end
+
+      def each(&_block)
+        @items.each { |item| yield item }
+      end
+
+      private
+
+      attr_reader :items
+
+      def build_all_items(count, text)
+        Array.new(count) { build_items(text) }.flatten
+      end
+
+      def build_items(text, rand_limit: 10_000)
+        id_num = rand(rand_limit) + 1
+        begin_item = Internals.build_item(text, id_num, 'begin')
+        end_item = Internals.build_item(text, id_num, 'end')
+        [end_item, begin_item]
+      end
+
+      # Stateless methods.
+      module Internals
+        def self.build_item(text, id_number, end_str)
+          id_string = "#{text}-#{id_number}-#{end_str}"
+          Struct.new(:id_string).new(id_string).freeze
+        end
+      end
+      private_constant :Internals
+    end # class ArticleFixtureGen::Data::PmtpAttributes
+  end
+end

data/lib/article_fixture_gen/data/pmtp_decorated_markup.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative './mtp_decorated_markup'
+require_relative './pmtp_decorator_params'
+
+module ArticleFixtureGen
+  module Data
+    # Generate a copy of the specified base content with single marker-tag pairs
+    # inserted before random words in the content.
+    #
+    # Parameters:
+    # `base_markup`: *Must* be a string representing a single HTML element with
+    #                child nodes, some containing text strings. The canonical
+    #                example is article-body markup presented as a containing
+    #                `div` with paragraphs and so on;
+    # `config`:      A configuration-information object, which *must* respond to
+    #                the `:pmtp_text` message with a string, and *must* respond
+    #                to the `:pmtp_count` message with a non-negative integer.
+    #
+    class PmtpDecoratedMarkup
+      def self.call(base_markup:, config:, param_builder: PmtpDecoratorParams)
+        params = param_builder.call(base_markup: base_markup, config: config)
+        MtpDecoratedMarkup.call(params)
+      end
+    end # class ArticleFixtureGen::Data::PmtpDecoratedMarkup
+  end
+end

data/lib/article_fixture_gen/data/pmtp_decorator_params.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative './pmtp_attributes'
+
+module ArticleFixtureGen
+  module Data
+    # Builds a parameter hash for calling `MtpDecoratedMarkup` to decorate
+    # markup with paired MTPs (as opposed to single MTPs).
+    class PmtpDecoratorParams
+      def self.call(base_markup:, config:)
+        attributes = PmtpAttributes.new config: config
+        { attributes: attributes, base_markup: base_markup }
+      end
+    end # class ArticleFixtureGen::Data::SmtpDecoratorParams
+  end
+end

data/lib/article_fixture_gen/data/replace_child_nodes_using_new_child.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative './parent_element_for'
+require_relative './split_text_at_target_word'
+
+module ArticleFixtureGen
+  module Data
+    # Replaces the (INTERNAL!) list of child nodes of an element with a list
+    # generated elsewhere (that replaces a single text node with two text nodes
+    # separated by a new element).
+    class ReplaceChildNodesUsingNewChild
+      def self.call(parent_node, target_entry, new_el)
+        new(parent_node, target_entry, new_el).call
+      end
+
+      def call
+        element.instance_variable_set :@nodes, nodes
+      end
+
+      protected
+
+      def initialize(parent_node, target_entry, new_el)
+        @element = ParentElementFor.call(parent_node, target_entry.dom_position)
+        @target_entry = target_entry
+        @new_el = new_el
+        self
+      end
+
+      private
+
+      attr_reader :element, :new_el, :target_entry
+
+      def leading_nodes
+        element.nodes[leading_node_indexes]
+      end
+
+      def leading_node_indexes
+        0...node_index
+      end
+
+      def node_index
+        target_entry.dom_position.last
+      end
+
+      def nodes
+        parts = SplitTextAtTargetWord.call(element, target_entry)
+        replacement_nodes_for(parts)
+      end
+
+      def parts_and_element(parts)
+        parts.insert 1, new_el
+      end
+
+      def replacement_nodes_for(parts)
+        [leading_nodes, parts_and_element(parts), trailing_nodes].flatten(1)
+      end
+
+      def trailing_nodes
+        element.nodes[trailing_node_indexes]
+      end
+
+      def trailing_node_indexes
+        node_index + 1..-1
+      end
+    end # class ArticleFixtureGen::Data::ReplaceChildNodesUsingNewChild
+  end
+end

data/lib/article_fixture_gen/data/single_marker_tag_pair.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ArticleFixtureGen
+  module Data
+    # Encapsulates a "single marker-tag pair", or sMTP; an HTML anchor tag with
+    # a specifically-formatted ID attribute, an empty :href attribute, and no
+    # enclosed content. Different than a "paired marker-tag pair", which is
+    # analogous to two slightly differently-formatted sMTPs separated by content
+    # (and with no overlapping pMTPs).
+    class SingleMarkerTagPair
+      def initialize(config:, counter:)
+        @counter = counter
+        @label = config.smtp_text
+        IceNine.deep_freeze self
+      end
+
+      def to_html
+        ['<a href="" id="', '"></a>'].join html_id
+      end
+      alias_method :to_s, :to_html
+
+      private
+
+      attr_reader :counter, :label
+
+      def html_id
+        [label, counter.to_s].join '-'
+      end
+    end # class ArticleFixtureGen::Data::SingleMarkerTagPair
+  end
+end

data/lib/article_fixture_gen/data/smtp_attributes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ArticleFixtureGen
+  module Data
+    # Wraps attributes for a single marker-tag pair instance. Initially, the
+    # only attribute supported is `:id_string`.
+    class SmtpAttributes
+      include Enumerable
+
+      def initialize(config:)
+        text = config.smtp_text
+        @items = Array.new(config.smtp_count) { build_item(text) }
+        self
+      end
+
+      def each(&_block)
+        @items.each { |item| yield item }
+      end
+
+      private
+
+      attr_reader :items
+
+      def build_item(text, rand_limit: 10_000)
+        id_num = rand(rand_limit) + 1
+        Struct.new(:id_string).new "#{text}-#{id_num}"
+      end
+    end # class ArticleFixtureGen::Data::SmtpAttributes
+  end
+end

data/lib/article_fixture_gen/data/smtp_decorated_markup.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative './mtp_decorated_markup'
+require_relative './smtp_decorator_params'
+
+module ArticleFixtureGen
+  module Data
+    # Generate a copy of the specified base content with single marker-tag pairs
+    # inserted before random words in the content.
+    #
+    # Parameters:
+    # `base_markup`: *Must* be a string representing a single HTML element with
+    #                child nodes, some containing text strings. The canonical
+    #                example is article-body markup presented as a containing
+    #                `div` with paragraphs and so on;
+    # `config`:      A configuration-information object, which *must* respond to
+    #                the `:smtp_text` message with a string, and *must* respond
+    #                to the `:smtp_count` message with a non-negative integer.
+    #
+    class SmtpDecoratedMarkup
+      def self.call(base_markup:, config:, param_builder: SmtpDecoratorParams)
+        params = param_builder.call(base_markup: base_markup, config: config)
+        MtpDecoratedMarkup.call(params)
+      end
+    end # class ArticleFixtureGen::Data::SmtpDecoratedMarkup
+  end
+end

data/lib/article_fixture_gen/data/smtp_decorator_params.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative './smtp_attributes'
+
+module ArticleFixtureGen
+  module Data
+    # Builds a parameter hash for calling `MtpDecoratedMarkup` to decorate
+    # markup with single MTPs (as opposed to paired MTPs).
+    class SmtpDecoratorParams
+      def self.call(base_markup:, config:)
+        attributes = SmtpAttributes.new config: config
+        { attributes: attributes, base_markup: base_markup }
+      end
+    end # class ArticleFixtureGen::Data::SmtpDecoratorParams
+  end
+end

data/lib/article_fixture_gen/data/split_text_at_target_word.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ArticleFixtureGen
+  module Data
+    # Produces an array of two strings such that, for a specified text node
+    # (string), the first string will be the text before a specified word, and
+    # the second (last) string will be the text after that word. The word in
+    # question is specified by a child-node index relative to the `el` parameter
+    # (an `Ox::Element` instance) and a word index within that child node.
+    class SplitTextAtTargetWord
+      def self.call(el, target_entry)
+        new(el, target_entry).call
+      end
+
+      def call
+        [head, tail]
+      end
+
+      protected
+
+      def initialize(el, target_entry)
+        @original_text = Internals.original_text(el, target_entry)
+        @target_entry = target_entry
+        @word_index = target_entry.word_index
+        self
+      end
+
+      private
+
+      attr_reader :original_text, :target_entry, :word_index
+
+      def ends_in_space?
+        original_text[-1] == ' '
+      end
+
+      def head
+        words_in_range(0...word_index) + ' '
+      end
+
+      def tail
+        ret = words_in_range(word_index..-1)
+        ret += ' ' if ends_in_space?
+        ret
+      end
+
+      def words_in_range(range)
+        original_text.split[range].join(' ')
+      end
+
+      # Stateless methods.
+      module Internals
+        def self.original_text(el, target_entry)
+          el.nodes[target_entry.dom_position.last]
+        end
+      end
+      private_constant :Internals
+    end # class ArticleFixtureGen::Data::SplitTextAtTargetWord
+  end
+end

data/lib/article_fixture_gen/exe/config.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'article_fixture_gen/cli/config'
+
+module ArticleFixtureGen
+  module Exe
+    # Build configuration, consolidating defaults, possible YAML config-file
+    # contents, and possible command-line-specified settings.
+    class Config
+      def self.load(modified:, options:)
+        new(options, modified).load
+      end
+
+      def load
+        return config_based_on_file if config_given?
+        ArticleFixtureGen::Config.new options
+      end
+
+      protected
+
+      def initialize(options, modified)
+        @options = options.to_hash
+        @modified = modified.to_hash
+        self
+      end
+
+      private
+
+      attr_reader :modified, :options
+
+      def config_given?
+        options[:config_given] == true
+      end
+
+      def config_based_on_file
+        effective_options = { defaults: options, filename: options[:config],
+                              overrides: modified }
+        ArticleFixtureGen::CLI::Config.call effective_options
+      end
+    end # class ArticleFixtureGen::Exe::Config
+  end
+end