baf 0.14.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 30b9c85a7af0b78d5fde855f4df47b907ee0f3f4
-  data.tar.gz: 5fc0895f480eb22b9589c2d7ae5cb292838db483
+SHA256:
+  metadata.gz: 9ae72395dc2c034e6b12f33f383794c31ed4ab8d0e93ebd4ae939c9ea3f218a5
+  data.tar.gz: 28268255bb47195a8647bdc66c2f89e21dbfd5dafbc6d6dcf7a473a8fee5d239
 SHA512:
-  metadata.gz: 1048997ad551c80a4927c97966aa647eab6e3480a26f2131f2593bd0af29dfa0791ac74a401acce57972c9af5a8aa30b2c32121d1fc714c27c83a010c96a4e7b
-  data.tar.gz: 946e877506f84efecd2f6ab63a9a8dece8665c1d6f592301424b3b58af3ac586ecc51ae08e34fe65f0d5bf966207d713bee23853951eea52be0ec74683bd309e
+  metadata.gz: 2ba74a745aa0b8e85a1045727a69c9fb5e4b931966391fbf81486f2fd2ed8ba0937323e93afdf30f20979d175762ec78b20ce4c677cad2d8caf6f7d53f4ee8d2
+  data.tar.gz: 845a48d062d19a4b81f909d534a7314a9d109a430a5222d03e7d1a35c30896473d146ef675d1f91290432e1579b3abf5810c24ac3df9292c3669ecbf7fbd6a6b

data/lib/baf/cli.rb

@@ -10,7 +10,7 @@ module Baf
   class CLI
     ArgumentError = Class.new ::Baf::ArgumentError
 
-    EX_USAGE    = 64
+    EX_USAGE = 64
     EX_SOFTWARE = 70
 
     class << self
@@ -43,15 +43,17 @@ module Baf
         parent = Object.const_get parent_name
         parent.const_defined?(:Env) ? parent.const_get(:Env) : Env
       end
+
+      def ruby2_keywords *; end unless Module.respond_to? :ruby2_keywords, true
     end
 
     attr_reader :arguments, :env, :parser
 
     def initialize env, arguments, **opts
-      @env        = env
-      @arguments  = arguments
-      @parser     = opts[:parser]     || OptionParser.new
-      @registrant = opts[:registrant] || OptionsRegistrant.new
+      @env = env
+      @arguments = arguments
+      @parser = opts.fetch(:parser) { OptionParser.new }
+      @registrant = opts.fetch(:registrant) { OptionsRegistrant.new }
 
       registrant.register(env, parser) { setup }
     end
@@ -63,6 +65,7 @@ module Baf
       registrant.banner = arg
     end
 
+    ruby2_keywords \
     def flag *args
       registrant.flag *args
     end
@@ -80,15 +83,15 @@ module Baf
         tail: true
     end
 
-    def option *args
-      args = [*args, Proc.new] if block_given?
+    def option *args, &block
+      args = [*args, block] if block_given?
       registrant.option *args
     end
 
     def parse_arguments!
       parser.parse! arguments
     rescue OptionParser::InvalidOption
-      raise ArgumentError, parser
+      fail ArgumentError, parser
     end
 
     def usage!

data/lib/baf/env.rb

@@ -7,9 +7,9 @@ module Baf
     def_delegators :@output, :print, :puts
     def_delegator :@output_error, :puts, :puts_error
 
-    def initialize input: $input, output: $stdout, output_error: $stderr
-      @input        = input
-      @output       = output
+    def initialize input: $stdin, output: $stdout, output_error: $stderr
+      @input = input
+      @output = output
       @output_error = output_error
     end
 

data/lib/baf/option.rb

@@ -1,11 +1,11 @@
 module Baf
   class Option
-    LONG_PREFIX             = '--'.freeze
-    LONG_NORMALIZE_SEARCH   = ?_.freeze
-    LONG_NORMALIZE_REPLACE  = ?-.freeze
-    LONG_WITH_ARG_GLUE      = ' '.freeze
-    PARSER_MESSAGE          = :on
-    PARSER_MESSAGE_TAIL     = :on_tail
+    LONG_PREFIX = '--'.freeze
+    LONG_NORMALIZE_SEARCH = ?_.freeze
+    LONG_NORMALIZE_REPLACE = ?-.freeze
+    LONG_WITH_ARG_GLUE = ' '.freeze
+    PARSER_MESSAGE = :on
+    PARSER_MESSAGE_TAIL = :on_tail
 
     attr_accessor :short, :long, :arg, :desc, :block, :tail
 
@@ -41,20 +41,20 @@ module Baf
 
     def build_attrs short, long, arg_or_desc = nil, desc_or_block = nil, block = nil
       {
-        short:  short,
-        long:   long,
-        desc:   arg_or_desc
+        short: short,
+        long: long,
+        desc: arg_or_desc
       }.merge case desc_or_block
       when Proc
         {
-          desc:   arg_or_desc,
-          block:  desc_or_block
+          desc: arg_or_desc,
+          block: desc_or_block
         }
       when String
         {
-          arg:    arg_or_desc,
-          desc:   desc_or_block,
-          block:  block
+          arg: arg_or_desc,
+          desc: desc_or_block,
+          block: block
         }
       else
         {}

data/lib/baf/options_registrant.rb

@@ -3,8 +3,8 @@ require 'baf/option'
 
 module Baf
   class OptionsRegistrant
-    SUMMARY_HEADER    = "\noptions:".freeze
-    HELP_PARSER_ARGS  = %w[
+    SUMMARY_HEADER = "\noptions:".freeze
+    HELP_PARSER_ARGS = %w[
       -h
       --help
       print\ this\ message

data/lib/baf/testing/cucumber/steps/execution.rb

@@ -1,50 +1,35 @@
-def program_run check: false, opts: nil, args: nil, wait: true
-  cmd = [*@_baf_program ||= %w[ruby baf]]
-  cmd << opts if opts
-  cmd << args.split(' ') if args
-  if wait
-    run_simple cmd.join(' '), fail_on_error: false
-  else
-    run cmd.join ' '
-  end
-  program_run_check if check
-end
-
-def program_run_check status: 0
-  expect(last_command_started).to have_exit_status status
-rescue RSpec::Expectations::ExpectationNotMetError => e
-  if ENV.key? 'BAF_TEST_DEBUG'
-    fail RSpec::Expectations::ExpectationNotMetError, <<-eoh
-#{e.message} Output was:
-  ```\n#{last_command_started.output.lines.map { |l| "  #{l}" }.join}  ```
-    eoh
-  else
-    raise
-  end
+def run state, cmd: nil, wait: true, args: []
+  cmd ||= state[:program]
+  Baf::Testing.run cmd + args,
+    wait: wait,
+    env_allow: state.fetch(:env_allow) { [] },
+    timeout: state[:exec_timeout]
 end
 
 
 When /^I( successfully)? (run|\w+) the program$/ do |check, run|
-  program_run check: !!check, wait: run == 'run'
-end
-
-When /^I( successfully)? (run|\w+) the program with arguments? (.+)$/ do |check, run, args|
-  program_run check: !!check, args: args, wait: run == 'run'
+  $_baf[:process] = run $_baf, wait: run == 'run'
+  Baf::Testing.expect_ex $_baf[:process], 0 if check
 end
 
-When /^I( successfully)? (run|\w+) the program with command (.+)$/ do |check, run, cmd|
-  program_run check: !!check, args: cmd, wait: run == 'run'
+When(
+  /^I( successfully)? (run|\w+) the program with (?:argument|command|option)s? (.+)$/
+) do |check, run, args|
+  $_baf[:process] = run $_baf, wait: run == 'run', args: args.split(' ')
+  Baf::Testing.expect_ex $_baf[:process], 0 if check
 end
 
-When /^I( successfully)? (run|\w+) the program with options? (-.+)$/ do |check, run, opts|
-  program_run check: !!check, opts: opts, wait: run == 'run'
+When /^I( successfully)? (run|\w+) `([^`]+)`$/ do |check, run, command|
+  $_baf[:process] = run $_baf, cmd: command.split(' '), wait: run == 'run'
+  Baf::Testing.expect_ex $_baf[:process], 0 if check
 end
 
 
-Then /^the exit status must be (\d+)$/ do |exit_status|
-  program_run_check status: exit_status.to_i
+Then /^the program must terminate successfully$/ do
+  Baf::Testing.wait $_baf[:process]
+  Baf::Testing.expect_ex $_baf[:process], 0
 end
 
-Then /^the program must terminate successfully$/ do
-  program_run_check status: 0
+Then /^the exit status must be (\d+)$/ do |exit_status|
+  Baf::Testing.expect_ex $_baf[:process], Integer(exit_status)
 end

data/lib/baf/testing/cucumber/steps/filesystem.rb

@@ -0,0 +1,3 @@
+Given /^a file named ([^ ]+) with:$/ do |path, content|
+  Baf::Testing.write_file path, content + $/
+end

data/lib/baf/testing/cucumber/steps/input.rb

@@ -1,3 +1,3 @@
 When /^I input "([^"]+)"$/ do |content|
-  last_command_started.write unescape_text content
+  $_baf[:process].input Baf::Testing.unescape_step_arg content
 end

data/lib/baf/testing/cucumber/steps/output.rb

@@ -1,44 +1,35 @@
-def build_regexp pattern, options
-  Regexp.new(pattern, options.each_char.inject(0) do |m, e|
-    m | case e
-      when ?i then Regexp::IGNORECASE
-      when ?m then Regexp::MULTILINE
-      when ?x then Regexp::EXTENDED
-    end
-  end)
-end
-
-def expect_output content, stream: :output
-  stream = :stderr if stream == :error
-  expect(last_command_started.send stream).to eq unescape_text content
-end
-
-
 Then /^the output must be empty$/ do
-  expect(last_command_started.output).to be_empty
+  expect($_baf[:process].output).to be_empty
 end
 
 Then /^the output must contain:$/ do |content|
-  expect(last_command_started.output).to include unescape_text content
+  expect($_baf[:process].output).to include content
 end
 
 Then /^the output must contain "([^"]+)"$/ do |content|
-  expect(last_command_started.output).to include unescape_text content
+  expect($_baf[:process].output).to include content
 end
 
 Then /^the output must not contain "([^"]+)"$/ do |content|
-  expect(last_command_started.output).not_to include unescape_text content
+  expect($_baf[:process].output).not_to include content
 end
 
 Then /^the output must contain exactly:$/ do |content|
-  expect_output content + $/
+  expect($_baf[:process].output).to eq content + $/
 end
 
 Then /^the( error)? output must contain exactly "([^"]+)"$/ do |stream, content|
   stream = stream ? :error : :output
-  expect_output content, stream: stream
+  expect($_baf[:process].output stream)
+    .to eq Baf::Testing::unescape_step_arg content
+end
+
+Then /^the output must match:/ do |pattern|
+  expect($_baf[:process].output)
+    .to match Baf::Testing.build_regexp(pattern, 'mx')
 end
 
 Then /^the output must match \/([^\/]+)\/([a-z]*)$/ do |pattern, options|
-  expect(last_command_started.output).to match build_regexp(pattern, options)
+  expect($_baf[:process].output)
+    .to match Baf::Testing.build_regexp(pattern, options)
 end

data/lib/baf/testing/cucumber/steps/output_wait.rb

@@ -1,57 +1,16 @@
-require 'timeout'
-
-module Baf
-  module Testing
-    class WaitError < ::StandardError
-      attr_reader :timeout
-
-      def initialize message, timeout
-        super message
-        @timeout = timeout
-      end
-    end
-  end
-end
-
-def wait_output! pattern, times: 1, results: nil
-  output = -> { last_command_started.output }
-  wait_until do
-    case pattern
-    when Regexp then (results = output.call.scan(pattern)).size >= times
-    when String then output.call.include? pattern
-    end
-  end
-  results
-rescue Baf::Testing::WaitError => e
-  fail <<-eoh
-expected `#{pattern}' not seen after #{e.timeout} seconds in:
-  ```\n#{output.call.lines.map { |l| "  #{l}" }.join}  ```
-  eoh
-end
-
-def wait_until message: 'condition not met after %d seconds'
-  timeout = ENV.key?('BAF_TEST_TIMEOUT') ?
-    ENV['BAF_TEST_TIMEOUT'].to_i :
-    2
-  Timeout.timeout timeout do
-    loop do
-      break if yield
-      sleep 0.05
-    end
-  end
-rescue Timeout::Error
-  raise Baf::Testing::WaitError.new(message % timeout, timeout)
+def wait_output pattern, output: -> { $_baf[:process].output }, times: 1
+  Baf::Testing.wait_output pattern, stream: output, times: times
 end
 
 
 Then /^the output will match \/([^\/]+)\/([a-z]*)$/ do |pattern, options|
-  wait_output! build_regexp pattern, options
+  wait_output Baf::Testing.build_regexp pattern, options
 end
 
 Then /^the output will contain:$/ do |content|
-  wait_output! content + $/
+  wait_output content + $/
 end
 
 Then /^the output will contain "([^"]+)"$/ do |content|
-  wait_output! content
+  wait_output content
 end

data/lib/baf/testing/cucumber.rb

@@ -1,5 +1,11 @@
-require 'aruba/api'
-require 'aruba/cucumber/hooks'
-
+require 'baf/testing'
 require 'baf/testing/cucumber/steps/execution'
+require 'baf/testing/cucumber/steps/filesystem'
 require 'baf/testing/cucumber/steps/output'
+
+$_baf = {}
+
+Around do |_, block|
+  Baf::Testing.exercise_scenario &block
+  $_baf.delete :process
+end

data/lib/baf/testing/process.rb

@@ -0,0 +1,107 @@
+require 'baf'
+
+require 'tempfile'
+
+module Baf
+  module Testing
+    class Process
+      ExecutionFailure = Class.new Error
+
+      TIMEOUT = 4
+      TMP_FILE_PREFIX = 'baf_test_'.freeze
+      WAIT_POLL_DELAY = 0.01
+
+      attr_reader :pid, :exit_status, :timeout
+
+      def initialize command, env_allow: [], timeout: TIMEOUT
+        @command = command
+        @env_allow = env_allow
+        @timeout = timeout
+        @stdout = Tempfile.new TMP_FILE_PREFIX
+        @stderr = Tempfile.new TMP_FILE_PREFIX
+      end
+
+      def start
+        reader, writer = IO.pipe
+
+        @pid = spawn env,
+          *@command,
+          unsetenv_others: true,
+          in: reader,
+          out: @stdout,
+          err: @stderr
+        reader.close
+        @stdin = writer
+      rescue Errno::ENOENT => e
+        fail ExecutionFailure, e.message
+      end
+
+      def wait timeout: @timeout
+        deadline = Time.now + timeout
+        wait_poll
+        until stopped? || Time.now >= deadline
+          sleep WAIT_POLL_DELAY
+          wait_poll
+        end
+        yield unless stopped? if block_given?
+      end
+
+      def stop wait_timeout: 1
+        ::Process.kill :TERM, @pid
+        wait timeout: wait_timeout
+        return if stopped?
+        ::Process.kill :KILL, @pid
+        ::Process.wait2 @pid
+      rescue Errno::ECHILD, Errno::ESRCH
+      end
+
+      def running?
+        started? && !stopped?
+      end
+
+      def input str
+        @stdin.write str
+      end
+
+      def output stream = nil
+        case stream
+          when :output then [@stdout]
+          when :error then [@stderr]
+          else [@stdout, @stderr]
+        end.inject '' do |memo, stream|
+          memo + IO.read(stream.path)
+        end
+      end
+
+    private
+
+      def env
+        ENV.inject({}) do |acc, (k, v)|
+          if env_allow? k then acc.merge k => v else acc end
+        end.merge 'HOME' => File.realpath(?.)
+      end
+
+      def env_allow? var
+        @env_allow.any? do |e|
+          case e
+            when String then var == e
+            when Regexp then var =~ e
+          end
+        end
+      end
+
+      def started?
+        !!@pid
+      end
+
+      def stopped?
+        !!@exit_status
+      end
+
+      def wait_poll
+        pid, status = ::Process.wait2 @pid, ::Process::WNOHANG
+        @exit_status = status.exitstatus if pid
+      end
+    end
+  end
+end

data/lib/baf/testing.rb

@@ -0,0 +1,138 @@
+require 'fileutils'
+
+require 'baf'
+require 'baf/testing/process'
+
+module Baf
+  module Testing
+    ExecutionTimeout = Class.new Error
+    ExitStatusMismatch = Class.new Error
+
+    class WaitError < Error
+      attr_reader :timeout
+
+      def initialize message, timeout
+        super message
+        @timeout = timeout
+      end
+    end
+
+    ENV_WHITELIST = [
+      /\ACHRUBY_/,
+      /\AGEM_/,
+      'PATH',
+      /\ARB_/,
+      'RUBYOPT'
+    ].freeze
+
+    EXEC_TIMEOUT_ERROR_FMT = 'process did not exit after %.03f seconds'.freeze
+
+    EXIT_STATUS_MISMATCH_FMT = <<~eoh.freeze
+      expected %<expected>d exit status got %<actual>d; output was:
+      %{separator}
+      %{output}
+      %{separator}
+    eoh
+
+    OUTPUT_SEPARATOR = (?- * 70).freeze
+
+    WAIT_MESSAGE_FMT = 'condition not met after %.03f seconds'.freeze
+    WAIT_OUTPUT_MESSAGE_FMT = <<~eoh.freeze
+      expected `%{pattern}' not seen after %<timeout>.03f seconds in:
+      %{separator}
+      %{output}
+      %{separator}
+    eoh
+    WAIT_TIMEOUT = ENV.key?('BAF_TEST_TIMEOUT') ?
+      ENV['BAF_TEST_TIMEOUT'].to_i :
+      2
+
+    WORKING_DIR = 'tmp/uat'.freeze
+
+    class << self
+      def build_regexp pattern, options = ''
+        Regexp.new(pattern, options.each_char.inject(0) do |m, e|
+          m | case e
+            when ?i then Regexp::IGNORECASE
+            when ?m then Regexp::MULTILINE
+            when ?x then Regexp::EXTENDED
+          end
+        end)
+      end
+
+      def exercise_scenario dir: WORKING_DIR
+        FileUtils.remove_entry_secure dir, true
+        FileUtils.mkdir_p dir
+        Dir.chdir dir do
+          yield
+        end
+      end
+
+      def expect_ex process, exit_status
+        return if process.exit_status == exit_status
+
+        fail ExitStatusMismatch, EXIT_STATUS_MISMATCH_FMT % {
+          expected: exit_status,
+          actual: process.exit_status,
+          separator: OUTPUT_SEPARATOR,
+          output: process.output.chomp
+        }
+      end
+
+      def run command, wait: true, env_allow: [], timeout: nil
+        Process.new(
+          command,
+          env_allow: ENV_WHITELIST + env_allow,
+          timeout: timeout || Process::TIMEOUT
+        ).tap do |process|
+          process.start
+          wait process if wait
+        end
+      end
+
+      def wait process
+        process.wait do
+          process.stop
+          fail ExecutionTimeout, EXEC_TIMEOUT_ERROR_FMT % process.timeout
+        end
+      end
+
+      def unescape_step_arg str
+        str.gsub '\n', "\n"
+      end
+
+      def wait_until message: WAIT_MESSAGE_FMT, timeout: WAIT_TIMEOUT
+        return if yield
+        deadline = Time.now + timeout
+        until Time.now >= deadline
+          return if yield
+          sleep 0.05
+        end
+        fail WaitError.new message % timeout, timeout
+      end
+
+      def wait_output pattern, stream:, times: 1, timeout: WAIT_TIMEOUT
+        results = nil
+        wait_until timeout: timeout do
+          case pattern
+            when Regexp then (results = stream.call.scan(pattern)).size >= times
+            when String then stream.call.include? pattern
+          end
+        end
+        results
+      rescue Baf::Testing::WaitError => e
+        fail Baf::Testing::WaitError.new(WAIT_OUTPUT_MESSAGE_FMT % {
+          pattern: pattern,
+          timeout: timeout,
+          separator: OUTPUT_SEPARATOR,
+          output: stream.call.chomp
+        }, timeout)
+      end
+
+      def write_file path, content
+        FileUtils.mkdir_p File.dirname path
+        IO.write path, content
+      end
+    end
+  end
+end

data/lib/baf.rb

@@ -1,4 +1,4 @@
 module Baf
-  Error         = Class.new ::StandardError
+  Error = Class.new ::StandardError
   ArgumentError = Class.new Error
 end

metadata

@@ -1,44 +1,119 @@
 --- !ruby/object:Gem::Specification
 name: baf
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.1
 platform: ruby
 authors:
 - Thibault Jouan
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-10-22 00:00:00.000000000 Z
+date: 2022-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: baf-testing
+  name: rake
   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: rake
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '3.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10'
-description: Basic Application Framework
+        version: '3.11'
+description: |
+  == Baf
+
+  baf helps writing an user acceptance test suite with a dedicated library
+  and cucumber steps. It can run and wait for programs in a modified
+  environment, verify the exit status, the output streams and other side
+  effects. It also supports interactive programs and writing to their
+  standard input.
+
+  Then, it provides a DSL to write the CLI:
+
+      require 'baf/cli'
+
+      module MyProgram
+        class CLI < Baf::CLI
+          def setup
+            flag_version '0.1.2'.freeze
+
+            option :c, :config, 'config', 'specify config file' do |path|
+              @config_path = path
+            end
+          end
+
+          def run
+            usage! unless arguments.any?
+
+            puts 'arguments: %s' % arguments
+            puts 'config: %s' % @config_path if @config_path
+          end
+        end
+      end
+
+      MyProgram::CLI.run ARGV
+
+  Which behaves this way:
+
+      % ./my_program
+      Usage: my_program [options]
+
+      options:
+          -c, --config config              specify config file
+
+          -h, --help                       print this message
+          -V, --version                    print version
+      zsh: exit 64    ./my_program
+
+      % ./my_program --wrong-arg
+      Usage: my_program [options]
+
+      options:
+          -c, --config config              specify config file
+
+          -h, --help                       print this message
+          -V, --version                    print version
+      zsh: exit 64    ./my_program --wrong-arg
+
+      % ./my_program foo
+      arguments ["foo"]
+
+      % ./my_program -c some_file foo
+      arguments ["foo"]
+      config path some_file
 email: tj@a13.fr
 executables: []
 extensions: []
@@ -50,17 +125,19 @@ files:
 - lib/baf/flag.rb
 - lib/baf/option.rb
 - lib/baf/options_registrant.rb
+- lib/baf/testing.rb
 - lib/baf/testing/cucumber.rb
 - lib/baf/testing/cucumber/steps/execution.rb
+- lib/baf/testing/cucumber/steps/filesystem.rb
 - lib/baf/testing/cucumber/steps/input.rb
 - lib/baf/testing/cucumber/steps/output.rb
 - lib/baf/testing/cucumber/steps/output_wait.rb
-- lib/baf/version.rb
+- lib/baf/testing/process.rb
 homepage: https://rubygems.org/gems/baf
 licenses:
 - BSD-3-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -75,9 +152,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.3.17
+signing_key:
 specification_version: 4
-summary: Basic Application Framework
+summary: Toolkit for testing and writing CLI programs
 test_files: []

data/lib/baf/version.rb

@@ -1,3 +0,0 @@
-module Baf
-  VERSION = '0.14.0'.freeze
-end