tdiary 5.0.1 → 5.0.2

data/vendor/bundle/gems/capybara-2.7.1/lib/capybara/queries/selector_query.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-module Capybara
-  module Queries
-    class SelectorQuery < Queries::BaseQuery
-      attr_accessor :selector, :locator, :options, :expression, :find, :negative
-
-      VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum, :exact, :match, :wait]
-      VALID_MATCH = [:first, :smart, :prefer_exact, :one]
-
-      def initialize(*args)
-        @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-
-        if args[0].is_a?(Symbol)
-          @selector = Selector.all[args.shift]
-          @locator = args.shift
-        else
-          @selector = Selector.all.values.find { |s| s.match?(args[0]) }
-          @locator = args.shift
-        end
-        @selector ||= Selector.all[Capybara.default_selector]
-
-        warn "Unused parameters passed to #{self.class.name} : #{args.to_s}" unless args.empty?
-
-        # for compatibility with Capybara 2.0
-        if Capybara.exact_options and @selector == Selector.all[:option]
-          @options[:exact] = true
-        end
-
-        @expression = @selector.call(@locator)
-        assert_valid_keys
-      end
-
-      def name; selector.name; end
-      def label; selector.label or selector.name; end
-
-      def description
-        @description = String.new("#{label} #{locator.inspect}")
-        @description << " with text #{options[:text].inspect}" if options[:text]
-        @description << selector.description(options)
-        @description
-      end
-
-      def matches_filters?(node)
-        if options[:text]
-          regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text].to_s)
-          return false if not node.text(visible).match(regexp)
-        end
-        case visible
-          when :visible then return false unless node.visible?
-          when :hidden then return false if node.visible?
-        end
-        selector.custom_filters.each do |name, filter|
-          if options.has_key?(name)
-            return false unless filter.matches?(node, options[name])
-          elsif filter.default?
-            return false unless filter.matches?(node, filter.default)
-          end
-        end
-      end
-
-      def visible
-        if options.has_key?(:visible)
-          case @options[:visible]
-            when true then :visible
-            when false then :all
-            else @options[:visible]
-          end
-        else
-          if Capybara.ignore_hidden_elements
-            :visible
-          else
-            :all
-          end
-        end
-      end
-
-      def exact?
-        if options.has_key?(:exact)
-          @options[:exact]
-        else
-          Capybara.exact
-        end
-      end
-
-      def match
-        if options.has_key?(:match)
-          @options[:match]
-        else
-          Capybara.match
-        end
-      end
-
-      def xpath(exact=nil)
-        exact = self.exact? if exact == nil
-        if @expression.respond_to?(:to_xpath) and exact
-          @expression.to_xpath(:exact)
-        else
-          @expression.to_s
-        end
-      end
-
-      def css
-        @expression
-      end
-
-      # @api private
-      def resolve_for(node, exact = nil)
-        node.synchronize do
-          children = if selector.format == :css
-            node.find_css(self.css)
-          else
-            node.find_xpath(self.xpath(exact))
-          end.map do |child|
-            if node.is_a?(Capybara::Node::Base)
-              Capybara::Node::Element.new(node.session, child, node, self)
-            else
-              Capybara::Node::Simple.new(child)
-            end
-          end
-          Capybara::Result.new(children, self)
-        end
-      end
-
-      private
-
-      def valid_keys
-        COUNT_KEYS + [:text, :visible, :exact, :match, :wait] + @selector.custom_filters.keys
-      end
-
-      def assert_valid_keys
-        super
-        unless VALID_MATCH.include?(match)
-          raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(", ")}"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/capybara-2.7.1/lib/capybara/queries/text_query.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-module Capybara
-  # @api private
-  module Queries
-    class TextQuery < BaseQuery
-      def initialize(*args)
-        @type = (args.first.is_a?(Symbol) || args.first.nil?) ? args.shift : nil
-        @expected_text, @options = args
-        unless @expected_text.is_a?(Regexp)
-          @expected_text = Capybara::Helpers.normalize_whitespace(@expected_text)
-        end
-        @search_regexp = Capybara::Helpers.to_regexp(@expected_text)
-        @options ||= {}
-        assert_valid_keys
-      end
-
-      def resolve_for(node)
-        @actual_text = Capybara::Helpers.normalize_whitespace(node.text(@type))
-        @count = @actual_text.scan(@search_regexp).size
-      end
-
-      def failure_message
-        description =
-          if @expected_text.is_a?(Regexp)
-            "text matching #{@expected_text.inspect}"
-          else
-            "text #{@expected_text.inspect}"
-          end
-
-        message = Capybara::Helpers.failure_message(description, @options)
-        unless (COUNT_KEYS & @options.keys).empty?
-          message << " but found #{@count} #{Capybara::Helpers.declension('time', 'times', @count)}"
-        end
-        message << " in #{@actual_text.inspect}"
-      end
-
-      def negative_failure_message
-        failure_message.sub(/(to find)/, 'not \1')
-      end
-
-      private
-
-      def valid_keys
-        COUNT_KEYS + [:wait]
-      end
-    end
-  end
-end

data/vendor/bundle/gems/capybara-2.7.1/lib/capybara/rack_test/node.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-class Capybara::RackTest::Node < Capybara::Driver::Node
-  def all_text
-    Capybara::Helpers.normalize_whitespace(native.text)
-  end
-
-  def visible_text
-    Capybara::Helpers.normalize_whitespace(unnormalized_text)
-  end
-
-  def [](name)
-    string_node[name]
-  end
-
-  def value
-    string_node.value
-  end
-
-  def set(value)
-    if (Array === value) && !self[:multiple]
-      raise ArgumentError.new "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
-    end
-
-    if radio?
-      set_radio(value)
-    elsif checkbox?
-      set_checkbox(value)
-    elsif input_field?
-      set_input(value)
-    elsif textarea?
-      if self[:readonly]
-        warn "Attempt to set readonly element with value: #{value} \n * This will raise an exception in a future version of Capybara"
-      else
-        native.content = value.to_s
-      end
-    end
-  end
-
-  def select_option
-    return if disabled?
-    if select_node['multiple'] != 'multiple'
-      select_node.find_xpath(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
-    end
-    native["selected"] = 'selected'
-  end
-
-  def unselect_option
-    if select_node['multiple'] != 'multiple'
-      raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
-    end
-    native.remove_attribute('selected')
-  end
-
-  def click
-    if tag_name == 'a' && !self[:href].nil?
-      method = self["data-method"] if driver.options[:respect_data_method]
-      method ||= :get
-      driver.follow(method, self[:href].to_s)
-    elsif (tag_name == 'input' and %w(submit image).include?(type)) or
-        ((tag_name == 'button') and type.nil? or type == "submit")
-      associated_form = form
-      Capybara::RackTest::Form.new(driver, associated_form).submit(self) if associated_form
-    end
-  end
-
-  def tag_name
-    native.node_name
-  end
-
-  def visible?
-    string_node.visible?
-  end
-
-  def checked?
-    string_node.checked?
-  end
-
-  def selected?
-    string_node.selected?
-  end
-
-  def disabled?
-    if %w(option optgroup).include? tag_name
-      string_node.disabled? || find_xpath("parent::*")[0].disabled?
-    else
-      string_node.disabled?
-    end
-  end
-
-  def path
-    native.path
-  end
-
-  def find_xpath(locator)
-    native.xpath(locator).map { |n| self.class.new(driver, n) }
-  end
-
-  def find_css(locator)
-    native.css(locator, Capybara::RackTest::CSSHandlers.new).map { |n| self.class.new(driver, n) }
-  end
-
-  def ==(other)
-    native == other.native
-  end
-
-protected
-
-  def unnormalized_text(check_ancestor_visibility = true)
-    if !string_node.visible?(check_ancestor_visibility)
-      ''
-    elsif native.text?
-      native.text
-    elsif native.element?
-      native.children.map do |child|
-        Capybara::RackTest::Node.new(driver, child).unnormalized_text(false)
-      end.join
-    else
-      ''
-    end
-  end
-
-private
-
-  def string_node
-    @string_node ||= Capybara::Node::Simple.new(native)
-  end
-
-  # a reference to the select node if this is an option node
-  def select_node
-    find_xpath('./ancestor::select').first
-  end
-
-  def type
-    native[:type]
-  end
-
-  def form
-    if native[:form]
-      native.xpath("//form[@id='#{native[:form]}']").first
-    else
-      native.ancestors('form').first
-    end
-  end
-
-  def set_radio(value)
-    other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name).equals(self[:name])] }.to_s
-    driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
-    native['checked'] = 'checked'
-  end
-
-  def set_checkbox(value)
-    if value && !native['checked']
-      native['checked'] = 'checked'
-    elsif !value && native['checked']
-      native.remove_attribute('checked')
-    end
-  end
-
-  def set_input(value)
-    if text_or_password? && attribute_is_not_blank?(:maxlength)
-      # Browser behavior for maxlength="0" is inconsistent, so we stick with
-      # Firefox, allowing no input
-      value = value.to_s[0...self[:maxlength].to_i]
-    end
-    if Array === value #Assert multiple attribute is present
-      value.each do |v|
-        new_native = native.clone
-        new_native.remove_attribute('value')
-        native.add_next_sibling(new_native)
-        new_native['value'] = v.to_s
-      end
-      native.remove
-    else
-      if self[:readonly]
-        warn "Attempt to set readonly element with value: #{value} \n *This will raise an exception in a future version of Capybara"
-      else
-        native['value'] = value.to_s
-      end
-    end
-  end
-
-  def attribute_is_not_blank?(attribute)
-    self[attribute] && !self[attribute].empty?
-  end
-
-  def checkbox?
-    input_field? && type == 'checkbox'
-  end
-
-  def input_field?
-    tag_name == 'input'
-  end
-
-  def radio?
-    input_field? && type == 'radio'
-  end
-
-  def textarea?
-    tag_name == "textarea"
-  end
-
-  def text_or_password?
-    input_field? && (type == 'text' || type == 'password')
-  end
-end

data/vendor/bundle/gems/capybara-2.7.1/lib/capybara/result.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-require 'forwardable'
-
-module Capybara
-
-  ##
-  # A {Capybara::Result} represents a collection of {Capybara::Node::Element} on the page. It is possible to interact with this
-  # collection similar to an Array because it implements Enumerable and offers the following Array methods through delegation:
-  #
-  # * []
-  # * each()
-  # * at()
-  # * size()
-  # * count()
-  # * length()
-  # * first()
-  # * last()
-  # * empty?()
-  #
-  # @see Capybara::Node::Element
-  #
-  class Result
-    include Enumerable
-    extend Forwardable
-
-    def initialize(elements, query)
-      @elements = elements
-      @result = elements.select { |node| query.matches_filters?(node) }
-      @rest = @elements - @result
-      @query = query
-    end
-
-    def_delegators :@result, :each, :[], :at, :size, :count, :length,
-                   :first, :last, :values_at, :empty?, :inspect, :sample, :index
-
-    def matches_count?
-      Capybara::Helpers.matches_count?(@result.size, @query.options)
-    end
-
-    def failure_message
-      message = Capybara::Helpers.failure_message(@query.description, @query.options)
-      if count > 0
-        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << @result.map(&:text).map(&:inspect).join(", ")
-      else
-        message << " but there were no matches"
-      end
-      unless @rest.empty?
-        elements = @rest.map(&:text).map(&:inspect).join(", ")
-        message << ". Also found " << elements << ", which matched the selector but not all filters."
-      end
-      message
-    end
-
-    def negative_failure_message
-      failure_message.sub(/(to find)/, 'not \1')
-    end
-  end
-end

data/vendor/bundle/gems/capybara-2.7.1/lib/capybara/rspec/features.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-if RSpec::Core::Version::STRING.to_f >= 3.0
-  RSpec.shared_context "Capybara Features", :capybara_feature => true do
-    instance_eval do
-      alias background before
-      alias given let
-      alias given! let!
-    end
-  end
-
-  RSpec.configure do |config|
-    config.alias_example_group_to :feature, :capybara_feature => true, :type => :feature
-    config.alias_example_group_to :xfeature, :capybara_feature => true, :type => :feature, :skip => "Temporarily disabled with xfeature"
-    config.alias_example_group_to :ffeature, :capybara_feature => true, :type => :feature, :focus => true
-    config.alias_example_to :scenario
-    config.alias_example_to :xscenario, :skip => "Temporarily disabled with xscenario"
-    config.alias_example_to :fscenario, :focus => true
-  end
-else
-  module Capybara
-    module Features
-      def self.included(base)
-        base.instance_eval do
-          alias :background :before
-          alias :scenario :it
-          alias :xscenario :xit
-          alias :given :let
-          alias :given! :let!
-          alias :feature :describe
-        end
-      end
-    end
-  end
-
-
-  def self.feature(*args, &block)
-    options = if args.last.is_a?(Hash) then args.pop else {} end
-    options[:capybara_feature] = true
-    options[:type] = :feature
-    options[:caller] ||= caller
-    args.push(options)
-
-    #call describe on RSpec in case user has expose_dsl_globally set to false
-    RSpec.describe(*args, &block)
-  end
-
-  RSpec.configuration.include Capybara::Features, :capybara_feature => true
-end