mega-max-rb 0.0.1

data/capybara-3.40.0/spec/regexp_dissassembler_spec.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Capybara::Selector::RegexpDisassembler, :aggregate_failures do
+  it 'handles strings' do
+    verify_strings(
+      /abcdef/ => %w[abcdef],
+      /abc def/ => ['abc def']
+    )
+  end
+
+  it 'handles escaped characters' do
+    verify_strings(
+      /abc\\def/ => %w[abc\def],
+      /abc\.def/ => %w[abc.def],
+      /\nabc/ => ["\nabc"],
+      %r{abc/} => %w[abc/],
+      /ab\++cd/ => %w[ab+ cd]
+    )
+  end
+
+  it 'handles wildcards' do
+    verify_strings(
+      /abc.*def/ => %w[abc def],
+      /.*def/ => %w[def],
+      /abc./ => %w[abc],
+      /abc.*/ => %w[abc],
+      /abc.def/ => %w[abc def],
+      /abc.def.ghi/ => %w[abc def ghi],
+      /abc.abcd.abcde/ => %w[abcde],
+      /.*/ => []
+    )
+  end
+
+  it 'ignores optional characters for substrings' do
+    {
+      /abc*def/ => %w[ab def],
+      /abc*/ => %w[ab],
+      /c*/ => [],
+      /abc?def/ => %w[ab def],
+      /abc?/ => %w[ab],
+      /abc?def?/ => %w[ab de],
+      /abc?def?g/ => %w[ab de g],
+      /d?/ => []
+    }.each do |regexp, expected|
+      expect(described_class.new(regexp).substrings).to eq expected
+    end
+  end
+
+  it 'handles optional characters for #alternated_substrings' do
+    verify_alternated_strings(
+      {
+        /abc*def/ => [%w[ab def]],
+        /abc*/ => [%w[ab]],
+        /c*/ => [],
+        /abc?def/ => [%w[abdef], %w[abcdef]],
+        /abc?/ => [%w[ab]],
+        /abc?def?/ => [%w[abde], %w[abcde]],
+        /abc?def?g/ => [%w[abdeg], %w[abdefg], %w[abcdeg], %w[abcdefg]],
+        /d?/ => []
+      }
+    )
+  end
+
+  it 'handles character classes' do
+    verify_strings(
+      /abc[a-z]/ => %w[abc],
+      /abc[a-z]def[0-9]g/ => %w[abc def g],
+      /[0-9]abc/ => %w[abc],
+      /[0-9]+/ => [],
+      /abc[0-9&&[^7]]/ => %w[abc]
+    )
+  end
+
+  it 'handles posix bracket expressions' do
+    verify_strings(
+      /abc[[:alpha:]]/ => %w[abc],
+      /[[:digit:]]abc/ => %w[abc],
+      /abc[[:print:]]def/ => %w[abc def]
+    )
+  end
+
+  it 'handles repitition' do
+    verify_strings(
+      /abc{3}/ => %w[abccc],
+      /abc{3}d/ => %w[abcccd],
+      /abc{0}/ => %w[ab],
+      /abc{,2}/ => %w[ab],
+      /abc{2,}/ => %w[abcc],
+      /def{1,5}/ => %w[def],
+      /abc+def/ => %w[abc def],
+      /ab(cde){,4}/ => %w[ab],
+      /(ab){,2}cd/ => %w[cd],
+      /(abc){2,3}/ => %w[abcabc],
+      /(abc){3}/ => %w[abcabcabc],
+      /ab{2,3}cd/ => %w[abb cd],
+      /(ab){2,3}cd/ => %w[abab cd]
+    )
+  end
+
+  it 'handles non-greedy repetition' do
+    verify_strings(
+      /abc.*?/ => %w[abc],
+      /abc+?/ => %w[abc],
+      /abc*?cde/ => %w[ab cde],
+      /(abc)+?def/ => %w[abc def],
+      /ab(cde)*?fg/ => %w[ab fg]
+    )
+  end
+
+  it 'ignores alternation for #substrings' do
+    {
+      /abc|def/ => [],
+      /ab(?:c|d)/ => %w[ab],
+      /ab(c|d|e)fg/ => %w[ab fg],
+      /ab?(c|d)fg/ => %w[a fg],
+      /ab(c|d)ef/ => %w[ab ef],
+      /ab(cd?|ef)g/ => %w[ab g],
+      /ab(cd|ef*)g/ => %w[ab g],
+      /ab|cd*/ => [],
+      /cd(?:ef|gh)|xyz/ => [],
+      /(cd(?:ef|gh)|xyz)/ => [],
+      /cd(ef|gh)+/ => %w[cd],
+      /cd(ef|gh)?/ => %w[cd],
+      /cd(ef|gh)?ij/ => %w[cd ij],
+      /cd(ef|gh)+ij/ => %w[cd ij],
+      /cd(ef|gh){2}ij/ => %w[cd ij],
+      /(cd(ef|g*))/ => %w[cd],
+      /ab(cd){0,2}ef/ => %w[ab ef],
+      /ab(cd){0,1}ef/ => %w[ab ef],
+      /ab(cd|cd)ef/ => %w[ab ef],
+      /ab(cd|cd)?ef/ => %w[ab ef],
+      /ab\\?cd/ => %w[ab cd]
+    }.each do |regexp, expected|
+      expect(described_class.new(regexp).substrings).to eq expected
+    end
+  end
+
+  it 'handles alternation for #alternated_substrings' do
+    verify_alternated_strings(
+      {
+        /abc|def/ => [%w[abc], %w[def]],
+        /ab(?:c|d)/ => [%w[abc], %w[abd]],
+        /ab(c|d|e)fg/ => [%w[abcfg], %w[abdfg], %w[abefg]],
+        /ab?(c|d)fg/ => [%w[acfg], %w[adfg], %w[abcfg], %w[abdfg]],
+        /ab(c|d)ef/ => [%w[abcef], %w[abdef]],
+        /ab(cd?|ef)g/ => [%w[abcg], %w[abcdg], %w[abefg]],
+        /ab(cd|ef*)g/ => [%w[abcdg], %w[abe g]],
+        /ab|cd*/ => [%w[ab], %w[c]],
+        /cd(?:ef|gh)|xyz/ => [%w[cdef], %w[cdgh], %w[xyz]],
+        /(cd(?:ef|gh)|xyz)/ => [%w[cdef], %w[cdgh], %w[xyz]],
+        /cd(ef|gh)+/ => [%w[cdef], %w[cdgh]],
+        /cd(ef|gh)?/ => [%w[cd]],
+        /cd(ef|gh)?ij/ => [%w[cdij], %w[cdefij], %w[cdghij]],
+        /cd(ef|gh)+ij/ => [%w[cdef ij], %w[cdgh ij]],
+        /cd(ef|gh){2}ij/ => [%w[cdefefij], %w[cdefghij], %w[cdghefij], %w[cdghghij]],
+        /(cd(ef|g*))/ => [%w[cd]],
+        /a|b*/ => [],
+        /ab(?:c|d?)/ => [%w[ab]],
+        /ab(c|d)|a*/ => [],
+        /(abc)?(d|e)/ => [%w[d], %w[e]],
+        /(abc*de)?(d|e)/ => [%w[d], %w[e]],
+        /(abc*de)?(d|e?)/ => [],
+        /(abc)?(d|e?)/ => [],
+        /ab(cd){0,2}ef/ => [%w[ab ef]],
+        /ab(cd){0,1}ef/ => [%w[abef], %w[abcdef]],
+        /ab(cd|cd)ef/ => [%w[abcdef]],
+        /ab(cd|cd)?ef/ => [%w[abef], %w[abcdef]],
+        /ab\\?cd/ => [%w[abcd], %w[ab\cd]]
+      }
+    )
+  end
+
+  it 'handles grouping' do
+    verify_strings(
+      /(abc)/ => %w[abc],
+      /(abc)?/ => [],
+      /ab(cde)/ => %w[abcde],
+      /(abc)de/ => %w[abcde],
+      /ab(cde)fg/ => %w[abcdefg],
+      /ab(?<name>cd)ef/ => %w[abcdef],
+      /gh(?>ij)kl/ => %w[ghijkl],
+      /m(n.*p)q/ => %w[mn pq],
+      /(?:ab(cd)*){2,3}/ => %w[ab],
+      /(ab(cd){3})?/ => [],
+      /(ab(cd)+){2}/ => %w[abcd]
+    )
+  end
+
+  it 'handles meta characters' do
+    verify_strings(
+      /abc\d/ => %w[abc],
+      /abc\wdef/ => %w[abc def],
+      /\habc/ => %w[abc]
+    )
+  end
+
+  it 'handles character properties' do
+    verify_strings(
+      /ab\p{Alpha}cd/ => %w[ab cd],
+      /ab\p{Blank}/ => %w[ab],
+      /\p{Digit}cd/ => %w[cd]
+    )
+  end
+
+  it 'handles backreferences' do
+    verify_strings(
+      /a(?<group>abc).\k<group>.+/ => %w[aabc]
+    )
+  end
+
+  it 'handles subexpressions' do
+    verify_strings(
+      /\A(?<paren>a\g<paren>*b)+\z/ => %w[a b]
+    )
+  end
+
+  it 'ignores negative lookaheads' do
+    verify_strings(
+      /^(?!.*\bContributing Editor\b).*$/ => %w[],
+      /abc(?!.*def).*/ => %w[abc],
+      /(?!.*def)abc/ => %w[abc],
+      /abc(?!.*def.*).*ghi/ => %w[abc ghi],
+      /abc(?!.*bcd)def/ => %w[abcdef]
+    )
+  end
+
+  it 'handles anchors' do
+    verify_strings(
+      /^abc/ => %w[abc],
+      /def$/ => %w[def],
+      /^abc$/ => %w[abc]
+    )
+  end
+
+  def verify_strings(hsh)
+    hsh.each do |regexp, expected|
+      expect(Capybara::Selector::RegexpDisassembler.new(regexp).substrings).to eq expected
+    end
+    verify_alternated_strings(hsh, wrap: true)
+  end
+
+  def verify_alternated_strings(hsh, wrap: false)
+    hsh.each do |regexp, expected|
+      expected = [expected] if wrap && (expected != [])
+      expect(Capybara::Selector::RegexpDisassembler.new(regexp).alternated_substrings).to eq expected
+    end
+  end
+end

data/capybara-3.40.0/spec/result_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Capybara::Result do
+  let :string do
+    Capybara.string <<-STRING
+      <ul>
+        <li>Alpha</li>
+        <li>Beta</li>
+        <li>Gamma</li>
+        <li>Delta</li>
+      </ul>
+    STRING
+  end
+
+  let :result do
+    string.all '//li', minimum: 0 # pass minimum: 0 so lazy evaluation doesn't get triggered yet
+  end
+
+  it 'has a length' do
+    expect(result.length).to eq(4)
+  end
+
+  it 'has a first element' do
+    result.first.text == 'Alpha'
+  end
+
+  it 'has a last element' do
+    result.last.text == 'Delta'
+  end
+
+  it 'splats into multiple assignment' do
+    first, *rest, last = result
+
+    expect(first).to have_text 'Alpha'
+    expect(rest.first).to have_text 'Beta'
+    expect(rest.last).to have_text 'Gamma'
+    expect(last).to have_text 'Delta'
+  end
+
+  it 'can supports values_at method' do
+    expect(result.values_at(0, 2).map(&:text)).to eq(%w[Alpha Gamma])
+  end
+
+  it 'can return an element by its index' do
+    expect(result.at(1).text).to eq('Beta')
+    expect(result[2].text).to eq('Gamma')
+  end
+
+  it 'can be mapped' do
+    expect(result.map(&:text)).to eq(%w[Alpha Beta Gamma Delta])
+  end
+
+  it 'can be selected' do
+    expect(result.count do |element|
+      element.text.include? 't'
+    end).to eq(2)
+  end
+
+  it 'can be reduced' do
+    expect(result.reduce('') do |memo, element|
+      memo + element.text[0]
+    end).to eq('ABGD')
+  end
+
+  it 'can be sampled' do
+    expect(result).to include(result.sample)
+  end
+
+  it 'can be indexed' do
+    expect(result.index do |el|
+      el.text == 'Gamma'
+    end).to eq(2)
+  end
+
+  def recalc_result
+    string.all '//li', minimum: 0 # pass minimum: 0 so lazy evaluation doesn't get triggered yet
+  end
+
+  it 'supports all modes of []' do
+    expect(recalc_result[1].text).to eq 'Beta'
+    expect(recalc_result[0, 2].map(&:text)).to eq %w[Alpha Beta]
+    expect(recalc_result[1..3].map(&:text)).to eq %w[Beta Gamma Delta]
+    expect(recalc_result[-1].text).to eq 'Delta'
+    expect(recalc_result[-2, 3].map(&:text)).to eq %w[Gamma Delta]
+    expect(recalc_result[1...3].map(&:text)).to eq %w[Beta Gamma]
+    expect(recalc_result[1..7].map(&:text)).to eq %w[Beta Gamma Delta]
+    expect(recalc_result[2...-1].map(&:text)).to eq %w[Gamma]
+    expect(recalc_result[2..-1].map(&:text)).to eq %w[Gamma Delta] # rubocop:disable Style/SlicingWithRange
+    expect(recalc_result[2..].map(&:text)).to eq %w[Gamma Delta]
+  end
+
+  it 'supports endless ranges' do
+    expect(result[2..].map(&:text)).to eq %w[Gamma Delta]
+  end
+
+  it 'supports inclusive positive beginless ranges' do
+    expect(result[..2].map(&:text)).to eq %w[Alpha Beta Gamma]
+  end
+
+  it 'supports inclusive negative beginless ranges' do
+    expect(result[..-2].map(&:text)).to eq %w[Alpha Beta Gamma]
+    expect(result[..-1].map(&:text)).to eq %w[Alpha Beta Gamma Delta]
+  end
+
+  it 'supports exclusive positive beginless ranges' do
+    expect(result[...2].map(&:text)).to eq %w[Alpha Beta]
+  end
+
+  it 'supports exclusive negative beginless ranges' do
+    expect(result[...-2].map(&:text)).to eq %w[Alpha Beta]
+    expect(result[...-1].map(&:text)).to eq %w[Alpha Beta Gamma]
+  end
+
+  it 'works with filter blocks' do
+    result = string.all('//li') { |node| node.text == 'Alpha' }
+    expect(result.size).to eq 1
+  end
+
+  # Not a great test but it indirectly tests what is needed
+  it 'should evaluate filters lazily for idx' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    # Not processed until accessed
+    expect(result.instance_variable_get(:@result_cache).size).to be 0
+
+    # Only one retrieved when needed
+    result.first
+    expect(result.instance_variable_get(:@result_cache).size).to be 1
+
+    # works for indexed access
+    result[0]
+    expect(result.instance_variable_get(:@result_cache).size).to be 1
+
+    result[2]
+    expect(result.instance_variable_get(:@result_cache).size).to be 3
+
+    # All cached when converted to array
+    result.to_a
+    expect(result.instance_variable_get(:@result_cache).size).to eq 4
+  end
+
+  it 'should evaluate filters lazily for range' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    result[0..1]
+    expect(result.instance_variable_get(:@result_cache).size).to be 2
+
+    expect(result[0..7].size).to eq 4
+    expect(result.instance_variable_get(:@result_cache).size).to be 4
+  end
+
+  it 'should evaluate filters lazily for idx and length' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    result[1, 2]
+    expect(result.instance_variable_get(:@result_cache).size).to be 3
+
+    expect(result[2, 5].size).to eq 2
+    expect(result.instance_variable_get(:@result_cache).size).to be 4
+  end
+
+  it 'should only need to evaluate one result for any?' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    result.any?
+    expect(result.instance_variable_get(:@result_cache).size).to be 1
+  end
+
+  it 'should evaluate all elements when #to_a called' do
+    # All cached when converted to array
+    result.to_a
+    expect(result.instance_variable_get(:@result_cache).size).to eq 4
+  end
+
+  describe '#each' do
+    it 'lazily evaluates' do
+      skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+      results = []
+      result.each do |el|
+        results << el
+        expect(result.instance_variable_get(:@result_cache).size).to eq results.size
+      end
+
+      expect(results.size).to eq 4
+    end
+
+    context 'without a block' do
+      it 'returns an iterator' do
+        expect(result.each).to be_a(Enumerator)
+      end
+
+      it 'lazily evaluates' do
+        skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+        result.each.with_index do |_el, idx|
+          expect(result.instance_variable_get(:@result_cache).size).to eq(idx + 1) # 0 indexing
+        end
+      end
+    end
+  end
+
+  def jruby_lazy_enumerator_workaround?
+    RUBY_PLATFORM == 'java'
+  end
+end

data/capybara-3.40.0/spec/rspec/features_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# rubocop:disable RSpec/MultipleDescribes
+
+require 'spec_helper'
+require 'capybara/rspec'
+
+# rubocop:disable RSpec/InstanceVariable
+RSpec.configuration.before(:each, file_path: './spec/rspec/features_spec.rb') do
+  @in_filtered_hook = true
+end
+
+feature "Capybara's feature DSL" do
+  background do
+    @in_background = true
+  end
+
+  scenario 'includes Capybara' do
+    visit('/')
+    expect(page).to have_content('Hello world!')
+  end
+
+  scenario 'preserves description' do |ex|
+    expect(ex.metadata[:full_description])
+      .to eq("Capybara's feature DSL preserves description")
+  end
+
+  scenario 'allows driver switching', driver: :selenium do
+    expect(Capybara.current_driver).to eq(:selenium)
+  end
+
+  scenario 'runs background' do
+    expect(@in_background).to be_truthy
+  end
+
+  scenario 'runs hooks filtered by file path' do
+    expect(@in_filtered_hook).to be_truthy
+  end
+
+  scenario "doesn't pollute the Object namespace" do
+    expect(Object.new).not_to respond_to(:feature)
+  end
+
+  feature 'nested features' do
+    scenario 'work as expected' do
+      visit '/'
+      expect(page).to have_content 'Hello world!'
+    end
+
+    scenario 'are marked in the metadata as capybara_feature' do |ex|
+      expect(ex.metadata[:capybara_feature]).to be_truthy
+    end
+
+    scenario 'have a type of :feature' do |ex|
+      expect(ex.metadata[:type]).to eq :feature
+    end
+  end
+end
+# rubocop:enable RSpec/InstanceVariable
+
+feature 'given and given! aliases to let and let!' do
+  given(:value) { :available }
+  given!(:value_in_background) { :available }
+
+  background do
+    expect(value_in_background).to be(:available)
+  end
+
+  scenario 'given and given! work as intended' do
+    expect(value).to be(:available)
+    expect(value_in_background).to be(:available)
+  end
+end
+
+feature "Capybara's feature DSL with driver", driver: :culerity do
+  scenario 'switches driver' do
+    expect(Capybara.current_driver).to eq(:culerity)
+  end
+end
+
+# rubocop:disable RSpec/RepeatedExample
+xfeature 'if xfeature aliases to pending then' do
+  scenario "this should be 'temporarily disabled with xfeature'" do
+    # dummy
+  end
+
+  scenario "this also should be 'temporarily disabled with xfeature'" do
+    # dummy
+  end
+end
+
+ffeature 'if ffeature aliases focused tag then' do # rubocop:disable RSpec/Focus
+  scenario 'scenario inside this feature has metatag focus tag' do |example|
+    expect(example.metadata[:focus]).to be true
+  end
+
+  scenario 'other scenarios also has metatag focus tag' do |example|
+    expect(example.metadata[:focus]).to be true
+  end
+end
+# rubocop:enable RSpec/RepeatedExample, RSpec/MultipleDescribes

data/capybara-3.40.0/spec/rspec/scenarios_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# rubocop:disable RSpec/MultipleDescribes
+
+require 'spec_helper'
+require 'capybara/rspec'
+
+RSpec.configuration.before(:each, file_path: './spec/rspec/scenarios_spec.rb') do
+  @in_filtered_hook = true
+end
+
+feature 'if fscenario aliases focused tag then' do
+  fscenario 'scenario should have focused meta tag' do |example| # rubocop:disable RSpec/Focus
+    expect(example.metadata[:focus]).to be true
+  end
+end
+
+feature 'if xscenario aliases to pending then' do
+  xscenario "this test should be 'temporarily disabled with xscenario'" do # rubocop:disable RSpec/PendingWithoutReason
+  end
+end
+
+# rubocop:enable RSpec/MultipleDescribes