brutal 1.3.0 → 1.6.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f98c650c2e97438b0cedcebdb5b01da84af29f7cbc0c324a4b3416b3da68114
-  data.tar.gz: 696e8e96639a62e046f138c10f3d5181a3265c90bb10306481bc0d2b2fd9d3d0
+  metadata.gz: 37fdb51264d859c50519c1bfc0f511542eb8bcca0817049e11191977d06cb7b1
+  data.tar.gz: 54e26e7e3ad8cc403fdb6c1db116186c61d06b0766eb8fa5e96ed7688913872b
 SHA512:
-  metadata.gz: b6279a503eba6120d29cd8855fab48c725f46671bd8efa7d6fd73158e68d0cf6de9fed01e4f5ae83cf04417b0551ab9598d6c615d25b164fbefec1d3b7ce262f
-  data.tar.gz: 8aebd74fd0a2c9bda6b418980dd627645f9b1c85f3e92e753ba2c03bd642d0dd63393dfd8923ef25e470269e3b6645fa3428a54cd7b2128ca53ee2b5c9e5de63
+  metadata.gz: d42f48f5e24be39950a9e5a1bfb521a84a37402b8cb3cca1eb680767ce63410ab44b836310ba7792af80a8d9c9f803ba30c9e08dff4f1094fde184409f81c95c
+  data.tar.gz: 40a6cf45ccdc12816d677fd5c8d19ed4c6305ec135c66fc2e56bd11f595291d9c16715b979ff920b1ed36cc90bddfe783db3653fb7f072cbc77ef8a0d760c769

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.beta1", require: false
 ```
 
 And then execute:
@@ -50,91 +50,79 @@ bundle install
 Or install it yourself as:
 
 ```sh
-gem install brutal
+gem install brutal --pre
 ```
 
-## Quick Start
+## Command line
 
-Just type `brutal` in a Ruby project's folder and watch the magic happen.
+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 --help
+```
+
+```txt
+Usage: #{$PROGRAM_NAME} [options] [files or directories]
+
+    --format=FORMAT Choose "ruby" (default).
+    --help          Display this help.
+    --version       Display the version.
+```
 
 ## Usage
 
-__Brutal__ needs a configuration file, it's a kind of manifest, or a meta-spec if you prefer.
-This file is composed of 4 top-level sections:
+__Brutal__ needs configuration files in YAML format to know how to write tests.
+Configuration file names are suffixed by `_brutal.yaml` and composed of 4 top-level sections:
 
 * `header` - Specifies the code to execute before generating the test suite.
 * `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.
 
-By default, this file is called `.brutal.yml`, but it would be possible to call it differently by passing it as an argument to the brutal command.
-
-Currently, only the YAML format is supported.
-
-### Getting started
+When the configuration file is present, the generation of a test suite can be done with the command:
 
-1. Create a `.brutal.yml` file in your application's root directory.
-The following example `.brutal.yml` defines the shape of a Hello test suite:
+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:
 
-```yaml
----
-subject: |
-  "Hello " + "%{string}"
-
-contexts:
-  string:
-    - Alice
-    - Bob
-
-actuals:
-  - "%{subject}.to_s"
-  - "%{subject}.length"
+```sh
+brutal user_brutal.yaml
 ```
 
-2. Run the `brutal` command from the same directory.
+or:
 
-3. Read the generated `test.rb` file in the same directory:
-
-```ruby
-# Brutal test suite
-
-# ------------------------------------------------------------------------------
+```sh
+brutal .
+```
 
-actual = begin
-  "Hello " + "Alice"
-end
+or even:
 
-raise if actual.to_s != "Hello Alice"
-raise if actual.length != 11
+```sh
+brutal
+```
 
-# ------------------------------------------------------------------------------
+This would create a `user_brutal.rb` file containing the test suite.
 
-actual = begin
-  "Hello " + "Bob"
-end
+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:
 
-raise if actual.to_s != "Hello Bob"
-raise if actual.length != 9
+```sh
+brutal spec/ # => generate tests from each configuration file matching ./spec/**/*_brutal.yaml in to ./spec/**/*_brutal.rb
 ```
 
-### More examples
+### Some examples
 
-https://github.com/fixrb/brutal/raw/main/examples/
+<https://github.com/fixrb/brutal/blob/v1.6.0.beta1/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 = "**/*_brutal.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,6 +1,14 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require_relative File.join("..", "lib", "brutal", "command_line_arguments_parser")
+format, pathnames = Brutal::CommandLineArgumentsParser.new(*ARGV).call
+
 require_relative File.join("..", "lib", "brutal")
+generator = Brutal.new(format: format)
 
-Brutal.generate! ARGV.fetch(0, Brutal::File::DEFAULT_CONFIG_FILENAME)
+pathnames.each do |pathname|
+  Dir.chdir(pathname.dirname) do
+    generator.call(pathname.basename)
+  end
+end

data/lib/brutal/command_line_arguments_parser.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+class Brutal
+  # Accept an arbitrary number of arguments passed from the command-line.
+  class CommandLineArgumentsParser
+    DEFAULT_FORMAT = "ruby"
+    FILE_SUFFIX = "_brutal.yaml"
+    FILE_PATTERN = ::File.join("**", "*#{FILE_SUFFIX}")
+    CURRENT_EXECUTION_CONTEXT = "."
+
+    attr_reader :pathnames
+
+    def initialize(*args)
+      @any_path = false
+      @pathnames = []
+      args.each { |arg| parse!(arg) }
+      parse!(CURRENT_EXECUTION_CONTEXT) unless any_path?
+    end
+
+    def call
+      [format, pathnames]
+    end
+
+    private
+
+    def any_path?
+      @any_path
+    end
+
+    def format
+      @format || DEFAULT_FORMAT
+    end
+
+    def parse!(arg)
+      case arg
+      when "--format=ruby"
+        format!("Ruby")
+      when "--help"
+        help!
+      when "--version"
+        version!
+      else
+        pathname = ::Pathname.new(arg)
+        load!(pathname)
+      end
+    end
+
+    def format!(name)
+      raise ::ArgumentError, "Format already filled in." unless format.nil?
+
+      @format = name
+    end
+
+    def help!
+      puts help_command_output
+      exit
+    end
+
+    def help_command_output
+      <<~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)
+      @any_path = true
+
+      if pathname.directory?
+        pathname.glob(FILE_PATTERN).each { |filename| load!(filename) }
+      elsif pathname.file?
+        if pathname.to_s.end_with?(FILE_SUFFIX)
+          @pathnames << pathname
+        else
+          warn "Skipping #{pathname} because not suffixed with #{FILE_SUFFIX}."
+        end
+      else
+        raise ::ArgumentError, "#{pathname} is neither a file nor a directory."
+      end
+    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["brutal"]
+    end
+
+    def not_loaded_spec?
+      loaded_spec.nil?
+    end
+  end
+end

data/lib/brutal/configuration.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Brutal
+class Brutal
   # Brutal::Configuration
   #
   # @since 1.0.0

data/lib/brutal/file/read.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Brutal
+class Brutal
   module File
     # Brutal::File::Read
     #
@@ -15,7 +15,7 @@ module Brutal
       def call
         ::File.read(path)
       rescue ::Errno::ENOENT => _e
-        abort("File #{path} not found!")
+        abort "File #{path} not found!"
       end
 
       protected

data/lib/brutal/file/write.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Brutal
+class Brutal
   module File
     # Brutal::File::Write
     #

data/lib/brutal/file.rb

@@ -5,16 +5,13 @@
   write
 ].each { |filename| require_relative(File.join("file", filename)) }
 
-module Brutal
+class Brutal
   # Brutal::File
   module File
-    DEFAULT_CONFIG_FILENAME = ".brutal.yml"
-    DEFAULT_GENERATED_FILENAME = "test.rb"
+    RUBY_EXTENSION = ".rb"
 
-    def self.generated_filename(filename)
-      return DEFAULT_GENERATED_FILENAME if filename == DEFAULT_CONFIG_FILENAME
-
-      filename.gsub(/.[^.]+\z/, ".rb")
+    def self.generated_pathname(pathname)
+      pathname.sub_ext(RUBY_EXTENSION)
     end
   end
 end

data/lib/brutal/format/ruby.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class Brutal
+  module Format
+    # Ruby format class
+    class Ruby
+      # 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
+end

data/lib/brutal/format.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+%w[
+  ruby
+].each { |filename| require_relative(File.join("format", filename)) }
+
+class Brutal
+  # Brutal::Format
+  module Format
+    SUPPORT = {
+      "ruby" => Ruby
+    }.freeze
+
+    DEFAULT = SUPPORT.keys.sort.fetch(-1)
+  end
+end

data/lib/brutal/yaml.rb

@@ -2,23 +2,18 @@
 
 require "yaml"
 
-module Brutal
+class Brutal
   # Brutal::Yaml
-  #
-  # @since 1.1.0
   module Yaml
-    FILENAME_EXTENSIONS = %w[
-      yaml
-      yml
-    ].freeze
+    FILENAME_EXTENSION = ".yaml"
 
     def self.parse(yaml)
       ::YAML.safe_load(yaml, symbolize_names: false)
     end
 
-    def self.parse?(filename)
-      filename_extension = filename.split(".")[1..][-1]
-      FILENAME_EXTENSIONS.include?(filename_extension)
+    def self.parse?(pathname)
+      filename_extension = pathname.extname
+      filename_extension.eql?(FILENAME_EXTENSION)
     end
   end
 end

data/lib/brutal.rb

@@ -3,31 +3,48 @@
 %w[
   configuration
   file
-  scaffold
+  format
   yaml
 ].each { |filename| require_relative(File.join("brutal", filename)) }
 
 # The Brutal namespace.
-module Brutal
-  def self.generate!(filename)
-    file = File::Read.new(filename).call
+class Brutal
+  attr_reader :format
 
-    hash = if Yaml.parse?(filename)
-             Yaml.parse(file)
-           else
-             raise ::ArgumentError, "Unrecognized extension.  " \
-                                    "Impossible to parse #{filename.inspect}."
-           end
+  def initialize(format: Format::DEFAULT)
+    @format = String(format)
+  end
 
+  def call(pathname)
+    hash = parse(pathname)
     conf = Configuration.load(hash)
+    code = scaffold(conf)
+    write(pathname, code)
+  end
+
+  def scaffold(conf)
+    engine = Format::SUPPORT.fetch(format) do
+      raise ::NotImplementedError, "#{format.inspect} format is not supported."
+    end
+
+    engine.new(conf.header, conf.subject, *conf.actuals, **conf.contexts)
+  end
 
-    ruby = Scaffold.new(conf.header,
-                        conf.subject,
-                        *conf.actuals,
-                        **conf.contexts)
+  private
 
-    new_filename = File.generated_filename(filename)
+  def parse(pathname)
+    return Yaml.parse(read(pathname)) if Yaml.parse?(pathname)
+
+    raise ::ArgumentError, "Unrecognized extension.  " \
+                           "Impossible to parse #{pathname.inspect}."
+  end
+
+  def read(pathname)
+    File::Read.new(pathname).call
+  end
 
-    File::Write.new(new_filename).call(ruby)
+  def write(pathname, ruby)
+    new_pathname = File.generated_pathname(pathname)
+    File::Write.new(new_pathname).call(ruby)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brutal
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.6.0.beta1
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-21 00:00:00.000000000 Z
+date: 2022-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,11 +147,13 @@ files:
 - README.md
 - bin/brutal
 - lib/brutal.rb
+- lib/brutal/command_line_arguments_parser.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/format.rb
+- lib/brutal/format/ruby.rb
 - lib/brutal/yaml.rb
 homepage: https://github.com/fixrb/brutal
 licenses:
@@ -169,9 +171,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/scaffold.rb

@@ -1,88 +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
-      "#{header.chomp}\n#{blank_line}" + combinations_values.map do |values|
-        attributes = context_names.each_with_index.inject({}) do |h, (name, i)|
-          h.merge(name.to_sym => inspect(values.fetch(i)))
-        end
-
-        actual_str = format(inspect(subject), **attributes)
-
-        string = <<~CODE
-          actual = begin
-          #{actual_str.gsub(/^/, '  ')}
-          end
-
-        CODE
-
-        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.join(blank_line)
-    end
-
-    def blank_line
-      "\n" \
-        "# #{'-' * 78}\n" \
-        "\n"
-    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
-  end
-end