tdiary 5.2.3 → 5.2.4

data/vendor/bundle/ruby/3.1.0/gems/test-unit-3.5.3/lib/test/unit/attribute.rb

@@ -1,227 +0,0 @@
-module Test
-  module Unit
-    module Attribute
-      class StringifyKeyHash < Hash
-        class << self
-          def stringify(object)
-            object.to_s
-          end
-        end
-
-        def key?(key)
-          super(self.class.stringify(key))
-        end
-
-        def [](key)
-          super(self.class.stringify(key))
-        end
-
-        def []=(key, value)
-          super(self.class.stringify(key), value)
-        end
-      end
-
-      class << self
-        def included(base)
-          base.extend(BaseClassMethods)
-          base.extend(ClassMethods)
-        end
-      end
-
-      module BaseClassMethods
-        def attributes_table
-          {}
-        end
-      end
-
-      module ClassMethods
-        def method_added(name)
-          super
-          return unless defined?(@current_attributes)
-
-          attributes = {}
-          kept_attributes = StringifyKeyHash.new
-          @current_attributes.each do |attribute_name, attribute|
-            attributes[attribute_name] = attribute[:value]
-            if attribute[:keep]
-              keep_hook = attribute[:keep_hook]
-              attribute = keep_hook.call(attribute) if keep_hook
-              kept_attributes[attribute_name] = attribute
-            end
-          end
-          set_attributes(name, attributes)
-          @current_attributes = kept_attributes
-        end
-
-        # Set an attribute to test methods.
-        #
-        # @overload attribute(name, value)
-        #   @example
-        #     attribute :speed, :slow
-        #     def test_my_slow_method
-        #       self[:speed] # => :slow
-        #     end
-        #
-        #   @param [Object] name the attribute name
-        #   @param [Object] value the attribute value
-        #   @return [void]
-        #
-        # @overload attribute(name, value, *method_names)
-        #   @example
-        #     def test_my_slow_method1
-        #       self[:speed] # => :slow
-        #     end
-        #
-        #     attribute :speed, :slow, :test_my_slow_method1, :test_my_slow_method2
-        #
-        #     def test_my_slow_method2
-        #       self[:speed] # => :slow
-        #     end
-        #
-        #   @param [Object] name the attribute name
-        #   @param [Object] value the attribute value
-        #   @param [Array<Symbol, String>] method_names the test method names set the attribute
-        #   @return [void]
-        #
-        # @overload attribute(name, value, options)
-        #   @example
-        #     attribute :speed, :slow, keep: true
-        #     def test_my_slow_method1
-        #       self[:speed] # => :slow
-        #     end
-        #
-        #     def test_my_slow_method2
-        #       self[:speed] # => :slow
-        #     end
-        #
-        #   @param [Object] name the attribute name
-        #   @param [Object] value the attribute value
-        #   @option options [Boolean] :keep whether or not to set attribute to following test methods
-        #   @return [void]
-        #
-        # @overload attribute(name, value, options, *method_names)
-        #   @example
-        #     def test_my_slow_method1
-        #       self[:speed] # => :slow
-        #     end
-        #
-        #     # There are no valid options for now.
-        #     attribute :speed, :slow, {}, :test_my_slow_method1
-        #
-        #     def test_my_slow_method2
-        #       self[:speed] # => nil
-        #     end
-        #
-        #   @param [Object] name the attribute name
-        #   @param [Object] value the attribute value
-        #   @param [Hash] options ignored
-        #   @param [Array<Symbol, String>] method_names the test method names set the attribute
-        #   @return [void]
-        def attribute(name, value, options={}, *method_names)
-          unless options.is_a?(Hash)
-            method_names << options
-            options = {}
-          end
-          if method_names.empty?
-            current_attributes[name] = options.merge(:value => value)
-          else
-            method_names.each do |method_name|
-              set_attributes(method_name, {name => value})
-            end
-          end
-        end
-
-        def current_attributes
-          @current_attributes ||= StringifyKeyHash.new
-        end
-
-        def current_attribute(name)
-          current_attributes[name] || StringifyKeyHash.new
-        end
-
-        def attributes_table
-          @attributes_table ||= StringifyKeyHash.new
-          super.merge(@attributes_table)
-        end
-
-        def set_attributes(method_name, new_attributes)
-          return if new_attributes.empty?
-          @attributes_table ||= StringifyKeyHash.new
-          @attributes_table[method_name] ||= StringifyKeyHash.new
-          current_attributes = @attributes_table[method_name]
-          new_attributes.each do |key, value|
-            observers = attribute_observers(key) || []
-            observers.each do |observer|
-              observer.call(self,
-                            StringifyKeyHash.stringify(key),
-                            (attributes(method_name) || {})[key],
-                            value,
-                            method_name)
-            end
-            current_attributes[key] = value
-          end
-        end
-
-        def attributes(method_name)
-          attributes = attributes_table[method_name]
-          ancestors.each do |ancestor|
-            next if ancestor == self
-            if ancestor.is_a?(Class) and ancestor < Test::Unit::Attribute
-              parent_attributes = ancestor.attributes(method_name)
-              if attributes
-                attributes = (parent_attributes || {}).merge(attributes)
-              else
-                attributes = parent_attributes
-              end
-              break
-            end
-          end
-          attributes || StringifyKeyHash.new
-        end
-
-        def find_attribute(method_name, name, options={})
-          recursive_p = options[:recursive]
-          recursive_p = true if recursive_p.nil?
-
-          @attributes_table ||= StringifyKeyHash.new
-          if @attributes_table.key?(method_name)
-            attributes = @attributes_table[method_name]
-            if attributes.key?(name)
-              return attributes[name]
-            end
-          end
-
-          return nil unless recursive_p
-          return nil if self == TestCase
-
-          @cached_parent_test_case ||= ancestors.find do |ancestor|
-            ancestor != self and
-              ancestor.is_a?(Class) and
-              ancestor < Test::Unit::Attribute
-          end
-
-          @cached_parent_test_case.find_attribute(method_name, name, options)
-        end
-
-        @@attribute_observers = StringifyKeyHash.new
-        def register_attribute_observer(attribute_name, observer=nil, &block)
-          observer ||= Proc.new(&block)
-          @@attribute_observers[attribute_name] ||= []
-          @@attribute_observers[attribute_name] << observer
-        end
-
-        def attribute_observers(attribute_name)
-          @@attribute_observers[attribute_name]
-        end
-      end
-
-      def attributes
-        self.class.attributes(@method_name) || StringifyKeyHash.new
-      end
-
-      def [](name)
-        self.class.find_attribute(@method_name, name)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/test-unit-3.5.3/lib/test/unit/version.rb

@@ -1,5 +0,0 @@
-module Test
-  module Unit
-    VERSION = "3.5.3"
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/websocket-1.2.9/CHANGELOG.md

@@ -1,114 +0,0 @@
-# Changelog
-
-## 1.2.9
-
-- avoid ruby -w warnings
-
-## 1.2.8
-
-- restore support for Ruby 2.0+
-
-## 1.2.7
-
-- fix bug in previous version for Ruby 2.3
-
-## 1.2.6
-
-- duplicate variables passed in initializers to avoid changing them
-
-## 1.2.5
-
-- make handshake server resilient to non-string Rack env keys
-
-## 1.2.4
-
-- add subprotocol handling for both server and client
-
-## 1.2.3
-
-- fix for draft 76 when challenge might sometimes fail
-- multiple small optimizations
-
-## 1.2.2
-
-- fix handshake for draft 11+ sending Sec-WebSocket-Origin instead of Origin
-
-## 1.2.1
-
-- fix error for draft 76 when leftovers are empty
-
-## 1.2.0
-
-- Remove support for Ruby 1.8
-- Add support for sending custom headers for Client
-- Better detection and handling of draft 76
-- Multiple small fixes and optimizations
-
-## 1.1.4
-
-- verify valid close codes according to spec
-- return error on invalid UTF-8 payload
-- expose error message
-
-## 1.1.3
-
-- fix close code support
-
-## 1.1.2
-
-- fix support for rack input that is blocking (i.e. Passenger)
-
-## 1.1.1
-
-- fix handling close code for frames version 5+
-
-## 1.1.0
-
-- allow raising ruby errors instead of setting `error` flag
-- allow access to handshake headers
-- add from_rack method
-- add from_hash method
-- stop extending handlers - it should improve performance for opening connection
-
-## 1.0.7
-
-- fix requiring url under Ruby 1.9.1
-- support for Ruby 2.0.0
-
-## 1.0.6
-
-- support text frame types instead of only symbol ones
-- support for sending masked frames
-
-## 1.0.5
-
-- add support for close codes
-
-## 1.0.4
-
-- nicer inspect - handful during debugging
-
-## 1.0.3
-
-- improve pure ruby implementation performance by ~30%
-- add support for native extension
-
-## 1.0.2
-
-- allow configuration of max frame size via WebSocket.max_frame_size option
-- much better documentation
-- remove handler-specific methods from public list
-- refactor code for easier use
-- make parsers return more consistent values
-- fix server handshake #to_s when no version was found
-- add #uri to server handshake
-
-## 1.0.1
-
-- allow creating client with :uri and :url options
-- prevent strange results when header is mailformed
-- set client path to '/' when :uri option is provided but without trailing slash
-
-## 1.0.0
-
-- initial release

data/vendor/bundle/ruby/3.1.0/gems/websocket-1.2.9/Gemfile

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-source 'http://rubygems.org'
-
-group :development do
-  gem 'rake'
-  gem 'rspec', '~> 3.7'
-
-  # Use same version as Code Climate for consistency with CI
-  # https://github.com/codeclimate/codeclimate-rubocop/blob/master/Gemfile.lock
-  gem 'rubocop', '0.52.1', require: false
-  gem 'rubocop-rspec', '1.21.0', require: false
-end
-
-gemspec

data/vendor/bundle/ruby/3.1.0/gems/websocket-1.2.9/README.md

@@ -1,131 +0,0 @@
-# WebSocket Ruby
-
-Universal Ruby library to handle WebSocket protocol. It focuses on providing abstraction layer over [WebSocket API](http://dev.w3.org/html5/websockets/) instead of providing server or client functionality.
-
-[![Gem Version](https://badge.fury.io/rb/websocket.svg)](http://badge.fury.io/rb/websocket)
-[![Gem Downloads](https://img.shields.io/gem/dt/websocket.svg?maxAge=2592000)](https://rubygems.org/gems/websocket)
-[![Travis CI](https://travis-ci.org/imanel/websocket-ruby.svg)](http://travis-ci.org/imanel/websocket-ruby)
-[![Code Climate](https://codeclimate.com/github/imanel/websocket-ruby.svg)](https://codeclimate.com/github/imanel/websocket-ruby)
-
-**Autobahn tests:** [server](http://imanel.github.com/websocket-ruby/autobahn/server/), [client](http://imanel.github.com/websocket-ruby/autobahn/client/)
-
-Currently WebSocket Ruby supports all existing drafts of WebSocket, which include:
-
-- [hixie-75](http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75)
-- [hixie-76](http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76)
-- [all hybi drafts (00-13)](http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17)
-- [RFC 6455](http://datatracker.ietf.org/doc/rfc6455/)
-
-## Installation
-
-WebSocket Ruby has no external dependencies, so it can be installed from source or directly from rubygems:
-
-```
-gem install "websocket"
-```
-
-or via Gemfile:
-
-```
-gem "websocket"
-```
-
-## Server handshake
-
-``` ruby
-@handshake = WebSocket::Handshake::Server.new
-
-# Parse client request
-@handshake << <<EOF
-GET /demo HTTP/1.1\r
-Upgrade: websocket\r
-Connection: Upgrade\r
-Host: example.com\r
-Origin: http://example.com\r
-Sec-WebSocket-Version: 13\r
-Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
-\r
-EOF
-
-# All data received?
-@handshake.finished?
-
-# No parsing errors?
-@handshake.valid?
-
-# Create response
-@handshake.to_s # HTTP/1.1 101 Switching Protocols
-                # Upgrade: websocket
-                # Connection: Upgrade
-                # Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
-```
-
-## Client handshake
-
-``` ruby
-@handshake = WebSocket::Handshake::Client.new(url: 'ws://example.com', headers: { 'Cookie' => 'SESSIONID=1234' })
-
-# Create request
-@handshake.to_s # GET /demo HTTP/1.1
-                # Upgrade: websocket
-                # Connection: Upgrade
-                # Host: example.com
-                # Cookie: SESSIONID=1234
-                # Origin: http://example.com
-                # Sec-WebSocket-Version: 13
-                # Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
-
-# Parse server response
-@handshake << <<EOF
-HTTP/1.1 101 Switching Protocols\r
-Upgrade: websocket\r
-Connection: Upgrade\r
-Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
-\r
-EOF
-
-# All data received?
-@handshake.finished?
-
-# No parsing errors?
-@handshake.valid?
-```
-
-## Parsing and constructing frames
-
-``` ruby
-# Prepare frame for sending
-frame = WebSocket::Frame::Outgoing::Server.new(version: @handshake.version, data: "Hello", type: :text)
-frame.to_s # "\x81\x05\x48\x65\x6c\x6c\x6f"
-
-# Parse incoming frames
-frame = WebSocket::Frame::Incoming::Server.new(version: @handshake.version)
-frame << "\x81\x05\x48\x65\x6c\x6c\x6f\x81\x06\x77\x6f\x72\x6c\x64\x21"
-frame.next # "Hello"
-frame.next # "world!""
-```
-
-## Examples & Projects using WebSocket-Ruby
-
-- [WebSocket-EventMachine-Client](https://github.com/imanel/websocket-eventmachine-client) - client based on EventMachine
-- [WebSocket-EventMachine-Server](https://github.com/imanel/websocket-eventmachine-server) - server based on EventMachine (drop-in replacement for EM-WebSocket)
-- [Selenium-WebDriver](https://rubygems.org/gems/selenium-webdriver) - tool for writing automated tests of websites
-- [Rubame](https://github.com/saward/Rubame) - websocket game server
-
-## Native extension
-
-WebSocket gem is written in pure Ruby, without any dependencies or native extensions and still is one of the fastest implementations of WebSocket API. However, if you want to increase it's speed even further, I created additional gem with dedicated native extensions for both C and Java. Those extensions provide 20-30% increase in speed(more accurate comparison can be found in autobahn test results)
-
-In order to use native extension just install [websocket-native](http://github.com/imanel/websocket-ruby-native) gem or add it to Gemfile - WebSocket will automatically detect and load it.
-
-## License
-
-(The MIT License)
-
-Copyright © 2012 Bernard Potocki
-
-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.

data/vendor/bundle/ruby/3.1.0/gems/websocket-1.2.9/Rakefile

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
-
-Bundler::GemHelper.install_tasks
-
-RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = ['-c', '-f progress']
-  t.pattern = 'spec/**/*_spec.rb'
-end
-
-RuboCop::RakeTask.new
-
-task default: %i[spec rubocop]
-
-namespace :autobahn do
-  desc 'Run autobahn tests for client'
-  task :client do
-    system('wstest --mode=fuzzingserver --spec=autobahn-client.json')
-  end
-
-  desc 'Run autobahn tests for server'
-  task :server do
-    system('wstest --mode=fuzzingclient --spec=autobahn-server.json')
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/websocket-1.2.9/lib/websocket/error.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module WebSocket
-  class Error < RuntimeError
-    class Frame < ::WebSocket::Error
-      class ControlFramePayloadTooLong < ::WebSocket::Error::Frame
-        def message
-          :control_frame_payload_too_long
-        end
-      end
-
-      class DataFrameInsteadContinuation < ::WebSocket::Error::Frame
-        def message
-          :data_frame_instead_continuation
-        end
-      end
-
-      class FragmentedControlFrame < ::WebSocket::Error::Frame
-        def message
-          :fragmented_control_frame
-        end
-      end
-
-      class Invalid < ::WebSocket::Error::Frame
-        def message
-          :invalid_frame
-        end
-      end
-
-      class InvalidPayloadEncoding < ::WebSocket::Error::Frame
-        def message
-          :invalid_payload_encoding
-        end
-      end
-
-      class MaskTooShort < ::WebSocket::Error::Frame
-        def message
-          :mask_is_too_short
-        end
-      end
-
-      class ReservedBitUsed < ::WebSocket::Error::Frame
-        def message
-          :reserved_bit_used
-        end
-      end
-
-      class TooLong < ::WebSocket::Error::Frame
-        def message
-          :frame_too_long
-        end
-      end
-
-      class UnexpectedContinuationFrame < ::WebSocket::Error::Frame
-        def message
-          :unexpected_continuation_frame
-        end
-      end
-
-      class UnknownFrameType < ::WebSocket::Error::Frame
-        def message
-          :unknown_frame_type
-        end
-      end
-
-      class UnknownOpcode < ::WebSocket::Error::Frame
-        def message
-          :unknown_opcode
-        end
-      end
-
-      class UnknownCloseCode < ::WebSocket::Error::Frame
-        def message
-          :unknown_close_code
-        end
-      end
-
-      class UnknownVersion < ::WebSocket::Error::Frame
-        def message
-          :unknown_protocol_version
-        end
-      end
-    end
-
-    class Handshake < ::WebSocket::Error
-      class GetRequestRequired < ::WebSocket::Error::Handshake
-        def message
-          :get_request_required
-        end
-      end
-
-      class InvalidAuthentication < ::WebSocket::Error::Handshake
-        def message
-          :invalid_handshake_authentication
-        end
-      end
-
-      class InvalidHeader < ::WebSocket::Error::Handshake
-        def message
-          :invalid_header
-        end
-      end
-
-      class UnsupportedProtocol < ::WebSocket::Error::Handshake
-        def message
-          :unsupported_protocol
-        end
-      end
-
-      class InvalidStatusCode < ::WebSocket::Error::Handshake
-        def message
-          :invalid_status_code
-        end
-      end
-
-      class NoHostProvided < ::WebSocket::Error::Handshake
-        def message
-          :no_host_provided
-        end
-      end
-
-      class UnknownVersion < ::WebSocket::Error::Handshake
-        def message
-          :unknown_protocol_version
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/websocket-1.2.9/lib/websocket/exception_handler.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module WebSocket
-  module ExceptionHandler
-    attr_accessor :error
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      # Rescue from WebSocket::Error errors.
-      #
-      # @param [String] method_name Name of method that should be wrapped and rescued
-      # @param [Hash] options Options for rescue
-      #
-      # @option options [Any] :return Value that should be returned instead of raised error
-      def rescue_method(method_name, options = {})
-        define_method "#{method_name}_with_rescue" do |*args|
-          begin
-            send("#{method_name}_without_rescue", *args)
-          rescue WebSocket::Error => e
-            self.error = e.message.to_sym
-            WebSocket.should_raise ? raise : options[:return]
-          end
-        end
-        alias_method "#{method_name}_without_rescue", method_name
-        alias_method method_name, "#{method_name}_with_rescue"
-      end
-    end
-  end
-end