markdown_composer 0.7.0

data/lib/markdown_composer/where.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module MarkdownComposer
+  module Where
+    GROUP_KEYS = %w[all any none not xor].freeze
+    FIELD_TAKE_FIELDS = %w[title text source_text].freeze
+
+    module_function
+
+    def normalize(value)
+      return parse(value) if value.is_a?(String)
+      return nil if value.nil?
+
+      case value
+      when Hash
+        hash = value.transform_keys(&:to_s)
+        group_key = GROUP_KEYS.find { |key| hash.key?(key) }
+        if group_key
+          children = hash[group_key]
+          return { group_key => Array(children).map { |child| normalize(child) } } unless group_key == "not"
+
+          return { "not" => normalize(children) }
+        end
+        hash
+      else
+        value
+      end
+    end
+
+    def parse(text)
+      text = text.to_s.strip
+      group = GROUP_KEYS.find { |key| text.start_with?("#{key}(") && text.end_with?(")") }
+      if group
+        inner = text[(group.length + 1)..-2]
+        children = split_top_level(inner, ";").map { |part| parse(part) }
+        return group == "not" ? { "not" => children.first } : { group => children }
+      end
+
+      field_expression, rest = split_field_and_rest(text)
+      if field_expression && (predicate_match = rest&.match(/\A([a-z_]+)\((.*)\)\z/))
+        field, field_take = parse_field_expression(field_expression)
+        condition = {
+          "field" => field,
+          "operator" => predicate_match[1].strip,
+          "value" => unquote(predicate_match[2].strip)
+        }
+        condition["field_take"] = field_take if field_take
+        return condition
+      end
+
+      if field_expression && rest
+        field, field_take = parse_field_expression(field_expression)
+        if rest.match?(/\A[a-z_]+\(/)
+          condition = {
+            "field" => field,
+            "operator" => "__malformed_predicate__",
+            "value" => rest.strip
+          }
+          condition["field_take"] = field_take if field_take
+          return condition
+        end
+
+        value = unquote(rest.strip)
+        if field == "position" && value.include?("..")
+          from, to = value.split("..", 2)
+          condition = { "field" => field, "operator" => "range", "from" => Take.integer(from), "to" => Take.integer(to) }
+          condition["field_take"] = field_take if field_take
+          return condition
+        end
+
+        operator = %w[exists true false].include?(value) ? value : "equals"
+        condition = { "field" => field, "operator" => operator == "exists" ? "exists" : "equals", "value" => cast(value) }
+        condition["field_take"] = field_take if field_take
+        return condition
+      end
+
+      if text =~ /\A([^:]+):([a-z_]+)\((.*)\)\z/
+        return {
+          "field" => Regexp.last_match(1).strip,
+          "operator" => Regexp.last_match(2).strip,
+          "value" => unquote(Regexp.last_match(3).strip)
+        }
+      end
+
+      if text =~ /\A([^:]+):(.+)\z/
+        field = Regexp.last_match(1).strip
+        value = unquote(Regexp.last_match(2).strip)
+        if field == "position" && value.include?("..")
+          from, to = value.split("..", 2)
+          return { "field" => field, "operator" => "range", "from" => Take.integer(from), "to" => Take.integer(to) }
+        end
+
+        operator = %w[exists true false].include?(value) ? value : "equals"
+        return { "field" => field, "operator" => operator == "exists" ? "exists" : "equals", "value" => cast(value) }
+      end
+
+      { "field" => "text", "operator" => "contains", "value" => text }
+    end
+
+    def match?(unit, condition, position:, total:, options: {})
+      return true if condition.nil? || condition == {}
+
+      condition = normalize(condition)
+      if condition.is_a?(Hash)
+        group_key = GROUP_KEYS.find { |key| condition.key?(key) }
+        return match_group?(group_key, condition[group_key], unit, position: position, total: total, options: options) if group_key
+      end
+
+      field = condition["field"].to_s
+      operator = condition["operator"].to_s
+      value = condition["value"]
+      actual = field_value(unit, field, position: position, total: total)
+      actual = apply_field_take(actual, condition["field_take"]) if condition["field_take"]
+      compare(actual, operator, value, condition, options: options)
+    end
+
+    def validate(condition, diagnostics:, path:, options: {})
+      condition = normalize(condition)
+      return if condition.nil?
+
+      if condition.is_a?(Hash)
+        group_key = GROUP_KEYS.find { |key| condition.key?(key) }
+        if group_key
+          if group_key == "not"
+            validate(condition[group_key], diagnostics: diagnostics, path: "#{path}.not", options: options)
+            return
+          end
+
+          Array(condition[group_key]).each_with_index { |child, index| validate(child, diagnostics: diagnostics, path: "#{path}.#{group_key}[#{index}]", options: options) }
+          return
+        end
+      end
+
+      field = condition["field"].to_s
+      operator = condition["operator"].to_s
+      if operator == "__malformed_predicate__"
+        diagnostics.error("where.predicate_malformed", "Malformed condition for #{field}: #{condition["value"]}", path: path)
+        return
+      end
+
+      registry = Registries.default.where
+      field_entry = registry.fields[field]
+      diagnostics.error("where.field_unknown", "Unknown condition field #{field.inspect}", path: path) unless field_entry
+      diagnostics.error("where.operator_unknown", "Unknown predicate #{operator.inspect}", path: path) unless registry.predicate?(operator) && registry.predicates_for(field).include?(operator)
+      if condition["field_take"]
+        diagnostics.error("where.field_take_unsupported", "#{field} does not support bracketed where take", path: path) unless field_entry&.field_take
+        Take.validate(condition["field_take"]).each { |message| diagnostics.error("where.field_take_invalid", message, path: path) }
+      end
+      validate_regex(condition["value"], diagnostics: diagnostics, path: path) if operator == "matches"
+      diagnostics.error("where.position_zero", "position:0 is invalid", path: path) if field == "position" && condition["value"].to_i.zero? && condition["operator"] == "equals"
+    end
+
+    def field_value(unit, field, position:, total:)
+      case field
+      when "title"
+        unit.respond_to?(:title_text) ? unit.title_text : unit.text
+      when "text"
+        unit.respond_to?(:text) ? unit.text : unit.title_text
+      when "source_text"
+        unit.respond_to?(:raw) ? unit.raw : field_value(unit, "text", position: position, total: total)
+      when "position"
+        position
+      when "language"
+        unit.respond_to?(:attributes) ? unit.attributes["language"] : nil
+      when "diagram_type"
+        unit.respond_to?(:attributes) ? unit.attributes["diagram_type"] : nil
+      when "format"
+        unit.respond_to?(:attributes) ? unit.attributes["format"] : nil
+      when "location"
+        unit.respond_to?(:attributes) ? unit.attributes["location"] : nil
+      when "links"
+        nested_nodes(unit).any? { |node| node.type == "link" }
+      when "images"
+        nested_nodes(unit).any? { |node| node.type == "image" }
+      when "code"
+        nested_nodes(unit).any? { |node| node.type == "code_block" }
+      when "numbers"
+        (unit.respond_to?(:text) ? unit.text : unit.title_text).to_s.match?(/\d/)
+      when "empty"
+        (unit.respond_to?(:text) ? unit.text : unit.title_text).to_s.strip.empty?
+      when "length"
+        (unit.respond_to?(:text) ? unit.text : unit.title_text).to_s.length
+      when "word_count"
+        (unit.respond_to?(:text) ? unit.text : unit.title_text).to_s.scan(/\w+/).length
+      when "child"
+        unit.respond_to?(:child_sections) ? unit.child_sections : []
+      end
+    end
+
+    def validate_regex(value, diagnostics:, path:)
+      Regexp.new(value.to_s)
+    rescue RegexpError => e
+      diagnostics.error("where.regex_invalid", "Invalid regular expression: #{e.message}", path: path)
+    end
+
+    def compare(actual, operator, value, condition, options:)
+      case operator
+      when "contains"
+        actual.to_s.include?(value.to_s)
+      when "starts_with"
+        actual.to_s.start_with?(value.to_s)
+      when "ends_with"
+        actual.to_s.end_with?(value.to_s)
+      when "equals"
+        actual.to_s.downcase == value.to_s.downcase
+      when "range"
+        from = condition["from"].to_i
+        to = condition["to"].to_i
+        actual.to_i >= from && actual.to_i <= (to.negative? ? Float::INFINITY : to)
+      when "exists"
+        actual.respond_to?(:any?) ? actual.any? : !!actual
+      when "min"
+        actual.to_i >= value.to_i
+      when "max"
+        actual.to_i <= value.to_i
+      when "matches"
+        Regexp.new(value.to_s).match?(actual.to_s)
+      else
+        false
+      end
+    rescue RegexpError
+      false
+    end
+
+    def match_group?(group_key, children, unit, position:, total:, options:)
+      children = group_key == "not" ? [ children ] : Array(children)
+      results = children.map { |child| match?(unit, child, position: position, total: total, options: options) }
+      case group_key
+      when "all" then results.all?
+      when "any" then results.any?
+      when "none" then results.none?
+      when "not" then !results.first
+      when "xor" then results.count(true) == 1
+      else false
+      end
+    end
+
+    def nested_nodes(unit)
+      return [ unit, *unit.children ].compact if unit.respond_to?(:children)
+      return [ unit ] unless unit.respond_to?(:all_nodes)
+
+      [ unit.heading_node, *unit.body_nodes, *unit.all_nodes ].compact
+    end
+
+    def apply_field_take(actual, take)
+      Take.apply(field_tokens(actual), take).join(" ")
+    end
+
+    def field_tokens(actual)
+      actual.to_s.scan(/\S+/)
+    end
+
+    def parse_field_expression(expression)
+      if expression =~ /\A([a-z_]+)\[(.+)\]\z/
+        return [ Regexp.last_match(1), Take.parse(Regexp.last_match(2)) ]
+      end
+
+      [ expression.strip, nil ]
+    end
+
+    def split_field_and_rest(text)
+      depth = 0
+      quote = nil
+      text.each_char.with_index do |char, index|
+        quote = quote == char ? nil : char if %w[" '].include?(char)
+        if quote.nil?
+          depth += 1 if char == "["
+          depth -= 1 if char == "]"
+        end
+        return [ text[0...index].strip, text[(index + 1)..].strip ] if char == ":" && depth.zero? && quote.nil?
+      end
+
+      [ nil, nil ]
+    end
+
+    def split_top_level(text, delimiter)
+      depth = 0
+      bracket_depth = 0
+      quote = nil
+      current = +""
+      parts = []
+      text.each_char do |char|
+        quote = quote == char ? nil : char if %w[" '].include?(char)
+        if quote.nil?
+          depth += 1 if char == "("
+          depth -= 1 if char == ")"
+          bracket_depth += 1 if char == "["
+          bracket_depth -= 1 if char == "]"
+        end
+        if char == delimiter && depth.zero? && bracket_depth.zero? && quote.nil?
+          parts << current.strip
+          current = +""
+        else
+          current << char
+        end
+      end
+      parts << current.strip unless current.strip.empty?
+      parts
+    end
+
+    def unquote(value)
+      value.sub(/\A["']/, "").sub(/["']\z/, "")
+    end
+
+    def cast(value)
+      return true if value == "true"
+      return false if value == "false"
+      return Take.integer(value) if value.to_s.match?(/\A-?\d+\z|last/)
+
+      value
+    end
+  end
+end

data/lib/markdown_composer.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+
+require_relative "markdown_composer/version"
+require_relative "markdown_composer/value_object"
+require_relative "markdown_composer/diagnostics"
+require_relative "markdown_composer/registries"
+require_relative "markdown_composer/source"
+require_relative "markdown_composer/source_list_builder"
+require_relative "markdown_composer/plan"
+require_relative "markdown_composer/plan_builder"
+require_relative "markdown_composer/result"
+require_relative "markdown_composer/document_index"
+require_relative "markdown_composer/take"
+require_relative "markdown_composer/where"
+require_relative "markdown_composer/data_path"
+require_relative "markdown_composer/selection_resolver"
+require_relative "markdown_composer/composition_buffer"
+require_relative "markdown_composer/markdown_renderer"
+require_relative "markdown_composer/transform_options"
+require_relative "markdown_composer/validator"
+require_relative "markdown_composer/executor"
+require_relative "markdown_composer/transform_runner"
+require_relative "markdown_composer/transforms/registry"
+require_relative "markdown_composer/capabilities"
+
+module MarkdownComposer
+  class << self
+    def compose(sources:, config: nil, plan: nil, options: {})
+      plan ||= config
+      raise ArgumentError, "provide config: or plan:" unless plan
+
+      plan = plan.is_a?(Plan) ? plan : Plan.new(plan)
+      Executor.new(sources: sources, plan: plan, options: options).call
+    end
+
+    def normalise(config_or_rows)
+      plan = if config_or_rows.is_a?(Plan)
+        config_or_rows
+      elsif config_or_rows.is_a?(Array)
+        Plan.from_rows(config_or_rows)
+      else
+        Plan.new(config_or_rows)
+      end
+      plan.to_h
+    end
+    alias normalize normalise
+
+    def validate(config:, sources: [], options: {})
+      plan = config.is_a?(Plan) ? config : Plan.new(config)
+      normalized_sources = Array(sources).map { |source| Source.build(source) }
+      diagnostics = Validator.new(plan, sources: normalized_sources, options: options).call
+      {
+        valid: !diagnostics.any_errors?,
+        plan: plan.to_h,
+        diagnostics: diagnostics.as_json,
+        errors: diagnostics.errors.map(&:to_h)
+      }
+    end
+
+    def capabilities(options: {})
+      Capabilities.build(options)
+    end
+
+    def plan(&block)
+      builder = PlanBuilder.new
+      builder.instance_eval(&block) if block
+      builder.to_plan
+    end
+
+    def source_list(&block)
+      builder = SourceListBuilder.new
+      builder.instance_eval(&block) if block
+      builder.to_a
+    end
+
+    def parse_yaml(yaml_string)
+      Plan.new(YAML.safe_load(yaml_string, permitted_classes: [ Symbol ], aliases: false) || {})
+    rescue Psych::SyntaxError => e
+      Plan.invalid("yaml.syntax", e.message)
+    end
+
+    def parse_json(json_string)
+      Plan.new(JSON.parse(json_string))
+    rescue JSON::ParserError => e
+      Plan.invalid("json.syntax", e.message)
+    end
+
+    def to_yaml(plan)
+      plan = Plan.new(plan) unless plan.is_a?(Plan)
+      YAML.dump(plan.to_h)
+    end
+
+    def to_json(plan, pretty: true)
+      plan = Plan.new(plan) unless plan.is_a?(Plan)
+      pretty ? JSON.pretty_generate(plan.to_h) : JSON.generate(plan.to_h)
+    end
+
+    def parse_rows(row_hashes)
+      Plan.from_rows(row_hashes)
+    end
+
+    def to_rows(plan)
+      plan = Plan.new(plan) unless plan.is_a?(Plan)
+      plan.steps
+    end
+
+    def registries
+      Registries.default
+    end
+  end
+end

metadata

@@ -0,0 +1,260 @@
+--- !ruby/object:Gem::Specification
+name: markdown_composer
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- SocIt2Em
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commonmarker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.23.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.23.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.13.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.13.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '14'
+description: A pure Ruby, headless composition engine for Markdown-first workflows
+  with best-effort HTML input and HTML output support.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- ROADMAP.md
+- docs/_md_composer_architecture.md
+- docs/_md_composer_cheatsheet.md
+- docs/_md_composer_concepts.md
+- docs/_md_composer_dev_guide.md
+- docs/_md_composer_getting_started.md
+- docs/_md_composer_readme.md
+- docs/_md_composer_user_guide.md
+- docs/ai/md_composer_ai_audit.md
+- docs/ai/md_composer_ai_canonical_docs.md
+- docs/ai/md_composer_ai_source_map.md
+- docs/compose/md_composer_compose_actions.md
+- docs/compose/md_composer_compose_anatomy.md
+- docs/compose/md_composer_compose_buffer.md
+- docs/compose/md_composer_compose_examples.md
+- docs/compose/md_composer_compose_include.md
+- docs/compose/md_composer_compose_select.md
+- docs/compose/md_composer_compose_sources.md
+- docs/compose/md_composer_compose_targets.md
+- docs/examples/md_composer_example_basic_compose.md
+- docs/examples/md_composer_example_buffer_target_actions.md
+- docs/examples/md_composer_example_fixtures.md
+- docs/examples/md_composer_example_html_output.md
+- docs/examples/md_composer_example_modify.md
+- docs/examples/md_composer_example_multi_row_compose.md
+- docs/examples/md_composer_example_ruby_plans.md
+- docs/examples/md_composer_example_structured_data.md
+- docs/examples/md_composer_example_transforms.md
+- docs/examples/md_composer_example_yaml_json_rows.md
+- docs/examples/md_composer_examples_readme.md
+- docs/examples/md_composer_runnable_examples.md
+- docs/examples/md_composer_source_ruby_dsl.md
+- docs/reference/md_composer_nested.md
+- docs/reference/md_composer_reference_api.md
+- docs/reference/md_composer_reference_capabilities.md
+- docs/reference/md_composer_reference_diagnostics.md
+- docs/reference/md_composer_reference_plan_schema.md
+- docs/reference/md_composer_reference_registries.md
+- docs/reference/md_composer_take.md
+- docs/reference/md_composer_unit_tokens.md
+- docs/reference/md_composer_where.md
+- docs/transform/md_composer_transform_anatomy.md
+- docs/transform/md_composer_transform_examples.md
+- docs/transform/md_composer_transform_modes.md
+- docs/transform/md_composer_transform_options.md
+- docs/transform/md_composer_transform_scope.md
+- docs/transform/md_composer_transform_transforms.md
+- examples/README.md
+- examples/advanced_composer.rb
+- examples/basic_compose.rb
+- examples/complex_composer.rb
+- examples/example_support.rb
+- examples/fixtures/current.md
+- examples/fixtures/faq.md
+- examples/fixtures/guide.md
+- examples/fixtures/site_intro.md
+- examples/fixtures/source.html
+- examples/html_input.rb
+- examples/output/advanced_composer.md
+- examples/output/basic_compose.md
+- examples/output/complex_composer.md
+- examples/output/html_input.md
+- examples/output/source_list_dsl.md
+- examples/output/standard_composer.md
+- examples/output/standard_sources_buffer.md
+- examples/output/yaml_plan.md
+- examples/plans/basic.yml
+- examples/source_list_dsl.rb
+- examples/standard_composer.rb
+- examples/standard_sources_buffer.rb
+- examples/yaml_plan.rb
+- lib/markdown_composer.rb
+- lib/markdown_composer/capabilities.rb
+- lib/markdown_composer/composition_buffer.rb
+- lib/markdown_composer/data_path.rb
+- lib/markdown_composer/diagnostics.rb
+- lib/markdown_composer/document_index.rb
+- lib/markdown_composer/document_index/html_parser.rb
+- lib/markdown_composer/document_index/markdown_parser.rb
+- lib/markdown_composer/executor.rb
+- lib/markdown_composer/markdown_renderer.rb
+- lib/markdown_composer/plan.rb
+- lib/markdown_composer/plan_builder.rb
+- lib/markdown_composer/registries.rb
+- lib/markdown_composer/registries/action_entries.rb
+- lib/markdown_composer/registries/condition_entries.rb
+- lib/markdown_composer/registries/registry.rb
+- lib/markdown_composer/registries/source_entries.rb
+- lib/markdown_composer/registries/support_values.rb
+- lib/markdown_composer/registries/take_entries.rb
+- lib/markdown_composer/registries/take_registry.rb
+- lib/markdown_composer/registries/target_entries.rb
+- lib/markdown_composer/registries/unit_token_entries.rb
+- lib/markdown_composer/registries/where_registry.rb
+- lib/markdown_composer/result.rb
+- lib/markdown_composer/selection_resolver.rb
+- lib/markdown_composer/source.rb
+- lib/markdown_composer/source_list_builder.rb
+- lib/markdown_composer/take.rb
+- lib/markdown_composer/transform_options.rb
+- lib/markdown_composer/transform_runner.rb
+- lib/markdown_composer/transform_runner/content_placement.rb
+- lib/markdown_composer/transform_runner/field_interpolator.rb
+- lib/markdown_composer/transform_runner/heading_numbering.rb
+- lib/markdown_composer/transform_runner/scope_resolver.rb
+- lib/markdown_composer/transforms/default_entries.rb
+- lib/markdown_composer/transforms/registry.rb
+- lib/markdown_composer/validator.rb
+- lib/markdown_composer/value_object.rb
+- lib/markdown_composer/version.rb
+- lib/markdown_composer/where.rb
+homepage: https://github.com/SocIt2Em/markdown_composer
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/SocIt2Em/markdown_composer
+  documentation_uri: https://github.com/SocIt2Em/markdown_composer#readme
+  changelog_uri: https://github.com/SocIt2Em/markdown_composer/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/SocIt2Em/markdown_composer/issues
+  github_repo: ssh://github.com/SocIt2Em/markdown_composer
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.7
+specification_version: 4
+summary: Headless Markdown composer for selecting and transforming document fragments
+test_files: []