pax_global_header00006660000000000000000000000064151632066450014522gustar00rootroot0000000000000052 comment=08084b3232b76a7f5c4e5474b4178faf8d7636b3 rspec-parameterized-rspec-parameterized-core-3cab033/000077500000000000000000000000001516320664500227625ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/.github/000077500000000000000000000000001516320664500243225ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/.github/dependabot.yml000066400000000000000000000005531516320664500271550ustar00rootroot00000000000000# c.f. https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file version: 2 updates: - package-ecosystem: github-actions directory: / schedule: interval: monthly time: "05:00" timezone: Asia/Tokyo cooldown: default-days: 7 assignees: - sue445 rspec-parameterized-rspec-parameterized-core-3cab033/.github/release.yml000066400000000000000000000012221516320664500264620ustar00rootroot00000000000000# ref. https://docs.github.com/en/repositories/releasing-projects-on-github/automatically-generated-release-notes#configuring-automatically-generated-release-notes changelog: exclude: labels: - chore categories: - title: ":bomb: Breaking Changes" labels: - breaking change - title: ":lock: Security Fix" labels: - security - title: ":rocket: Features" labels: - enhancement - title: ":bug: Bug Fixes" labels: - bug - title: ":dependabot: Dependency updates" labels: - dependencies - title: ":pencil: Other Changes" labels: - "*" rspec-parameterized-rspec-parameterized-core-3cab033/.github/workflows/000077500000000000000000000000001516320664500263575ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/.github/workflows/release_gem.yml000066400000000000000000000022021516320664500313460ustar00rootroot00000000000000name: Publish gem to rubygems.org on: workflow_dispatch: jobs: release: if: github.repository == 'rspec-parameterized/rspec-parameterized-core' runs-on: ubuntu-latest environment: name: rubygems.org url: https://rubygems.org/gems/rspec-parameterized-core permissions: contents: write id-token: write steps: - name: Harden Runner uses: step-security/harden-runner@20cf305ff2072d973412fa9b1e3a4f227bda3c76 # v2.14.0 with: egress-policy: audit - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Set up Ruby uses: ruby/setup-ruby@09a7688d3b55cf0e976497ff046b70949eeaccfd # v1.288.0 with: bundler-cache: true ruby-version: ruby - name: Publish to RubyGems uses: rubygems/release-gem@e9a6361a0b14562539327c2a02373edc56dd3169 # v1.1.4 - name: Create GitHub release run: | tag_name="$(git describe --tags --abbrev=0)" gh release create "${tag_name}" --verify-tag --generate-notes env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} rspec-parameterized-rspec-parameterized-core-3cab033/.github/workflows/rspec.yml000066400000000000000000000021461516320664500302210ustar00rootroot00000000000000name: RSpec on: push: branches: - main pull_request: jobs: test: runs-on: ubuntu-latest strategy: fail-fast: false matrix: ruby-version: - '2.7' - '3.0' - '3.1' - '3.2' - '3.3' - '3.4' - '4.0' steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - name: Set up Ruby # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby, # change this to (see https://github.com/ruby/setup-ruby#versioning): uses: ruby/setup-ruby@09a7688d3b55cf0e976497ff046b70949eeaccfd # v1.288.0 with: ruby-version: ${{ matrix.ruby-version }} bundler-cache: true # runs 'bundle install' and caches installed gems automatically - name: Run tests run: bundle exec rake all-pass: if: always() needs: - test runs-on: ubuntu-slim steps: - name: check dependent jobs uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # v1.2.2 with: jobs: ${{ toJSON(needs) }} rspec-parameterized-rspec-parameterized-core-3cab033/.gitignore000066400000000000000000000001771516320664500247570ustar00rootroot00000000000000/.bundle/ /.yardoc /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ # rspec failure tracking .rspec_status Gemfile.lock rspec-parameterized-rspec-parameterized-core-3cab033/.rspec000066400000000000000000000000651516320664500241000ustar00rootroot00000000000000--format documentation --color --require spec_helper rspec-parameterized-rspec-parameterized-core-3cab033/CHANGELOG.md000066400000000000000000000034241516320664500245760ustar00rootroot00000000000000## [Unreleased] [Full Changelog](https://github.com/rspec-parameterized/rspec-parameterized-core/compare/v2.0.2...main) ## [2.0.2](https://github.com/rspec-parameterized/rspec-parameterized-core/releases/tag/v2.0.2) - 2026-04-01 [Full Changelog](https://github.com/rspec-parameterized/rspec-parameterized-core/compare/v2.0.1...v2.0.2) - Fix massive object allocation in LazyArg#inspect - https://github.com/rspec-parameterized/rspec-parameterized-core/pull/36 ## [2.0.1](https://github.com/rspec-parameterized/rspec-parameterized-core/releases/tag/v2.0.1) - 2025-11-30 [Full Changelog](https://github.com/rspec-parameterized/rspec-parameterized-core/compare/v2.0.0...v2.0.1) - Release gem from GitHub Actions - https://github.com/rspec-parameterized/rspec-parameterized-core/pull/23 - Fix unused variable warning - https://github.com/rspec-parameterized/rspec-parameterized-core/pull/20 ## [2.0.0](https://github.com/rspec-parameterized/rspec-parameterized-core/releases/tag/v2.0.0) - 2025-05-02 [Full Changelog](https://github.com/rspec-parameterized/rspec-parameterized-core/compare/v1.0.1...v2.0.0) - Requires Ruby 2.7+ - https://github.com/rspec-parameterized/rspec-parameterized-core/pull/19 - Use Prism gem instead of Parser gem when Ruby 3.4+ - https://github.com/rspec-parameterized/rspec-parameterized-core/issues/17 - https://github.com/rspec-parameterized/rspec-parameterized-core/pull/18 ## [1.0.1] - 2024-05-04 [Full Changelog](https://github.com/rspec-parameterized/rspec-parameterized-core/compare/v1.0.0...v1.0.1) - Requires proc_to_ast 0.2.0+ - https://github.com/rspec-parameterized/rspec-parameterized-core/pull/12 ## [1.0.0] - 2022-12-31 - https://github.com/tomykaira/rspec-parameterized/blob/master/CHANGELOG.md#v100-2022-12-31 - Drop support Ruby < 2.6 (explicitly) rspec-parameterized-rspec-parameterized-core-3cab033/Gemfile000066400000000000000000000002141516320664500242520ustar00rootroot00000000000000# frozen_string_literal: true source "https://rubygems.org" # Specify your gem's dependencies in rspec-parameterized-core.gemspec gemspec rspec-parameterized-rspec-parameterized-core-3cab033/LICENSE.txt000066400000000000000000000020611516320664500246040ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2022 sue445 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. rspec-parameterized-rspec-parameterized-core-3cab033/README.md000066400000000000000000000112211516320664500242360ustar00rootroot00000000000000# Rspec::Parameterized::Core `rspec-parameterized-core` provides parameterized test syntax in [rspec](https://rspec.info/). [![Gem Version](https://badge.fury.io/rb/rspec-parameterized-core.svg)](https://badge.fury.io/rb/rspec-parameterized-core) [![RSpec](https://github.com/rspec-parameterized/rspec-parameterized-core/actions/workflows/rspec.yml/badge.svg)](https://github.com/rspec-parameterized/rspec-parameterized-core/actions/workflows/rspec.yml) ## Installation ```ruby # Install all components group :test do gem "rspec-parameterized", ">= 1.0.0" end # Install only rspec-parameterized-core group :test do gem "rspec-parameterized-core", ">= 1.0.0" end ``` ## Usage ### Nested Array Style ```ruby describe "plus" do where(:a, :b, :answer) do [ [1 , 2 , 3], [5 , 8 , 13], [0 , 0 , 0] ] end with_them do it "should do additions" do expect(a + b).to eq answer end end with_them do # Can browse parameters via `params` method in with_them block # Can browse all parameters via `all_params` method in with_them block it "#{params[:a]} + #{params[:b]} == #{params[:answer]}" do expect(a + b).to eq answer end end end ``` ### Hash and Array Style ```ruby # Given parameters is each value combinations # On this case # [ # [1, 5, 2], # [1, 5, 4], # [1, 7, 2], # [1, 7, 4], # [1, 9, 2], # [1, 9, 4], # [3, 5, 2], # [3, 5, 4], # [3, 7, 2], # [3, 7, 4], # [3, 9, 2], # [3, 9, 4] # ] describe "Hash arguments" do where(a: [1, 3], b: [5, 7, 9], c: [2, 4]) with_them do it "sums is even" do expect(a + b + c).to be_even end end end ``` ### Verbose Syntax ```ruby # For complex inputs or if you just want to be super explicit describe "Verbose syntax" do where do { "positive integers" => { a: 1, b: 2, answer: 3, }, "negative_integers" => { a: -1, b: -2, answer: -3, }, "mixed_integers" => { a: 3, b: -3, answer: 0, }, } end with_them do it "should do additions" do expect(a + b).to eq answer end end end ``` ### Custom names ```ruby # It's also possible to override each combination name using magic variable :case_name # Output: # Custom names for regular syntax # positive integers # should do additions # negative integers # should do additions # mixed integers # should do additions describe "Custom names for regular syntax" do where(:case_name, :a, :b, :answer) do [ ["positive integers", 6, 2, 8], ["negative integers", -1, -2, -3], [ "mixed integers", -5, 3, -2], ] end with_them do it "should do additions" do expect(a + b).to eq answer end end end # Or :case_names lambda for hash syntax # Output: # Custom naming for hash syntax # 1 + 5 + 2 # sum is even # 1 + 5 + 4 # sum is even # 1 + 7 + 2 # sum is even # ... describe "Custom naming for hash syntax" do where(case_names: ->(a, b, c){"#{a} + #{b} + #{c}"}, a: [1, 3], b: [5, 7, 9], c: [2, 4]) with_them do it "sum is even" do expect(a + b + c).to be_even end end end ``` ### lazy and ref types ```ruby # Use ref(:symbol) to use let/let! defined variables in the where block # Use lazy when you want to create let/let! variables after the where block # # Failures will be more readable in the future - https://github.com/tomykaira/rspec-parameterized/pull/65 describe "lazy and ref types" do let(:one) { 1 } let(:four) { 4 } where(:a, :b, :result) do [ [ref(:one), ref(:four), lazy { two + three }] ] end with_them do context "use let after where block" do let(:two) { 2 } let(:three) { 3 } it 'should equal 5' do expect(a + b).to eq result end end end end ``` I was inspired by [udzura's mock](https://gist.github.com/1881139). ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/rspec-parameterized/rspec-parameterized-core. ## License The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT). rspec-parameterized-rspec-parameterized-core-3cab033/Rakefile000066400000000000000000000002241516320664500244250ustar00rootroot00000000000000# frozen_string_literal: true require "bundler/gem_tasks" require "rspec/core/rake_task" RSpec::Core::RakeTask.new(:spec) task default: %i[spec] rspec-parameterized-rspec-parameterized-core-3cab033/bin/000077500000000000000000000000001516320664500235325ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/bin/console000077500000000000000000000006051516320664500251230ustar00rootroot00000000000000#!/usr/bin/env ruby # frozen_string_literal: true require "bundler/setup" require "rspec/parameterized/core" # You can add fixtures and/or initialization code here to make experimenting # with your gem easier. You can also use a different console, if you like. # (If you use this, don't forget to add pry to your Gemfile!) # require "pry" # Pry.start require "irb" IRB.start(__FILE__) rspec-parameterized-rspec-parameterized-core-3cab033/bin/setup000077500000000000000000000002031516320664500246130ustar00rootroot00000000000000#!/usr/bin/env bash set -euo pipefail IFS=$'\n\t' set -vx bundle install # Do any other automated setup that you need to do here rspec-parameterized-rspec-parameterized-core-3cab033/lib/000077500000000000000000000000001516320664500235305ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec-parameterized-core.rb000066400000000000000000000000431516320664500307460ustar00rootroot00000000000000require 'rspec/parameterized/core' rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/000077500000000000000000000000001516320664500246445ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/000077500000000000000000000000001516320664500275005ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core.rb000066400000000000000000000122601516320664500307560ustar00rootroot00000000000000require "rspec/parameterized/core/version" require 'rspec/parameterized/core/helper_methods' require 'rspec/parameterized/core/example_helper_methods' require 'rspec/parameterized/core/errors' require 'rspec/parameterized/core/composite_parser' module RSpec module Parameterized module Core module ExampleGroupMethods # capsulize parameter attributes class Parameter attr_reader :arg_names, :block def initialize(arg_names, &block) @arg_names, @block = arg_names, block end end # Set parameters to be bound in specs under this example group. # # ## Example1 # # where(:a, :b, :answer) do # [ # [1 , 2 , 3], # [5 , 8 , 13], # [0 , 0 , 0] # ] # end # # ## Example2 # using RSpec::Parameterized::TableSyntax # where(:a, :b, :answer) do # 1 | 2 | 3 > # 5 | 8 | 13 > # 0 | 0 | 0 # end # def where(*args, &b) if args.size == 1 && args[0].instance_of?(Hash) naming_func = args.first.delete(:case_names) params = args[0] first, *rest = params.values arg_names = params.keys arg_values = first.product(*rest) if naming_func && naming_func.respond_to?(:call) arg_names << :case_name arg_values.map! { |row| row << naming_func.call(*row) } end set_parameters(arg_names) { arg_values } elsif args.size == 0 set_verbose_parameters(&b) else set_parameters(args, &b) end end # Use parameters to execute the block. # The given block is converted into +describe+s for each parameter set. # # ## Example # with_them do # it "should do additions" do # (a + b).should == answer # end # end # def with_them(*args, &b) opts = args.last.is_a?(Hash) ? args.pop : {} opts[:caller] = caller unless opts[:caller] args.push(opts) @parameter ||= nil if @parameter.nil? @parameterized_pending_cases ||= [] @parameterized_pending_cases << [args, b] else define_cases(@parameter, *args, &b) end end private def set_parameters(arg_names, &b) @parameter = Parameter.new(arg_names, &b) @parameterized_pending_cases ||= [] @parameterized_pending_cases.each { |e| define_cases(@parameter, *e[0], &e[1]) } end def define_cases(parameter, *args, &block) instance = new # for evaluate let methods. instance.extend HelperMethods if defined?(self.superclass::LetDefinitions) instance.extend self.superclass::LetDefinitions end extracted = instance.instance_eval(¶meter.block) param_sets = extracted.is_a?(Array) ? extracted : extracted.to_params # for only one parameters param_sets = param_sets.map { |x| Array[x] } if !param_sets[0].is_a?(Array) param_sets.each do |param_set| pairs = [parameter.arg_names, param_set].transpose.to_h pretty_params = pairs.has_key?(:case_name) ? pairs[:case_name] : pairs.map {|name, val| "#{name}: #{params_inspect(val)}"}.join(", ") describe(pretty_params, *args) do include ExampleHelperMethods pairs.each do |name, val| let(name) { recursive_apply(val) } end singleton_class.module_eval do if respond_to?(:params) warn "ExampleGroup.params method is overrided." end define_method(:params) do pairs end if respond_to?(:all_params) warn "ExampleGroup.all_params method is overrided." end define_method(:all_params) do param_sets end end module_eval(&block) end end end def params_inspect(obj) RSpec::Parameterized::Core::CompositeParser.to_raw_source(obj) rescue ParserSyntaxError return obj.inspect end def set_verbose_parameters(&block) arguments_hash = yield arg_names = arguments_hash.values.reduce(Set.new) { |memo, pairs| memo | pairs.keys }.to_a arg_values = [] arguments_hash.each do |name, values_hash| row = [name] arg_names.each do |argument_name| row << values_hash[argument_name] end arg_values << row end arg_names.unshift(:case_name) set_parameters(arg_names) { arg_values } end end end end module Core class ExampleGroup extend ::RSpec::Parameterized::Core::ExampleGroupMethods end end end rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core/000077500000000000000000000000001516320664500304305ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core/arg.rb000066400000000000000000000001751516320664500315310ustar00rootroot00000000000000module RSpec module Parameterized module Core class Arg def apply(obj) ; end end end end end composite_parser.rb000066400000000000000000000040171516320664500342560ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/coremodule RSpec module Parameterized module Core # Proxy class for parser and prism module CompositeParser # @param obj [Object] # @return [String] # @raise [RSpec::Parameterized::Core::ParserSyntaxError] def self.to_raw_source(obj) return to_raw_source_with_prism(obj) if use_prism? to_raw_source_with_parser(obj) end # Whether use parser or prism # # @return [true] Use prism # @return [false] Use parser def self.use_prism? Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.4.0") end # @param obj [Object] # @return [String] # @raise [RSpec::Parameterized::Core::ParserSyntaxError] def self.to_raw_source_with_parser(obj) obj.is_a?(Proc) ? obj.to_raw_source : obj.inspect rescue Parser::SyntaxError raise ParserSyntaxError end private_class_method :to_raw_source_with_parser # @param obj [Object] # @return [String] def self.to_raw_source_with_prism(obj) return obj.inspect unless obj.is_a?(Proc) filename, linenum = obj.source_location ast = parse_with_prism(filename, linenum) return "" unless ast ast.source.source.strip end private_class_method :to_raw_source_with_prism # @param filename [String] # @param linenum [Integer] # # @return [Prism::ParseResult,nil] def self.parse_with_prism(filename, linenum) buf = [] File.open(filename, "rb").each_with_index do |line, index| next if index < linenum - 1 buf << line ret = Prism.parse(buf.join) return ret if ret.success? end nil end private_class_method :parse_with_prism end end end end if RSpec::Parameterized::Core::CompositeParser.use_prism? require 'prism' else require 'parser' require 'unparser' require 'proc_to_ast' end rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core/errors.rb000066400000000000000000000002311516320664500322650ustar00rootroot00000000000000module RSpec module Parameterized module Core class Error < StandardError; end class ParserSyntaxError < Error; end end end end example_helper_methods.rb000066400000000000000000000007601516320664500354160ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/coremodule RSpec module Parameterized module Core module ExampleHelperMethods def recursive_apply(val) return val.apply(self) if HelperMethods.applicable?(val) if val.is_a?(Array) return val.map { |child_val| recursive_apply(child_val) } end if val.is_a?(Hash) return val.map { |key, value| [recursive_apply(key), recursive_apply(value)] }.to_h end val end end end end end rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core/helper_methods.rb000066400000000000000000000006161516320664500337620ustar00rootroot00000000000000require 'rspec/parameterized/core/ref_arg' require 'rspec/parameterized/core/lazy_arg' module RSpec module Parameterized module Core module HelperMethods def ref(symbol) RefArg.new(symbol) end def lazy(&block) LazyArg.new(&block) end def self.applicable?(arg) arg.is_a? Arg end end end end end rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core/lazy_arg.rb000066400000000000000000000006161516320664500325700ustar00rootroot00000000000000module RSpec module Parameterized module Core class LazyArg < Arg def initialize(&block) @block = block end def apply(obj) obj.instance_eval(&@block) end def inspect filename, linenum = @block.source_location "lazy { ... } (#{File.basename(filename)}:#{linenum})" end end end end end rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core/ref_arg.rb000066400000000000000000000005161516320664500323640ustar00rootroot00000000000000require 'rspec/parameterized/core/arg' module RSpec module Parameterized module Core class RefArg < Arg def initialize(symbol) @symbol = symbol end def apply(obj) obj.send(@symbol) end def inspect "#{@symbol}" end end end end end rspec-parameterized-rspec-parameterized-core-3cab033/lib/rspec/parameterized/core/version.rb000066400000000000000000000001751516320664500324450ustar00rootroot00000000000000# frozen_string_literal: true module Rspec module Parameterized module Core VERSION = "2.0.2" end end end rspec-parameterized-rspec-parameterized-core-3cab033/rspec-parameterized-core.gemspec000066400000000000000000000036301516320664500312250ustar00rootroot00000000000000# frozen_string_literal: true require_relative "lib/rspec/parameterized/core/version" Gem::Specification.new do |spec| spec.name = "rspec-parameterized-core" spec.version = Rspec::Parameterized::Core::VERSION spec.authors = ["sue445", "tomykaira", "joker1007"] spec.email = ["sue445@sue445.net", "tomykaira@gmail.com"] spec.description = %q{RSpec::Parameterized supports simple parameterized test syntax in rspec.} spec.summary = %q{RSpec::Parameterized supports simple parameterized test syntax in rspec. I was inspired by [udzura's mock](https://gist.github.com/1881139).} spec.homepage = "https://github.com/rspec-parameterized/rspec-parameterized-core" spec.license = "MIT" spec.required_ruby_version = ">= 2.7.0" spec.metadata["homepage_uri"] = spec.homepage spec.metadata["source_code_uri"] = spec.homepage spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md" spec.metadata["rubygems_mfa_required"] = "true" # Specify which files should be added to the gem when it is released. # The `git ls-files -z` loads the files in the RubyGem that have been added into git. spec.files = Dir.chdir(__dir__) do `git ls-files -z`.split("\x0").reject do |f| (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)}) end end spec.bindir = "exe" spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) } spec.require_paths = ["lib"] spec.add_dependency "rspec", ">= 2.13", "< 4" # parser dependencies spec.add_dependency "parser" spec.add_dependency "proc_to_ast", ">= 0.2.0" spec.add_dependency "unparser" # prism dependencies spec.add_dependency "prism" spec.add_development_dependency "rake", ">= 12.0.0" spec.add_development_dependency "rspec-its" # For more information and examples about making a new gem, check out our # guide at: https://bundler.io/guides/creating_gem.html end rspec-parameterized-rspec-parameterized-core-3cab033/sig/000077500000000000000000000000001516320664500235445ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/sig/rspec/000077500000000000000000000000001516320664500246605ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/sig/rspec/parameterized/000077500000000000000000000000001516320664500275145ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/sig/rspec/parameterized/core.rbs000066400000000000000000000002451516320664500311550ustar00rootroot00000000000000module Rspec module Parameterized module Core VERSION: String # See the writing guide of rbs: https://github.com/ruby/rbs#guides end end end rspec-parameterized-rspec-parameterized-core-3cab033/spec/000077500000000000000000000000001516320664500237145ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/spec/rspec/000077500000000000000000000000001516320664500250305ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/spec/rspec/parameterized/000077500000000000000000000000001516320664500276645ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/spec/rspec/parameterized/core/000077500000000000000000000000001516320664500306145ustar00rootroot00000000000000composite_parser_spec.rb000066400000000000000000000020201516320664500354440ustar00rootroot00000000000000rspec-parameterized-rspec-parameterized-core-3cab033/spec/rspec/parameterized/coredescribe RSpec::Parameterized::Core::CompositeParser do describe ".to_raw_source" do subject { RSpec::Parameterized::Core::CompositeParser.to_raw_source(arg) } context "arg is not proc" do let(:arg) do 123 end it { should eq "123" } end context "arg is proc" do context "simple case" do let(:arg) do ->(a) { a + 1 } end it { should eq "->(a) { a + 1 }" } its(:encoding) { should eq Encoding::UTF_8 } end context "arg is multibyte characters" do let(:arg) do ->(a) { a + "ほげほげ" } end it { should eq '->(a) { a + "ほげほげ" }' } its(:encoding) { should eq Encoding::UTF_8 } end context "multiple lines" do let(:arg) do ->(a) { a + 1 } end it { should eq "->(a) {\n a +\n 1\n }" } its(:encoding) { should eq Encoding::UTF_8 } end end end end rspec-parameterized-rspec-parameterized-core-3cab033/spec/rspec/parameterized/core/lazy_arg_spec.rb000066400000000000000000000004771516320664500337730ustar00rootroot00000000000000describe RSpec::Parameterized::Core::LazyArg do describe "#inspect" do it "includes filename and line number" do lazy_arg = RSpec::Parameterized::Core::LazyArg.new { 1 + 2 }; expected_line = __LINE__ expect(lazy_arg.inspect).to eq "lazy { ... } (lazy_arg_spec.rb:#{expected_line})" end end end rspec-parameterized-rspec-parameterized-core-3cab033/spec/rspec/parameterized/core_spec.rb000066400000000000000000000206171516320664500321610ustar00rootroot00000000000000# RSpec::Parameterized # Sample # plus # [1, 2, 3] # should do additions # [5, 8, 13] # should do additions # [0, 0, 0] # should do additions describe RSpec::Parameterized do describe "where and with_them" do where(:a, :b, :answer) do [ [1 , 2 , 3], [5 , 8 , 13], [0 , 0 , 0] ] end with_them do it "should do additions" do expect(a + b).to eq answer end end with_them do it "#{params[:a]} + #{params[:b]} == #{params[:answer]}" do expect(a + b).to eq answer end end with_them pending: "PENDING" do it "should do additions" do expect(a + b).to == answer end end end describe "lambda parameter" do where(:a, :b, :answer) do [ [1 , 2 , -> {should == 3}], [5 , 8 , -> {should == 13}], [0 , 0 , -> {should == 0}] ] end with_them do subject {a + b} it "should do additions" do self.instance_exec(&answer) end end end describe "Hash arguments" do where(a: [1, 3], b: [5, 7, 9], c: [2, 4]) with_them do it "sums is even" do expect(a + b + c).to be_even end end end describe "Verbose syntax" do where do { "positive integers" => { a: 1, b: 2, answer: 3, }, "negative_integers" => { a: -1, b: -2, answer: -3, }, "mixed_integers" => { a: 3, b: -3, answer: 0, }, } end with_them do it "should do additions" do expect(a + b).to eq answer end it "should have custom name" do |example| expect(example.metadata[:example_group][:description]).to eq case_name end end context "lambda parameter" do where do { "integers" => { a: 1, b: 2, answer: -> {expect(subject).to eq 3}, }, "strings" => { a: "hello ", b: "world", answer: -> {expect(subject).to include "lo wo"}, }, "arrays" => { a: [1, 2, 3], b: [4, 5, 6], answer: -> {expect(subject.size).to eq 6} } } end with_them do subject {a + b} it "should do additions" do self.instance_exec(&answer) end it "should have custom name" do |example| expect(example.metadata[:example_group][:description]).to eq(case_name) end end end end describe "Custom test case name" do context "when regular arguments" do where(:case_name, :a, :b, :answer) do [ ["positive integers", 6, 2, 8], ["negative integers", -1, -2, -3], [ "mixed integers", -5, 3, -2], ] end with_them do it "should do additions" do expect(a + b).to eq answer end it "should have custom test name" do |example| expect(example.metadata[:example_group][:description]).to eq case_name end end end context "when hash arguments" do where(case_names: ->(a, b, c){"#{a} + #{b} + #{c}"}, a: [1, 3], b: [5, 7, 9], c: [2, 4]) with_them do it "sum is even" do expect(a + b + c).to be_even end it "should have custom names" do |example| expect(example.metadata[:example_group][:description]).to include "+" end end end end describe "ref" do context 'simple usecase' do let(:foo) { 1 } where(:value, :answer) do [ [ref(:foo), 1], ] end with_them do it "let variable in same example group can be used" do expect(value).to eq answer end context "override let varibale" do let(:foo) { 3 } it "can override let variable" do expect(value).to eq 3 end end end end context "recursive usecase" do let(:foo) { 1 } where(:value, :answer) do [ [[ref(:foo), 2], [1, 2]], ] end with_them do it "let variable in same example group can be used" do expect(value).to eq answer end context "override let varibale" do let(:foo) { 3 } it "can override let variable" do expect(value).to eq [3, 2] end end end end end describe "lazy" do context "simple usecase" do let(:one) { 1 } let(:four) { 4 } where(:a, :b, :answer) do [ [ref(:one), ref(:four), lazy { two + three }], ] end with_them do context "define two and three after where block" do let(:two) { 2 } let(:three) { 3 } it "should do additions" do expect(a + b).to eq answer end end end end context 'recursive usecase' do let(:one) { 1 } let(:four) { 4 } where(:a, :b, :answer) do [ [ref(:one), ref(:four), { result: lazy { two + three } }], ] end with_them do context "define two and three after where block" do let(:two) { 2 } let(:three) { 3 } it "should do additions" do expect(a + b).to eq answer[:result] end end end end context "have multibyte string usecase" do context 'only in lazy' do where(:value, :answer) do [ ["non multibyte parameter", lazy { "パラメータ is non multibyte parameter" }] ] end with_them do it "should run with correct description" do expect("パラメータ is #{value}").to eq answer end end end context 'with multibyte other parameter' do where(:value, :answer) do [ ["lazyとは別のパラメータ", lazy { "パラメータ is lazyとは別のパラメータ" }] ] end with_them do it "should run with correct description" do expect("パラメータ is #{value}").to eq answer end end end context 'use マルチバイト in ancestor context description' do where(:value, :answer) do [ ["non multibyte parameter", lazy { "パラメータ is non multibyte parameter"}] ] end with_them do it "should run with correct description" do expect("パラメータ is #{value}").to eq answer end end end end end context "when the where block is after with_them" do with_them do it "should do additions" do expect(a + b).to eq answer end end with_them do subject { a } it { should be_a Numeric } end where(:a, :b, :answer) do [ [1 , 2 , 3], [5 , 8 , 13], [0 , 0 , 0] ] end end context "when the where block is between with_thems" do with_them do it "should do additions" do expect(a + b).to eq answer end end where(:a, :b, :answer) do [ [1 , 2 , 3], [5 , 8 , 13], [0 , 0 , 0] ] end with_them do subject { a } it { should be_a Numeric } end end context "when the where has only one parameter to be set" do where(:x) do [1, 2, 3] end with_them do it 'can take an array of elements' do expect(x).to eq x end end end context "when the where has let variables, defined by parent example group" do describe "parent (define let)" do let(:five) { 5 } let(:eight) { 8 } describe "child 1" do where(:a, :b, :answer) do [ [1 , 2 , 3], [five , eight , 13], ] end with_them do it "a plus b is answer" do expect(a + b).to eq answer end end end let(:eq_matcher) { eq(13) } describe "child 3 (use matcher)" do where(:a, :b, :matcher) do [ [1 , 2 , eq(3) ], [five , eight , eq_matcher], ] end with_them do it "a plus b is answer" do expect(a + b).to matcher end end end end end end rspec-parameterized-rspec-parameterized-core-3cab033/spec/spec_helper.rb000066400000000000000000000003471516320664500265360ustar00rootroot00000000000000require 'rspec-parameterized-core' require 'rspec/its' RSpec.configure do |config| config.treat_symbols_as_metadata_keys_with_true_values = true config.run_all_when_everything_filtered = true config.filter_run :current end