article_fixture_gen 0.1.1

data/exe/article_fixture_gen

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'article_fixture_gen'
+require 'article_fixture_gen/exe/config'
+require 'article_fixture_gen/exe/generate_config'
+require 'article_fixture_gen/exe/option_parser'
+
+parsed_options = ArticleFixtureGen::Exe::OptionParser.call.to_h
+config = ArticleFixtureGen::Exe::Config.load parsed_options
+ArticleFixtureGen::Exe::GenerateConfig.call(config) if config.generate_config_given
+
+articles = Array.new(config.article_count) do
+  ArticleFixtureGen::Data::Article.new(config: config).to_s
+end
+puts articles.join("\n\n")

data/lib/article_fixture_gen/cli/config.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+require 'article_fixture_gen/config'
+require 'article_fixture_gen/support/logging'
+
+module ArticleFixtureGen
+  module CLI
+    # CLI implementation class that reads YAML config from file and uses it to
+    # create an `ArticleFixtureGen::Config` instance.
+    class Config
+      def self.call(filename:, defaults: nil, overrides: {})
+        new(filename, defaults, overrides).call
+      end
+
+      def call
+        ArticleFixtureGen::Config.new final
+      end
+
+      protected
+
+      def initialize(filename, defaults, overrides)
+        @defaults = Internals.defaults_based_on(defaults)
+        @filename = filename
+        @overrides = overrides
+        self
+      end
+
+      private
+
+      attr_reader :defaults, :filename, :overrides
+
+      def file_contents
+        YAML.load_file filename
+      end
+
+      def final
+        defaults.merge(non_defaults)
+      end
+
+      def non_defaults
+        file_contents.merge(overrides)
+      end
+
+      # Stateless methods.
+      module Internals
+        # Reek complains about a :reek:ControlParameter. :pedantic: :neckbeard:
+        def self.defaults_based_on(specified_defaults)
+          ret = specified_defaults || ArticleFixtureGen::Config.defaults
+          ret.to_hash
+        end
+      end
+      private_constant :Internals
+    end # class ArticleFixtureGen::CLI::Config
+  end
+end

data/lib/article_fixture_gen/cli/dump_config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'awesome_print'
+
+require 'article_fixture_gen/config'
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Command-line-specific classes.
+  module CLI
+    # Report contents of configuration data.
+    class DumpConfig
+      # Reek doesn't like :reek:BooleanParameter. Tough.
+      def self.call(config:, use_colour: false)
+        DumpConfig.new(config).call use_colour
+      end
+
+      def call(use_colour)
+        @use_colour = use_colour
+        report
+      end
+
+      protected
+
+      def initialize(config)
+        @config = config.to_hash
+        self
+      end
+
+      private
+
+      attr_reader :config, :use_colour
+
+      def dump_options
+        { plain: !use_colour, sort_keys: true }
+      end
+
+      def report
+        config.ai dump_options
+      end
+    end # class ArticleFixtureGen::CLI::DumpConfig
+  end
+end

data/lib/article_fixture_gen/cli.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'article_fixture_gen'
+
+require 'article_fixture_gen/cli/dump_config'

data/lib/article_fixture_gen/config/builder.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'prolog/dry_types'
+
+require_relative './constants'
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Maintain configuration information for app.
+  class Config
+    # Builds hash with correct keys based on input. What's the value of this,
+    # you ask? Two things:
+    # 1. It defines `*_given` entries which are `true` if their corresponding
+    #    entries are specified, whether those other entries are truthy or not;
+    # 2. It confirms filtering of the input hash, offering a guarantee that any
+    #    entry accepted is one supported elsehwere in our code.
+    #
+    # And yes, this class is *awfully* procedural. Got ideas for a fix? We'd
+    # appreciate your PR!
+    class Builder
+      def self.call(options_hash)
+        new.call options_hash
+      end
+
+      def call(options)
+        @options = options
+        hashes
+      end
+
+      private
+
+      attr_reader :options
+
+      def config_hash
+        value = options[:config]
+        given = Internals.string_given?(value)
+        { config_given: given }.tap do |ret|
+          ret[:config] = value || ''
+        end
+      end
+
+      def generate_config_hash
+        value = options[:generate_config]
+        given = Internals.string_given?(value)
+        { generate_config_given: given }.tap do |ret|
+          ret[:generate_config] = value || ''
+        end
+      end
+
+      def hashes
+        items = hash_items
+        {}.tap do |ret|
+          items.each { |item| ret.merge! item }
+        end
+      end
+
+      def hash_items
+        items = [:config_hash, :generate_config_hash, :other_hash]
+        items.map { |sym| send(sym) }
+      end
+
+      def other_hash
+        ret = Internals.other_specified_values(options)
+        ret.merge! Internals.defaults_not_in(ret)
+      end
+
+      # Stateless methods.
+      module Internals
+        def self.defaults_not_in(hash)
+          keys = _other_keys_not_in(hash)
+          _defaults_for(keys)
+        end
+
+        def self.other_specified_values(options)
+          keys = _other_hash_keys
+          options.select { |key, _| keys.include? key }
+        end
+
+        def self.string_given?(value)
+          !value.to_s.empty?
+        end
+
+        def self._defaults_for(keys)
+          Constants::DEFAULTS.select { |key| keys.include? key }
+        end
+
+        def self._other_hash_keys
+          [:article_count, :para_count_max, :para_count_min, :sent_count_max,
+           :sent_count_min, :pmtp_count, :pmtp_text, :smtp_count, :smtp_text]
+        end
+
+        def self._other_keys_not_in(hash)
+          _other_hash_keys.reject { |key| hash.key? key }
+        end
+      end
+      private_constant :Internals
+    end # class ArticleFixtureGen::Config::Builder
+  end # class ArticleFixtureGen::Config
+end

data/lib/article_fixture_gen/config/constants.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Maintain configuration information for app.
+  class Config
+    # Constants used semi-internally to the class.
+    module Constants
+      DEFAULTS = {
+        article_count: 5,
+        config: '',
+        generate_config: '',
+        para_count_max: 10,
+        para_count_min: 2,
+        pmtp_count: 2,
+        pmtp_text: 'paired-mtp',
+        sent_count_max: 8,
+        sent_count_min: 1,
+        smtp_count: 4,
+        smtp_text: 'single-mtp'
+      }.freeze
+    end
+    # private_constant :Constants
+  end # class ArticleFixtureGen::Config
+end

data/lib/article_fixture_gen/config/data.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'prolog/dry_types'
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Maintain configuration information for app.
+  class Config
+    # Immutable value object containing config settings.
+    class Data < Dry::Struct::Value
+      attribute :article_count, Types::Strict::Int
+      attribute :config, Types::Strict::String.default('')
+      attribute :config_given, Types::Strict::Bool
+      attribute :generate_config, Types::String.default('')
+      attribute :generate_config_given, Types::Strict::Bool
+      attribute :para_count_max, Types::Strict::Int
+      attribute :para_count_min, Types::Strict::Int
+      attribute :pmtp_count, Types::Strict::Int
+      attribute :pmtp_text, Types::Strict::String
+      attribute :sent_count_max, Types::Strict::Int
+      attribute :sent_count_min, Types::Strict::Int
+      attribute :smtp_count, Types::Strict::Int
+      attribute :smtp_text, Types::Strict::String
+    end # class ArticleFixtureGen::Config::data
+  end # class ArticleFixtureGen::Config
+end

data/lib/article_fixture_gen/config/option_validator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Maintain configuration information for app.
+  class Config
+    # Encapsulates validations of configuration option values.
+    class OptionValidator
+      def self.call(options:)
+        OptionValidator.new.call(options)
+      end
+
+      def initialize
+        @errors = []
+        self
+      end
+
+      def call(options)
+        @options = options
+        FATALS.each { |entry| validate_option entry }
+        errors
+      end
+
+      private
+
+      attr_reader :errors, :options
+
+      FATALS = [
+        { key: :para_count_max, message: 'must be at least 1',
+          cond: -> (opts) { opts[:para_count_max] < 1 } },
+        { key: :para_count_max,
+          message: 'must be >= the value for --para_count_min',
+          cond: -> (opts) { opts[:para_count_max] < opts[:para_count_min] } },
+        { key: :para_count_min, message: 'must be at least 1',
+          cond: -> (opts) { opts[:para_count_min] < 1 } },
+        { key: :para_count_min,
+          message: 'must be <= the value for --para_count_max',
+          cond: -> (opts) { opts[:para_count_min] > opts[:para_count_max] } },
+        { key: :pmtp_count, message: 'must be at least 0',
+          cond: -> (opts) { (opts[:pmtp_count]).negative? } },
+        { key: :pmtp_text, message: 'may not be empty',
+          cond: -> (opts) { opts[:pmtp_text].to_s.strip.empty? } },
+        { key: :sent_count_max, message: 'must be at least 1',
+          cond: -> (opts) { opts[:sent_count_max] < 1 } },
+        { key: :sent_count_max,
+          message: 'must be >= the value for --sent_count_min',
+          cond: -> (opts) { opts[:sent_count_max] < opts[:sent_count_min] } },
+        { key: :sent_count_min, message: 'must be at least 1',
+          cond: -> (opts) { opts[:sent_count_min] < 1 } },
+        { key: :sent_count_min,
+          message: 'must be <= the value for --sent_count_max',
+          cond: -> (opts) { opts[:sent_count_min] > opts[:sent_count_max] } },
+        { key: :smtp_count, message: 'must be at least 0',
+          cond: -> (opts) { (opts[:smtp_count]).negative? } },
+        { key: :smtp_text, message: 'may not be empty',
+          cond: -> (opts) { opts[:smtp_text].to_s.strip.empty? } }
+      ].freeze
+      private_constant :FATALS
+
+      def fails?(entry)
+        entry[:cond].call(options)
+      end
+
+      # Reek and hashes = :reek:FeatureEnvy; aka petrol and flame. FIXME
+      def report_failure(entry)
+        @errors << [entry[:key], entry[:message]]
+      end
+
+      def validate_option(entry)
+        report_failure(entry) if fails?(entry)
+      end
+    end # class ArticleFixtureGen::Config::OptionValidator
+  end # class ArticleFixtureGen::Config
+end

data/lib/article_fixture_gen/config.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative './config/builder'
+require_relative './config/constants'
+require_relative './config/data'
+require_relative './config/option_validator'
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Maintain configuration information for app.
+  class Config
+    # Error raised when validating one or more attributes fails.
+    class ValidationError < RuntimeError
+    end # class ArticleFixtureGen::Config::ValidationError
+
+    extend Forwardable
+
+    def initialize(options_hash)
+      data = Builder.call(options_hash)
+      validate(data) # will raise if not valid
+      @values = Data.new data
+      self
+    end
+
+    def self.defaults
+      new Constants::DEFAULTS
+    end
+
+    def_delegators :@values, :article_count, :config, :config_given,
+                   :generate_config, :generate_config_given,
+                   :para_count_max, :para_count_min, :pmtp_count, :pmtp_text,
+                   :sent_count_max, :sent_count_min, :smtp_count, :smtp_text,
+                   :to_hash
+
+    private
+
+    def validate(data)
+      errors = OptionValidator.call options: data
+      return self if errors.empty?
+      raise ValidationError, errors.first
+    end
+  end # class ArticleFixtureGen::Config
+end

data/lib/article_fixture_gen/data/article.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'ffaker'
+
+require 'article_fixture_gen/data/article_content'
+require 'article_fixture_gen/data/pmtp_decorated_markup'
+require 'article_fixture_gen/data/smtp_decorated_markup'
+require 'article_fixture_gen/support/logging'
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Details of data built by the generator.
+  module Data
+    # Details of generated Article and internal details thereof.
+    class Article
+      # Reek kvetches about a :reek:ControlParameter. Too bad.
+      def initialize(config:, base_content: nil)
+        @config = config
+        logger = SemanticLogger['Article#initialize']
+        @base_content = base_content || Default.base_content(config)
+        logger.trace "Line #{__LINE__}", base_content: @base_content
+        @str = nil
+        self
+      end
+
+      def to_s
+        return @str if @str
+        str = add_mtps(base_content, PmtpDecoratedMarkup)
+        @str = add_mtps(str, SmtpDecoratedMarkup)
+      end
+
+      private
+
+      attr_reader :base_content, :config
+
+      def add_mtps(base_markup, decorator)
+        decorator.call(base_markup: base_markup, config: config).rstrip
+      end
+
+      # Default-value builders for #initialize parameters.
+      module Default
+        # FIXME: We would *prefer* `fancy: true`. However, there is the problem
+        #        of https://github.com/ffaker/ffaker/issues/298 to contend with.
+        DEFAULT_FAKER_OPTS = { fancy: false }.freeze
+
+        def self.base_content(config, faker_opts = DEFAULT_FAKER_OPTS)
+          ArticleContent.new(config: config) do |sentence_count|
+            FFaker::HTMLIpsum.p(sentence_count, faker_opts)
+          end.to_s
+        end
+      end
+      private_constant :Default
+    end # class ArticleFixtureGen::Data::Article
+  end
+end

data/lib/article_fixture_gen/data/article_content.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Generate blog post/article fixture data, with embedded marker tag pairs.
+module ArticleFixtureGen
+  # Details of data built by the generator.
+  module Data
+    # Details of generated Article and internal details thereof.
+    class ArticleContent
+      def initialize(config:, &paras_builder)
+        @config = config
+        @paras_builder = paras_builder
+        @str = nil
+        self
+      end
+
+      def to_s
+        return @str if @str
+        @str = Internals.wrap_content(content)
+      end
+
+      private
+
+      attr_reader :config, :paras_builder
+
+      def content
+        paragraphs.join("\n")
+      end
+
+      def paragraph(sentence_count)
+        paras_builder.call sentence_count
+      end
+
+      def paragraphs
+        Array.new(para_count) { paragraph(sentence_count) }
+      end
+
+      def para_count
+        rand(para_count_range)
+      end
+
+      def para_count_range
+        config.para_count_min..config.para_count_max
+      end
+
+      def sentence_count
+        rand(sentence_count_range)
+      end
+
+      def sentence_count_range
+        config.sent_count_min..config.sent_count_max
+      end
+
+      # Stateless methods and supporting constants.
+      module Internals
+        CONTENT_WRAPPER = ['<div class="article">', '</div>'].freeze
+
+        def self.wrap_content(inner_content)
+          CONTENT_WRAPPER.join inner_content
+        end
+      end
+      private_constant :Internals
+    end # class ArticleFixtureGen::Data::ArticleContent
+  end
+end

data/lib/article_fixture_gen/data/build_fragment_list.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'prolog/dry_types'
+
+module ArticleFixtureGen
+  module Data
+    # Assembles a "fragment list", a list of objects associating a string as
+    # found in a DOM leaf text node with the DOM position of that leaf node
+    # relative to a specified parent node and initial position. The default
+    # initial position, `[]`, indicates that the parent node is the root node
+    # of a DOM tree known to the caller.
+    class BuildFragmentList
+      def self.call(parent_node:, position: [])
+        BuildFragmentList.new.call(parent_node, position)
+      end
+
+      def call(parent_node, position)
+        ret = []
+        Internals.with_each_child_of(parent_node) do |node, index|
+          ret += add_items_for(node, index, position)
+        end
+        ret
+      end
+
+      private
+
+      def add_items_for(node, index, position)
+        item_pos = Internals.position_with(position, index)
+        return call(node, item_pos) if Internals.node?(node)
+        Internals.item_with(item_pos, node)
+      end
+
+      # Stateless methods.
+      module Internals
+        def self.item_with(position, string)
+          Array(FragmentPosition.new(position: position, string: string))
+        end
+
+        # Reek doesn't like .respond_to?; it flags :reek:ManualDispatch. Tough.
+        def self.node?(item)
+          item.respond_to?(:nodes)
+        end
+
+        def self.position_with(position, index)
+          position + Array(index)
+        end
+
+        # This is here because we need *both* the node and the index, so
+        # `Array#map` doesn't do us for.
+        def self.with_each_child_of(parent_node)
+          parent_node.nodes.each_with_index { |node, index| yield(node, index) }
+        end
+      end
+      private_constant :Internals
+
+      # Associates a DOM-fragment string with a node position. The position is
+      # given as an array of indexes relative to the specified parent node.
+      # For example, given an object `obj` with :position of [0, 1, 7, 4], then
+      #     obj.string == parent_node.nodes[0].nodes[1].nodes[7].nodes[4]
+      # would be true.
+      class FragmentPosition < Dry::Struct::Value
+        attribute :position, Types::Strict::Array.member(Types::Strict::Int)
+        attribute :string, Types::Strict::String
+      end
+      private_constant :FragmentPosition
+    end # class ArticleFixtureGen::Data::BuildFragmentList
+  end
+end

data/lib/article_fixture_gen/data/build_target_entry_list.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative './build_word_list'
+
+module ArticleFixtureGen
+  module Data
+    # Builds a word list suitable for randomly selecting MTP locations; these
+    # may be used for either single- or paired-marker tag pairs by the simple
+    # expedient of reverse-sorting the returned list of entries. Existing MTPs
+    # in the content will be unaffected, as they will be treated as any other
+    # element node and, since they have no contained text, will not affect the
+    # result.
+    class BuildTargetEntryList
+      def self.call(parent_node, count)
+        new(parent_node, count).call
+      end
+
+      def call
+        entries.sort.reverse
+      end
+
+      protected
+
+      def initialize(parent_node, count)
+        @parent_node = parent_node
+        @count = count
+        @word_list = nil
+        @chosen_indexes = []
+        self
+      end
+
+      private
+
+      attr_reader :chosen_indexes, :count, :parent_node
+
+      def add_index(index)
+        chosen_indexes << index
+        index
+      end
+
+      def entries
+        Array.new(count) { item_from_word_list }
+      end
+
+      def index_taken?(index)
+        return true if index.to_i.zero? # covers nil
+        chosen_indexes.include?(index)
+      end
+
+      def item_from_word_list
+        word_list[random_index]
+      end
+
+      def random_index
+        add_index random_index_value
+      end
+
+      def random_index_value
+        index = rand(word_list.count) while index_taken?(index)
+        index
+      end
+
+      def word_list
+        @word_list ||= BuildWordList.call(parent_node: parent_node)
+      end
+    end # class ArticleFixtureGen::Data::BuildTargetEntryList
+  end
+end