brutal 1.5.0 → 1.6.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea124053ebeef681c2e046022936f9d67ca97778733a23bd2d81781e90daa9a8
-  data.tar.gz: 677089454fece7f60aedfc4693b53c132f057bbeeaca5e651f88ec52d026ea34
+  metadata.gz: 2a8a912485598e917360c280db92eee2b3acc53180dd0587b2147ea0eb26e649
+  data.tar.gz: 5a7a1f13b748e8deb7d5a1529ca2e11eb35b687aabab84f7b9fc9ebc58d0b174
 SHA512:
-  metadata.gz: b1d043d4740db1987c188755e9b339da566034a3cc2a43f99ced12fb3de26a93df0f93d669b20700ba662a935d9be662a25bffba8f8ae92aae3e01deade92d9b
-  data.tar.gz: 5abc20c46849f69b20de5b89848f8fed831b2d92641f57cfa349be4e0a975c8630c27268d16a022911693d403af8262b4f0d1099dcf468879392e9c2d7fe7ec0
+  metadata.gz: ec1ffa0f11a17812ff0000bc7e8b4ba8a04c826e37f9ef5e777681312fcb87962020f034b4802b617471894019f9c046598a012eeb6491c6548f0fef233af66d
+  data.tar.gz: 363647b4219053d2433fa198aac832b8f8f630e36d7b9282f0c36c34c2a255e5874ee91e481440be6bea2c87bb7763225ddbd04bfbf0204ad949bea98b5fbb01

data/README.md

@@ -38,7 +38,7 @@ It is therefore the responsibility of the developer to analyze the generated beh
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "brutal"
+gem "brutal", ">= 1.6.0.beta2", require: false
 ```
 
 And then execute:
@@ -50,84 +50,84 @@ bundle install
 Or install it yourself as:
 
 ```sh
-gem install brutal
+gem install brutal --pre
 ```
 
-## Quick Start
-
-Just type `brutal` in a Ruby project's folder and watch the magic happen.
-
 ## Usage
 
-__Brutal__ needs a configuration file to know how to write your tests.
-Currently, only the YAML format is supported.
-This file is by default named `.brutal.yml` and is composed of 4 top-level sections:
+### YAML manifest
+
+__Brutal__ needs configuration files in YAML format to know how to write tests.
+Configuration file names are suffixed by `_brutal.yaml` and composed of 7 top-level sections:
 
-* `header` - Specifies the code to execute before generating the test suite.
+* `header` - Specifies a block of lines to be executed once before all examples.
+* `before` - Specifies a block of lines to be executed before each example.
 * `subject` - Specifies the template of the code to be declined across contexts.
 * `contexts` - Specifies a list of variables to populate the subject's template.
 * `actuals` - Specifies templates to challenge evaluated subjects & get results.
+* `after` - Specifies a block of lines to be executed after each example.
+* `footer` - Specifies a block of lines to be executed once after all examples.
 
-When the configuration file is present, the generation of a test suite can be done with the command:
+### Command line
+
+The `brutal` command comes with several options you can use to customize Brutal's behavior.
+
+For a full list of options, run the `brutal` command with the `--help` flag:
 
 ```sh
-brutal .brutal.yml
+brutal --help
 ```
 
-or:
+```txt
+Usage: brutal [options] [files or directories]
 
-```sh
-brutal .
+    --format=FORMAT Choose "ruby" (default).
+    --help          Display this help.
+    --version       Display the version.
 ```
 
-or even:
+Assuming that in the workspace there is a configuration file named `user_brutal.yaml`, the test suite can be generated via one of these commands:
 
 ```sh
-brutal
+brutal user_brutal.yaml
 ```
 
-This would create a `test.rb` file containing the test suite.
-
-Configuration files can also be named differently:
+or:
 
 ```sh
-brutal path/to/test_hello_world.yml
+brutal .
 ```
 
-This would create a `path/to/test_hello_world.rb` file containing the test suite.
-
-To avoid accidentally overwriting a file, the `--no-force` option can be used:
+or even:
 
 ```sh
-brutal path/to/test_hello_world.yml --no-force
+brutal
 ```
 
-> A path/to/test_hello_world.rb file already exists!
+This would create a `test_user.rb` file containing the test suite.
 
-### Getting started
+Assuming now that in the workspace there are a large number of configuration files named in the `spec/` folder, the complete test suite could be generated recursively via this command:
 
-1. Create a `.brutal.yml` file in your application's root directory. For example: <https://github.com/fixrb/brutal/blob/v1.4.0/examples/hello_world_v1/.brutal.yml>
-2. Run the `brutal` command from the same directory.
-3. Read the generated `test.rb` file in the same directory: <https://github.com/fixrb/brutal/blob/v1.4.0/examples/hello_world_v1/test.rb>
+```sh
+brutal spec/
+```
+
+This would create one test file per configuration file matching `./spec/**/*_brutal.yaml` in to `./spec/**/test_*.rb`.
 
-### More examples
+### Some examples
 
-<https://github.com/fixrb/brutal/blob/v1.4.0/examples/>
+<https://github.com/fixrb/brutal/tree/main/examples/>
 
 ## Rake integration example
 
-A generated `test.rb` file could be matched as follows:
+Generated test suite files could be matched as follows:
 
 ```ruby
 Rake::TestTask.new do |t|
-  t.pattern = "test.rb"
+  t.pattern = "**/test_*.rb"
 end
 ```
 
-## Test suite
-
-__Brutal__'s test set is brutally self-generated here: [./test.rb](https://github.com/fixrb/brutal/blob/main/test.rb)
-
 ## Contact
 
 * Source code: https://github.com/fixrb/brutal

data/bin/brutal

@@ -1,12 +1,18 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "pathname"
+require_relative File.join("..", "lib", "brutal", "command_line_arguments_parser")
+
+formats, pathnames = Brutal::CommandLineArgumentsParser.new(*ARGV).call
+
 require_relative File.join("..", "lib", "brutal")
 
-path = ARGV.fetch(0, Brutal::File::DEFAULT_CONFIG_FILENAME)
-pathname = Pathname.new(path)
-pathname += Brutal::File::DEFAULT_CONFIG_FILENAME if pathname.directory?
-force_opt = ARGV.none?("--no-force")
+formats.each do |format|
+  generator = Brutal.new(format)
 
-Brutal.generate!(pathname, force: force_opt)
+  pathnames.each do |pathname|
+    Dir.chdir(pathname.dirname) do
+      generator.call(pathname.basename)
+    end
+  end
+end

data/lib/brutal/command_line_arguments_parser.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative File.join("manifest", "file", "name")
+
+require "pathname"
+
+class Brutal
+  # Accept an arbitrary number of arguments passed from the command-line.
+  class CommandLineArgumentsParser
+    MANIFEST_FILENAME_SUFFIX  = Manifest::File::Name::SUFFIX
+    MANIFEST_FILENAME_PATTERN = ::File.join("**", "*#{MANIFEST_FILENAME_SUFFIX}")
+    CURRENT_DIRECTORY_CONTEXT = "."
+    GEM_NAME                  = "brutal"
+    HELP_OPTION               = "--help"
+    VERSION_OPTION            = "--version"
+    RUBY_FORMAT_OPTION        = "--format=ruby"
+    DEFAULT_FORMAT_OPTION     = RUBY_FORMAT_OPTION
+
+    FORMAT_OPTIONS = {
+      RUBY_FORMAT_OPTION => :Ruby
+    }.freeze
+
+    DEFAULT_FORMAT  = FORMAT_OPTIONS.fetch(DEFAULT_FORMAT_OPTION)
+    DEFAULT_FORMATS = [DEFAULT_FORMAT].freeze
+
+    attr_reader :pathnames
+
+    def initialize(*args)
+      args.each do |arg|
+        help!     if arg == HELP_OPTION
+        version!  if arg == VERSION_OPTION
+      end
+
+      @formats   = []
+      @pathnames = []
+
+      args << CURRENT_DIRECTORY_CONTEXT unless any_path_given?(*args)
+      args.each { |arg| parse!(arg) }
+    end
+
+    def call
+      [formats, pathnames]
+    end
+
+    private
+
+    def formats
+      @formats.empty? ? DEFAULT_FORMATS : @formats
+    end
+
+    def parse!(arg)
+      case arg
+      when RUBY_FORMAT_OPTION
+        @formats << FORMAT_OPTIONS.fetch(RUBY_FORMAT_OPTION)
+      else
+        load!(::Pathname.new(arg))
+      end
+    end
+
+    def help!
+      puts help_message
+      exit
+    end
+
+    def help_message
+      <<~TXT
+        Usage: #{$PROGRAM_NAME} [options] [files or directories]
+
+            --format=FORMAT Choose "ruby" (default).
+            --help          Display this help.
+            --version       Display the version.
+      TXT
+    end
+
+    def load!(pathname)
+      if pathname.directory?
+        pathname.glob(MANIFEST_FILENAME_PATTERN).each { |filename| load!(filename) }
+      elsif pathname.file?
+        load_file!(pathname)
+      else
+        raise ::ArgumentError, "#{pathname} is neither a file nor a directory."
+      end
+    end
+
+    def load_file!(pathname)
+      if pathname.fnmatch?(MANIFEST_FILENAME_PATTERN)
+        @pathnames << pathname
+      else
+        warn "Skipping #{pathname} because not matched against #{MANIFEST_FILENAME_PATTERN}."
+      end
+    end
+
+    def any_path_given?(*args)
+      path_args(*args).any?
+    end
+
+    def path_args(*args)
+      args - FORMAT_OPTIONS.keys
+    end
+
+    def version!
+      abort "Gem not found on the system.  Unknown version." if not_loaded_spec?
+
+      puts loaded_spec.version
+      exit
+    end
+
+    def loaded_spec
+      ::Gem.loaded_specs[GEM_NAME]
+    end
+
+    def not_loaded_spec?
+      loaded_spec.nil?
+    end
+  end
+end

data/lib/brutal/format/ruby/filename.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Brutal
+  module Format
+    class Ruby
+      module Filename
+        # Brutal Ruby format file prefix.
+        PREFIX = "test_"
+
+        # Brutal Ruby format file suffix.
+        SUFFIX = ".rb"
+      end
+    end
+  end
+end

data/lib/brutal/format/ruby.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative File.join("ruby", "filename")
+
+class Brutal
+  module Format
+    # Ruby format class
+    class Ruby
+      # Whitespace character.
+      SPACE = " "
+
+      # Hyphen-minus character.
+      HYPHEN_MINUS = "-"
+
+      # Two spaces per indentation level.
+      INDENTATION = SPACE * 2
+
+      # Specifies templates to challenge evaluated subjects & get results.
+      attr_reader :actuals
+
+      # Specifies a list of variables to populate the subject's template.
+      attr_reader :contexts
+
+      # Specifies a block of lines to be executed once before all examples.
+      attr_reader :header
+
+      # Specifies a block of lines to be executed before each example.
+      attr_reader :before
+
+      # Specifies the template of the code to be declined across contexts.
+      attr_reader :subject
+
+      # Specifies a block of lines to be executed after each example.
+      attr_reader :after
+
+      # Specifies a block of lines to be executed once after all examples.
+      attr_reader :footer
+
+      # Initialize a new scaffold generator.
+      def initialize(header, before, subject, after, footer, *actuals, **contexts)
+        header = "# Brutal test suite"      if header.empty?
+        before = "# Starting an example"    if before.empty?
+        after  = "# Finishing an example"   if after.empty?
+        footer = "# End of the brutal test" if footer.empty?
+
+        warn("Empty subject!")              if subject.empty?
+        warn("Empty actual values!")        if actuals.empty?
+        warn("Empty contexts!")             if contexts.empty?
+
+        @header   = header
+        @before   = before
+        @subject  = subject
+        @actuals  = actuals
+        @contexts = contexts
+        @after    = after
+        @footer   = footer
+      end
+
+      # Return a Ruby string that can be evaluated.
+      def inspect(object)
+        return object.to_s unless object.is_a?(::String)
+
+        object.strip
+      end
+
+      # Return a string representation.
+      #
+      # @return [String]
+      def to_s
+        eval(header) # rubocop:disable Security/Eval
+
+        ruby_lines.compact.join(separator_code)
+      ensure
+        eval(footer) # rubocop:disable Security/Eval
+      end
+
+      def attributes(*values)
+        context_names.each_with_index.inject({}) do |h, (name, i)|
+          h.merge(name.to_sym => inspect(values.fetch(i)))
+        end
+      end
+
+      def context_names
+        contexts.keys.sort
+      end
+
+      def contexts_values
+        context_names.map { |context_name| contexts.fetch(context_name) }
+      end
+
+      def combinations_values
+        Array(contexts_values[0]).product(*Array(contexts_values[1..]))
+      end
+
+      def ruby_lines
+        [header_code] + actual_codes + [footer_code]
+      end
+
+      def actual_codes
+        combinations_values.map do |values|
+          actual_str = format(inspect(subject), **attributes(*values))
+          string = actual_code(actual_str)
+          actual = eval(actual_str) # rubocop:disable Security/Eval, Lint/UselessAssignment
+
+          actuals.each do |actual_value|
+            result_str = format(actual_value, subject: "actual")
+            string += "raise if #{result_str} != #{eval(result_str).inspect}\n" # rubocop:disable Security/Eval
+          end
+
+          string
+        end
+      end
+
+      def actual_code(actual_str)
+        <<~CODE
+          #{before_code}
+          actual = begin
+          #{actual_str.gsub(/^/, INDENTATION)}
+          end
+
+          #{after_code}
+        CODE
+      end
+
+      def header_code
+        <<~CODE
+          #{header.chomp}
+        CODE
+      end
+
+      def before_code
+        <<~CODE
+          #{before.chomp}
+        CODE
+      end
+
+      def after_code
+        <<~CODE
+          #{after.chomp}
+        CODE
+      end
+
+      def footer_code
+        <<~CODE
+          #{footer.chomp}
+        CODE
+      end
+
+      def separator_code
+        <<~CODE
+
+          #{thematic_break_code}
+        CODE
+      end
+
+      def thematic_break_code
+        <<~CODE
+          # #{HYPHEN_MINUS * 78}
+        CODE
+      end
+    end
+  end
+end

data/lib/brutal/format.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+Dir[File.join(File.dirname(__FILE__), "format", "*.rb")].sort.each do |fname|
+  require_relative fname
+end
+
+class Brutal
+  # A collection of formatter classes.
+  module Format
+  end
+end

data/lib/brutal/manifest/file/name.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Brutal
+  class Manifest
+    class File
+      module Name
+        # Suffix for configuration file names.
+        SUFFIX = "_brutal.yaml"
+
+        # Suffix pattern for configuration file names.
+        SUFFIX_PATTERN = "*#{SUFFIX}"
+
+        # Suffix regex for configuration file names.
+        SUFFIX_REGEX = /#{SUFFIX}\z/.freeze
+      end
+    end
+  end
+end

data/lib/brutal/manifest/file.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative File.join("file", "name")
+
+require "yaml"
+
+class Brutal
+  class Manifest
+    # YAML manifest file parser.
+    class File
+      attr_reader :yaml
+
+      def initialize(pathname)
+        raise ::ArgumentError unless pathname.fnmatch?(Name::SUFFIX_PATTERN)
+
+        @yaml = pathname.read
+      end
+
+      def parse
+        ::YAML.safe_load(yaml, symbolize_names: false)
+      end
+    end
+  end
+end

data/lib/brutal/manifest.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative File.join("manifest", "file")
+
+class Brutal
+  # Brutal YAML manifest file parser.
+  class Manifest
+    # The _actuals_ top-level section key.
+    ACTUALS_KEY = "actuals"
+
+    # The _contexts_ top-level section key.
+    CONTEXTS_KEY = "contexts"
+
+    # The _header_ top-level section key.
+    HEADER_KEY = "header"
+
+    # The _before_ top-level section key.
+    BEFORE_KEY = "before"
+
+    # The _subject_ top-level section key.
+    SUBJECT_KEY = "subject"
+
+    # The _after_ top-level section key.
+    AFTER_KEY = "after"
+
+    # The _footer_ top-level section key.
+    FOOTER_KEY = "footer"
+
+    # Default _actuals_ collection.
+    DEFAULT_ACTUALS = [].freeze
+
+    # Default _contexts_ collection.
+    DEFAULT_CONTEXTS = {}.freeze
+
+    # Default _header_ code to evaluate.
+    DEFAULT_HEADER = ""
+
+    # Default _before_ code to evaluate.
+    DEFAULT_BEFORE = ""
+
+    # Default _after_ code to evaluate.
+    DEFAULT_AFTER = ""
+
+    # Default _footer_ code to evaluate.
+    DEFAULT_FOOTER = ""
+
+    # Parse a file at `pathname`.  Returns the YAML manifest instance.
+    def self.parse_file(pathname)
+      load(File.new(pathname).parse)
+    end
+
+    # Load the configuration parameters.
+    #
+    # @param params [Hash] Receive the 7 top-level section parameters.
+    def self.load(params)
+      new(
+        actuals:  params.fetch(ACTUALS_KEY, DEFAULT_ACTUALS),
+        contexts: params.fetch(CONTEXTS_KEY, DEFAULT_CONTEXTS),
+        header:   params.fetch(HEADER_KEY, DEFAULT_HEADER),
+        before:   params.fetch(BEFORE_KEY, DEFAULT_BEFORE),
+        subject:  params.fetch(SUBJECT_KEY),
+        after:    params.fetch(AFTER_KEY, DEFAULT_AFTER),
+        footer:   params.fetch(FOOTER_KEY, DEFAULT_FOOTER)
+      )
+    end
+
+    # Specifies templates to challenge evaluated subjects & get results.
+    attr_reader :actuals
+
+    # Specifies a list of variables to populate the subject's template.
+    attr_reader :contexts
+
+    # Specifies a block of lines to be executed once before all examples.
+    attr_reader :header
+
+    # Specifies a block of lines to be executed before each example.
+    attr_reader :before
+
+    # Specifies the template of the code to be declined across contexts.
+    attr_reader :subject
+
+    # Specifies a block of lines to be executed after each example.
+    attr_reader :after
+
+    # Specifies a block of lines to be executed once after all examples.
+    attr_reader :footer
+
+    # Initialize a new configuration.
+    def initialize(actuals:, contexts:, header:, before:, subject:, after:, footer:)
+      raise ::TypeError, actuals.inspect  unless actuals.is_a?(::Array)
+      raise ::TypeError, contexts.inspect unless contexts.is_a?(::Hash)
+      raise ::TypeError, header.inspect   unless header.is_a?(::String)
+      raise ::TypeError, before.inspect   unless before.is_a?(::String)
+      raise ::TypeError, subject.inspect  unless subject.is_a?(::String)
+      raise ::TypeError, after.inspect    unless after.is_a?(::String)
+      raise ::TypeError, footer.inspect   unless footer.is_a?(::String)
+
+      @actuals  = actuals
+      @contexts = contexts
+      @header   = header
+      @before   = before
+      @subject  = subject
+      @after    = after
+      @footer   = footer
+    end
+  end
+end

data/lib/brutal.rb

@@ -1,43 +1,40 @@
 # frozen_string_literal: true
 
 %w[
-  configuration
-  file
-  scaffold
-  yaml
+  format
+  manifest
 ].each { |filename| require_relative(File.join("brutal", filename)) }
 
 # The Brutal namespace.
-module Brutal
-  def self.generate!(pathname, force: true)
-    hash = parse(pathname)
-    conf = Configuration.load(hash)
+class Brutal
+  attr_reader :engine
 
-    ruby = Scaffold.new(conf.header,
-                        conf.subject,
-                        *conf.actuals,
-                        **conf.contexts)
+  def initialize(format)
+    @engine = Format.const_get(format)
+  end
 
-    write(pathname, ruby, force: force)
+  def call(pathname)
+    manifest = Manifest.parse_file(pathname)
+    scaffold = brutalizer(manifest)
+    pathname = new_pathname(pathname)
+    pathname.write(scaffold)
   end
 
-  def self.parse(pathname)
-    return Yaml.parse(read(pathname)) if Yaml.parse?(pathname)
+  private
+
+  def brutalizer(conf)
+    engine.new(conf.header, conf.before, conf.subject, conf.after, conf.footer, *conf.actuals, **conf.contexts)
+  end
 
-    raise ::ArgumentError, "Unrecognized extension.  " \
-                           "Impossible to parse #{pathname.inspect}."
+  def new_pathname(pathname)
+    pathname.dirname + "#{new_prefix}#{pathname.basename.sub(Manifest::File::Name::SUFFIX_REGEX, new_suffix)}"
   end
-  private_class_method :parse
 
-  def self.read(pathname)
-    File::Read.new(pathname).call
+  def new_prefix
+    engine.const_get(:Filename).const_get(:PREFIX)
   end
-  private_class_method :read
 
-  def self.write(pathname, ruby, force:)
-    new_pathname = File.generated_pathname(pathname)
-    File.override_protection(new_pathname) unless force
-    File::Write.new(new_pathname).call(ruby)
+  def new_suffix
+    engine.const_get(:Filename).const_get(:SUFFIX)
   end
-  private_class_method :write
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brutal
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0.beta2
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-23 00:00:00.000000000 Z
+date: 2022-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,20 +108,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -147,12 +133,13 @@ files:
 - README.md
 - bin/brutal
 - lib/brutal.rb
-- lib/brutal/configuration.rb
-- lib/brutal/file.rb
-- lib/brutal/file/read.rb
-- lib/brutal/file/write.rb
-- lib/brutal/scaffold.rb
-- lib/brutal/yaml.rb
+- lib/brutal/command_line_arguments_parser.rb
+- lib/brutal/format.rb
+- lib/brutal/format/ruby.rb
+- lib/brutal/format/ruby/filename.rb
+- lib/brutal/manifest.rb
+- lib/brutal/manifest/file.rb
+- lib/brutal/manifest/file/name.rb
 homepage: https://github.com/fixrb/brutal
 licenses:
 - MIT
@@ -169,9 +156,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.6
 signing_key: 

data/lib/brutal/configuration.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Brutal
-  # Brutal::Configuration
-  #
-  # @since 1.0.0
-  class Configuration
-    ACTUALS_KEY   = "actuals"
-    CONTEXTS_KEY  = "contexts"
-    HEADER_KEY    = "header"
-    SUBJECT_KEY   = "subject"
-
-    DEFAULT_ACTUALS   = [].freeze
-    DEFAULT_CONTEXTS  = {}.freeze
-    DEFAULT_HEADER    = "# Brutal test suite"
-    DEFAULT_SUBJECT   = ""
-
-    # Load the configuration parameters.
-    #
-    # @param params [Hash] Receive the 4 top-level section parameters.
-    def self.load(params)
-      new(
-        actuals:  params.fetch(ACTUALS_KEY, DEFAULT_ACTUALS),
-        contexts: params.fetch(CONTEXTS_KEY, DEFAULT_CONTEXTS),
-        header:   params.fetch(HEADER_KEY, DEFAULT_HEADER),
-        subject:  params.fetch(SUBJECT_KEY, DEFAULT_SUBJECT)
-      )
-    end
-
-    # Specifies templates to challenge evaluated subjects & get results.
-    attr_reader :actuals
-
-    # Specifies a list of variables to populate the subject's template.
-    attr_reader :contexts
-
-    # Specifies the code to execute before generating the test suite.
-    attr_reader :header
-
-    # Specifies the template of the code to be declined across contexts.
-    attr_reader :subject
-
-    # Initialize a new configuration.
-    def initialize(actuals:, contexts:, header:, subject:)
-      raise ::TypeError, actuals.inspect  unless actuals.is_a?(::Array)
-      raise ::TypeError, contexts.inspect unless contexts.is_a?(::Hash)
-      raise ::TypeError, header.inspect   unless header.is_a?(::String)
-      raise ::TypeError, subject.inspect  unless subject.is_a?(::String)
-
-      @actuals  = actuals.sort
-      @contexts = contexts
-      @header   = header
-      @subject  = subject
-    end
-  end
-end

data/lib/brutal/file/read.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Brutal
-  module File
-    # Brutal::File::Read
-    #
-    # @since 1.1.0
-    class Read
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-
-      def call
-        ::File.read(path)
-      rescue ::Errno::ENOENT => _e
-        abort "File #{path} not found!"
-      end
-
-      protected
-
-      def path
-        ::File.join(::Dir.pwd, name)
-      end
-    end
-  end
-end

data/lib/brutal/file/write.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Brutal
-  module File
-    # Brutal::File::Write
-    #
-    # @since 1.1.0
-    class Write
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-
-      def call(scaffold)
-        file = ::File.open(path, "w")
-        file.write(scaffold)
-
-        true
-      ensure
-        file.close
-      end
-
-      protected
-
-      def path
-        ::File.join(::Dir.pwd, name)
-      end
-    end
-  end
-end

data/lib/brutal/file.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-%w[
-  read
-  write
-].each { |filename| require_relative(File.join("file", filename)) }
-
-module Brutal
-  # Brutal::File
-  module File
-    DEFAULT_CONFIG_FILENAME = ".brutal.yml"
-    DEFAULT_GENERATED_FILENAME = "test.rb"
-    RUBY_EXTENSION = ".rb"
-
-    def self.generated_pathname(pathname)
-      filename = pathname.basename
-      return pathname.dirname + DEFAULT_GENERATED_FILENAME if default_config_filename?(filename)
-
-      pathname.sub_ext(RUBY_EXTENSION)
-    end
-
-    def self.override_protection(pathname)
-      abort "A #{pathname} file already exists!" if pathname.exist?
-    end
-
-    def self.default_config_filename?(filename)
-      filename.to_s == DEFAULT_CONFIG_FILENAME
-    end
-    private_class_method :default_config_filename?
-  end
-end

data/lib/brutal/scaffold.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Brutal
-  # Brutal::Scaffold
-  #
-  # @since 1.0.0
-  class Scaffold
-    # Specifies templates to challenge evaluated subjects & get results.
-    attr_reader :actuals
-
-    # Specifies a list of variables to populate the subject's template.
-    attr_reader :contexts
-
-    # Specifies the code to execute before generating the test suite.
-    attr_reader :header
-
-    # Specifies the template of the code to be declined across contexts.
-    attr_reader :subject
-
-    # Initialize a new scaffold generator.
-    def initialize(header, subject, *actuals, **contexts)
-      warn("Empty subject!")        if subject.empty?
-      warn("Empty actual values!")  if actuals.empty?
-      warn("Empty contexts!")       if contexts.empty?
-
-      eval(header) # rubocop:disable Security/Eval
-
-      @header   = header
-      @subject  = subject
-      @actuals  = actuals
-      @contexts = contexts
-    end
-
-    # Return a Ruby string that can be evaluated.
-    def inspect(object)
-      return object.to_s unless object.is_a?(::String)
-
-      object.strip
-    end
-
-    # Return a string representation.
-    #
-    # @return [String]
-    def to_s
-      ruby_lines.join(separator_ruby_code)
-    end
-
-    def attributes(*values)
-      context_names.each_with_index.inject({}) do |h, (name, i)|
-        h.merge(name.to_sym => inspect(values.fetch(i)))
-      end
-    end
-
-    def context_names
-      contexts.keys.sort
-    end
-
-    def contexts_values
-      context_names.map { |context_name| contexts.fetch(context_name) }
-    end
-
-    def combinations_values
-      Array(contexts_values[0]).product(*Array(contexts_values[1..]))
-    end
-
-    def ruby_lines
-      [header_ruby_code] + actual_ruby_codes
-    end
-
-    def actual_ruby_codes
-      combinations_values.map do |values|
-        actual_str = format(inspect(subject), **attributes(*values))
-        string = actual_ruby_code(actual_str)
-        actual = eval(actual_str) # rubocop:disable Security/Eval, Lint/UselessAssignment
-
-        actuals.each do |actual_value|
-          result_str = format(actual_value, subject: "actual")
-          string += "raise if #{result_str} != #{eval(result_str).inspect}\n" # rubocop:disable Security/Eval
-        end
-
-        string
-      end
-    end
-
-    def actual_ruby_code(actual_str)
-      <<~RUBY_CODE
-        actual = begin
-        #{actual_str.gsub(/^/, '  ')}
-        end
-
-      RUBY_CODE
-    end
-
-    def header_ruby_code
-      <<~RUBY_CODE
-        #{header.chomp}
-      RUBY_CODE
-    end
-
-    def separator_ruby_code
-      <<~RUBY_CODE
-
-        #{thematic_break_ruby_code}
-      RUBY_CODE
-    end
-
-    def thematic_break_ruby_code
-      <<~RUBY_CODE
-        # #{'-' * 78}
-      RUBY_CODE
-    end
-  end
-end

data/lib/brutal/yaml.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-module Brutal
-  # Brutal::Yaml
-  #
-  # @since 1.1.0
-  module Yaml
-    FILENAME_EXTENSIONS = %w[
-      .yaml
-      .yml
-    ].freeze
-
-    def self.parse(yaml)
-      ::YAML.safe_load(yaml, symbolize_names: false)
-    end
-
-    def self.parse?(pathname)
-      filename_extension = pathname.extname
-      FILENAME_EXTENSIONS.include?(filename_extension)
-    end
-  end
-end