pork 1.5.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cc7cc07abd9d5e467ea5e229953b9bfd4ecc0978
-  data.tar.gz: adec072a9ef317b4f6baad7e38d14b96ee33aea2
+SHA256:
+  metadata.gz: 6ef62f89f8c80fddee9ebd8e670cfa8de340a312531d022a3e49510dc7dd218f
+  data.tar.gz: 1f3af07cdc623ec24ba294fc41409f958a7fb8c89961388d98915bc648dfb142
 SHA512:
-  metadata.gz: 9c181fef0d0491353d1034fb852f434c148eaaf6142f4d536320ee2c1f74a23e59a019340c8202399984ee75cebdee71bb545914558c895fd45dfbc675a0f7c6
-  data.tar.gz: c5e3d773b083eb21700a089a122cc577143a42e26c98c37ed8ed901b73d171b5b7717d8dd67a5fbecbdd67c030fe64057299698b212ece295421907f9e30f3b1
+  metadata.gz: e8c95acab07773aa0fd2f629c41c7a08d50b747c44649a3981021c5f64d0bc08f58a1b2de3ac78c317c3519c692dff2c6f473f32fcf37d806f367e65bb5fac28
+  data.tar.gz: 7b24bb5ec0792941b51ed0b2f69b90f17465fd68401db9835b42ac17b8719ed3c2936a683c6aa22f6165f9d9b01c94d5f5e90329c55c83868d051f4883004910

data/.gitlab-ci.yml

@@ -0,0 +1,40 @@
+
+stages:
+  - test
+
+.test:
+  stage: test
+  image: ruby:${RUBY_VERSION}-bullseye
+  variables:
+    GIT_DEPTH: "1"
+    GIT_SUBMODULE_STRATEGY: recursive
+    GIT_SUBMODULE_PATHS: task
+    RUBYOPT: --enable-frozen-string-literal
+  before_script:
+    - bundle install --retry=3
+    - unset CI # Coverage doesn't work well with frozen literal
+  script:
+    - ruby -vr bundler/setup -S rake test
+
+ruby:3.0:
+  extends:
+    - .test
+  variables:
+    RUBY_VERSION: '3.0'
+
+ruby:3.1:
+  extends:
+    - .test
+  variables:
+    RUBY_VERSION: '3.1'
+
+ruby:3.2:
+  extends:
+    - .test
+  variables:
+    RUBY_VERSION: '3.2'
+
+jruby:latest:
+  extends:
+    - .test
+  image: jruby:latest

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "task"]
 	path = task
-	url = git://github.com/godfat/gemgem.git
+	url = https://github.com/godfat/gemgem.git

data/CHANGES.md

@@ -1,5 +1,46 @@
 # CHANGES
 
+## Pork 2.1.0 -- 2022-12-28
+
+### Bugs fixed
+
+* `Pork.show_source` can work under frozen literal string mode now.
+* Fix picking the right test for the file line number from `ENV['PORK_TEST']`
+  (I totally forgot the details for this from 2017, but I think it should
+  make it more accurate anyway)
+* Ruby 3.2 compatibility fix. (Removed the use of `Random::DEFAULT`)
+
+### Enhancement
+
+* Introduced `Pork::API.around` which will pass the test object to the block,
+  and whenever the object is called with `call` it'll run the test. Note that
+  if `call` was never called, it'll act like `Pork::API.before` and the test
+  will still run unlike RSpec. To skip the test, call `skip` directly.
+
+## Pork 2.0.0 -- 2016-09-10
+
+### Incompatible changes
+
+* `Pork::Executor` is now renamed to `Pork::Suite`, and the new
+  `Pork::Executor` would be served as the real executor who's responsible
+  for running the test suites!
+* `Pork::Executor.execute` would now take a hash as the argument.
+* `Pork::Suite.after` would now run in a reverse manner because that would
+  serve better as a destructor.
+
+### Enhancement
+
+* `Pork::Suite.desc` would now preserve the original argument being passed to
+  `Pork::Suite.describe`, rather than converting it to a string.
+* Major internal structure cleanup. Now we don't include everything into the
+  context, but use different objects to do different things. For example,
+  now we have `Pork::Isolator` to isolate the context.
+* Introduced `Pork.execute_extensions` which would be extending to
+  `Pork::Executor`. The only extension for it for now is `Pork::Should`.
+* Don't crash if `Pork.loaded` was never called.
+* Now you could also make assertions in `after` block without triggering
+  `Missing assertions` errors.
+
 ## Pork 1.5.0 -- 2016-03-10
 
 ### Enhancement

data/Gemfile

@@ -7,7 +7,3 @@ gem 'rake'
 
 gem 'simplecov', :require => false if ENV['COV']
 gem 'coveralls', :require => false if ENV['CI']
-
-platform :rbx do
-  gem 'rubysl-singleton' # used in rake
-end

data/README.md

@@ -1,4 +1,4 @@
-# Pork [![Build Status](https://secure.travis-ci.org/godfat/pork.png?branch=master)](http://travis-ci.org/godfat/pork) [![Coverage Status](https://coveralls.io/repos/godfat/pork/badge.png)](https://coveralls.io/r/godfat/pork) [![Join the chat at https://gitter.im/godfat/pork](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/godfat/pork)
+# Pork [![Pipeline status](https://gitlab.com/godfat/pork/badges/master/pipeline.svg)](https://gitlab.com/godfat/pork/-/pipelines)
 
 by Lin Jen-Shin ([godfat](http://godfat.org))
 
@@ -7,6 +7,7 @@ by Lin Jen-Shin ([godfat](http://godfat.org))
 * [github](https://github.com/godfat/pork)
 * [rubygems](https://rubygems.org/gems/pork)
 * [rdoc](http://rdoc.info/github/godfat/pork)
+* [issues](https://github.com/godfat/pork/issues) (feel free to ask for support)
 
 ## DESCRIPTION:
 
@@ -93,7 +94,7 @@ end
 
 describe 'C' do
   # Also, we're not forced to include something in all describe blocks.
-  # If we want, we could do this instead: `Pork::Executor.include(Module.new)`
+  # If we want, we could do this instead: `Pork::Suite.include(Module.new)`
   # That would be the same as including in `Bacon::Context`
   would 'not respond_to? in_module nor in_describe' do
     should.not.respond_to?(:in_module)
@@ -147,7 +148,7 @@ end
 
 ## REQUIREMENTS:
 
-* Tested with MRI (official CRuby), Rubinius and JRuby.
+* Tested with MRI (official CRuby) and JRuby.
 * (Optional) [method_source][] if you would like to print the source for the
   failing tests.
 * (Optional) [ruby-progressbar][] if you like porgressbar for showing
@@ -298,7 +299,7 @@ Pork.autorun
 
 Here it `require 'pork/should'`, and it would load the monkey patches for
 inserting `Kernel#should` shown in SYNOPSIS. This is actually optional,
-and could be replaced with `Pork::Executor#expect`. For example, we could
+and could be replaced with `Pork::Suite#expect`. For example, we could
 also write it this way:
 
 ``` ruby
@@ -580,16 +581,16 @@ So this creates a test suite which should be containing various test cases
 suite, which accepts anything could be converted to a string. The _default_
 description is `:default` (which would be converted to `'default: '`)
 
-Each `describe` block would create a new subclass of `Pork::Executor` for
+Each `describe` block would create a new subclass of `Pork::Suite` for
 isolating test suites. Each nested `describe` block would be a subclass of
-its parent `Pork::Executor`.
+its parent `Pork::Suite`.
 
 ``` ruby
 require 'pork/auto'
 
 describe do
   would 'be default: for the default description' do
-    self.class.desc.should.eq 'default: '
+    self.class.desc.should.eq :default
   end
 end
 ```
@@ -602,7 +603,7 @@ description of the test case, which accepts anything could be converted to
 a string. The _default_ description is also `:default`.
 
 Each `would` block would be run inside a new instance of the describing
-`Pork::Executor` to isolate instance variables.
+`Pork::Suite` to isolate instance variables.
 
 ### Pork::API.before
 
@@ -637,20 +638,21 @@ end
 Each `after` block would be called after each `would` block (test case).
 You would probably want to cleanup stuffs inside `after` blocks.
 
-Each nested `describe` would also run parents' `after` block as well.
+Note that each nested `describe` would also run parents' `after` block in a
+reverse manner as opposed to `before`.
 
 ``` ruby
 require 'pork/auto'
 
 describe do
   after do
-    @a.should.eq 1
-    @a += 1
+    @a.should.eq 2
   end
 
   describe do
     after do
-      @a.should.eq 2
+      @a.should.eq 1
+      @a += 1
     end
 
     would do
@@ -661,6 +663,49 @@ describe do
 end
 ```
 
+### Pork::API.around
+
+Each `around` block would be called before each `would` block (test case),
+and whenever it's called, it can take an argument representing the `would`
+block (test case). Whenever `call` is called on the test case, it will run.
+Essentially it's wrapping around the `would` block.
+
+Note that each nested `describe` would also run parents' `around` block,
+following the same order of `before` (in order) and `after` (reverse order).
+
+``` ruby
+require 'pork/auto'
+
+describe do
+  around do |test|
+    @a = 0
+
+    test.call
+
+    @a.should.eq 2
+  end
+
+  describe do
+    around do |test|
+      @a.should.eq 0
+      @a += 1
+
+      test.call
+
+      @a.should.eq 1
+      @a += 1
+    end
+
+    would do
+      @a.should.eq 1
+    end
+  end
+end
+```
+
+Note that if `test.call` was never called, it'll just act like a `before`
+block. All the tests will still run unlike RSpec.
+
 ### Pork::API.copy and Pork::API.paste
 
 It could be a bit confusing at first, but just think of `copy` as a way to
@@ -694,7 +739,7 @@ describe do
 end
 ```
 
-### Pork::Executor#expect
+### Pork::Suite#expect
 
 It is the core of `Kernel#should`. Think of:
 
@@ -720,7 +765,7 @@ is equivalent to:
 expect(object, 'message').eq(1)
 ```
 
-### Pork::Executor#skip
+### Pork::Suite#skip
 
 At times we might want to skip some tests while leave the codes there without
 removing them or commenting them out. This is where `skip` would be helpful.
@@ -735,7 +780,7 @@ describe do
 end
 ```
 
-### Pork::Executor#ok
+### Pork::Suite#ok
 
 Because Pork would complain if a test case does not have any assertions,
 sometimes we might want to tell Pork that it's ok because we've already
@@ -758,7 +803,7 @@ describe do
 end
 ```
 
-### Pork::Executor#flunk
+### Pork::Suite#flunk
 
 If we're writing program carefully, there are a few cases where a condition
 would never meet. We could `raise "IMPOSSIBLE"` or we could simply call
@@ -1067,9 +1112,9 @@ Have you seen Rainbows!?
 
 ## LICENSE:
 
-Apache License 2.0
+Apache License 2.0 (Apache-2.0)
 
-Copyright (c) 2014-2016, Lin Jen-Shin (godfat)
+Copyright (c) 2014-2022, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/Rakefile

@@ -1,16 +1,17 @@
 
 begin
-  require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+  require "#{__dir__}/task/gemgem"
 rescue LoadError
-  sh 'git submodule update --init'
+  sh 'git submodule update --init --recursive'
   exec Gem.ruby, '-S', $PROGRAM_NAME, *ARGV
 end
 
-Gemgem.init(dir) do |s|
+Gemgem.init(__dir__) do |s|
   require 'pork/version'
   s.name    = 'pork'
   s.version = Pork::VERSION
+  s.files.delete('screenshot.png')
+
   %w[method_source ruby-progressbar].
     each(&s.method(:add_development_dependency))
-  s.files.delete('screenshot.png')
 end

data/TODO.md

@@ -1,5 +1,3 @@
 
 * introduce configs
-* plugin: color/reverse backtrace, replicating command, inspect mode
 * executable
-* if it's executing from a copy block, run all pasted blocks

data/lib/pork/api.rb

@@ -0,0 +1,35 @@
+
+require 'pork/suite'
+
+module Pork
+  module API
+    module_function
+    def before &block
+      Suite.before(&block)
+    end
+
+    def after &block
+      Suite.after(&block)
+    end
+
+    def around &block
+      Suite.around(&block)
+    end
+
+    def copy desc=:default, &block
+      Suite.copy(desc, &block)
+    end
+
+    def paste desc=:default, *args
+      Suite.paste(desc, *args)
+    end
+
+    def describe desc=:default, opts={}, &suite
+      Suite.describe(desc, opts, &suite)
+    end
+
+    def would desc=:default, opts={}, &test
+      Suite.would(desc, opts, &test)
+    end
+  end
+end

data/lib/pork/env.rb

@@ -11,8 +11,8 @@ module Pork
     end
 
     def run_after context
+      after.reverse_each{ |b| context.instance_eval(&b) }
       super_env && super_env.run_after(context)
-      after.each{ |b| context.instance_eval(&b) }
     end
   end
 end

data/lib/pork/executor.rb

@@ -1,16 +1,30 @@
 
-require 'pork/imp'
-require 'pork/isolate'
-require 'pork/context'
+require 'pork/suite'
+require 'pork/isolator'
 
 module Pork
-  class Executor < Struct.new(:pork_stat, :pork_description)
-    # we don't want this method from Struct.new, it's confusing when
-    # pork/isolate was not loaded. (i.e. isolate would override it anyway)
-    singleton_class.superclass.send(:remove_method, :[])
+  class Executor < Struct.new(:isolator)
+    def self.[] index
+      Isolator[][index]
+    end
 
-    extend Isolate, Imp
-    include Context
-    init
+    def self.execute mode: Pork.execute_mode,
+                     stat: Pork.stat,
+                     suite: Suite,
+                     isolator: Isolator[suite],
+                     paths: isolator.all_paths
+      require "pork/mode/#{mode}"
+      Pork.const_get(mode.capitalize).new(isolator).execute(stat, paths)
+    end
+
+    def initialize new_isolator
+      super(new_isolator)
+      extensions = Pork.execute_extensions
+      extend(*extensions.reverse) if extensions.any?
+    end
+
+    def execute stat=Stat.new, paths=isolator.all_paths
+      raise NotImplementedError
+    end
   end
 end

data/lib/pork/extra/show_source.rb

@@ -3,12 +3,31 @@ require 'method_source'
 
 module Pork
   module ShowSource
+    module FrozenStringFix
+      def extract_first_expression(lines, consume=0, &block)
+        code = consume.zero? ? [] : lines.slice!(0..(consume - 1))
+
+        lines.each do |v|
+          code << v
+
+          result = block ? block.call(code.join) : code.join
+
+          if complete_expression?(result)
+            return result
+          end
+        end
+        raise SyntaxError, "unexpected $end"
+      end
+    end
+
+    MethodSource.extend(FrozenStringFix)
+
     def show_source test, err
       source = test.source
       sopath = "#{test.source_location.first}:"
       lowers = test.source_location.last
       uppers = lowers + source.size
-      lineno = reject_pork(test, err).find do |backtrace|
+      lineno = reject_pork(test, err.backtrace).find do |backtrace|
         # find the line from the test source, exclude everything else
         next unless backtrace.start_with?(sopath)
         number = backtrace[/(?<=\.rb:)\d+/].to_i
@@ -28,7 +47,7 @@ module Pork
         end
       end.join
       "\n#{result.chomp}"
-    rescue SyntaxError => e
+    rescue SyntaxError, MethodSource::SourceNotFoundError => e
       "\nPork bug: Cannot parse the source. Please report: #{e}"
     end
   end

data/lib/pork/isolator.rb

@@ -0,0 +1,145 @@
+
+require 'pork/env'
+require 'pork/suite'
+
+module Pork
+  class Isolator < Struct.new(:suite)
+    def self.[] suite=Suite
+      @map ||= {}
+      @map[suite] ||= new(suite)
+    end
+
+    def all_tests
+      @all_tests ||= build_all_tests
+    end
+
+    def all_paths
+      (all_tests[:files] || {}).values.flat_map(&:values).flatten(1).uniq
+    end
+
+    def [] index
+      by_groups(index) || by_source(index)
+    end
+
+    def by_groups groups
+      return unless tests = all_tests[:groups]
+      paths = groups.split(',').flat_map do |g|
+        tests[g.strip] || []
+      end.uniq
+      paths unless paths.empty?
+    end
+
+    def by_source source
+      return unless tests = all_tests[:files]
+      file_str, line_str = source.split(':')
+      file, line = File.expand_path(file_str), line_str.to_i
+      return unless cases = tests[file]
+      if line.zero?
+        cases.values.flatten(1).uniq
+      else
+        _, paths = cases.reverse_each.find{ |(l, _)| l <= line }
+        paths
+      end
+    end
+
+    protected
+    def isolate stat, path, super_env=nil
+      env = Env.new(super_env)
+      idx = path.first
+
+      suite.tests.first(idx).each do |(type, arg, _)|
+        case type
+        when :before
+          env.before << arg
+        when :after
+          env.after  << arg
+        end
+      end
+
+      if path.size == 1
+        _, desc, test = suite.tests[idx]
+        suite.run(stat, desc, test, env)
+      else
+        Isolator[suite.tests[idx][1]].isolate(stat, path.drop(1), env)
+      end
+
+      stat
+    end
+
+    def build_all_tests result={}, path=[]
+      suite.tests.each_with_index.inject(result) do |
+        tests, ((type, imp, block, opts), index)|
+        current = path + [index]
+
+        case type
+        when :describe, :would
+          source_location = expand_source_location(block)
+          init_source_store_path(tests, source_location)
+        end
+
+        case type
+        when :describe
+          Isolator[imp].build_all_tests(tests, current) do |nested|
+            store_path(tests, nested, source_location, opts[:groups])
+          end
+        when :would
+          yield(current) if block_given?
+          store_path(tests, current, source_location, opts[:groups])
+        end
+
+        tests
+      end
+    end
+
+    def expand_source_location block
+      file, line = block.source_location
+      [File.expand_path(file), line]
+    end
+
+    def init_source_store_path tests, source_location
+      source, line = source_location
+
+      root = tests[:files] ||= {}
+      map = root[source] ||= {}
+
+      # Most of the time, line is always getting larger because we're
+      # scanning from top to bottom, and we really need to make sure
+      # that the map is sorted because whenever we're looking up which
+      # test we want from a particular line, we want to find the closest
+      # block rounding up. See Isolator#by_source
+      # However, it's not always appending from top to bottom, because
+      # we might be adding more tests from Suite#paste, and the original
+      # test could be defined in the same file, on previous lines!
+      # Because of this, we really need to make sure the map is balanced.
+      # If we ever have ordered map in Ruby, we don't have to do this...
+      # See the test for Isolator.all_tests (test/test_isolator.rb)
+      balanced_append(map, line, [])
+    end
+
+    def store_path tests, path, source_location, groups
+      store_for_groups(tests, path, groups) if groups
+      store_for_source(tests, path, source_location)
+    end
+
+    def store_for_groups tests, path, groups
+      map = tests[:groups] ||= {}
+      groups.each do |g|
+        (map[g.to_s] ||= []) << path
+      end
+    end
+
+    def store_for_source tests, path, source_location
+      source, line = source_location
+
+      tests[:files][source][line] << path
+    end
+
+    def balanced_append map, key, value
+      last_key = map.reverse_each.first.first unless map.empty?
+
+      map[key] ||= []
+
+      map.replace(Hash[map.sort]) if last_key && key < last_key
+    end
+  end
+end

data/lib/pork/mode/parallel.rb

@@ -2,22 +2,21 @@
 require 'pork/mode/shuffled'
 
 module Pork
-  module Parallel
+  class Parallel < Struct.new(:isolator)
     def cores
       8
     end
 
-    def parallel stat=Stat.new, paths=all_paths
+    def execute stat=Stat.new, paths=isolator.all_paths
+      executor = Shuffled.new(isolator)
       stat.prepare(paths)
       paths.shuffle.each_slice(cores).map do |paths_slice|
         Thread.new do
-          execute(:shuffled,
-                  Stat.new(stat.reporter, stat.protected_exceptions),
-                  paths_slice)
+          executor.execute(
+            Stat.new(stat.reporter, stat.protected_exceptions),
+            paths_slice)
         end
       end.map(&:value).inject(stat, &:merge)
     end
   end
-
-  Executor.extend(Parallel)
 end

data/lib/pork/mode/sequential.rb

@@ -1,11 +1,11 @@
 
+require 'pork/executor'
+
 module Pork
-  module Sequential
-    def sequential stat=Stat.new, paths=all_paths
+  class Sequential < Executor
+    def execute stat=Stat.new, paths=isolator.all_paths
       stat.prepare(paths)
-      paths.inject(stat, &method(:isolate))
+      paths.inject(stat, &isolator.method(:isolate))
     end
   end
-
-  Executor.extend(Sequential)
 end

data/lib/pork/mode/shuffled.rb

@@ -1,11 +1,11 @@
 
+require 'pork/executor'
+
 module Pork
-  module Shuffled
-    def shuffled stat=Stat.new, paths=all_paths
+  class Shuffled < Executor
+    def execute stat=Stat.new, paths=isolator.all_paths
       stat.prepare(paths)
-      paths.shuffle.inject(stat, &method(:isolate))
+      paths.shuffle.inject(stat, &isolator.method(:isolate))
     end
   end
-
-  Executor.extend(Shuffled)
 end

data/lib/pork/more/bottomup_backtrace.rb

@@ -1,6 +1,4 @@
 
-require 'pork'
-
 module Pork
   module BottomupBacktrace
     private