talon_one 6.0.0 → 7.0.0

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/lib/typhoeus/response/status.rb

@@ -0,0 +1,106 @@
+module Typhoeus
+  class Response
+
+    # This module contains logic about the http
+    # status.
+    module Status
+
+      # Return the status message if present.
+      #
+      # @example Return status message.
+      #   reesponse.status_message
+      #
+      # @return [ String ] The message.
+      def status_message
+        return @status_message if defined?(@status_message) && @status_message
+        return options[:status_message] unless options[:status_message].nil?
+
+        # HTTP servers can choose not to include the explanation to HTTP codes. The RFC
+        # states this (http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4):
+        # Except when responding to a HEAD request, the server SHOULD include an entity containing
+        # an explanation of the error situation [...]
+        # This means 'HTTP/1.1 404' is as valid as 'HTTP/1.1 404 Not Found' and we have to handle it.
+        #
+        # Regexp doc: http://rubular.com/r/eAr1oVYsVa
+        if first_header_line != nil and first_header_line[/\d{3} (.*)$/, 1] != nil
+          @status_message = first_header_line[/\d{3} (.*)$/, 1].chomp
+        else
+          @status_message = nil
+        end
+      end
+
+      # Return the http version.
+      #
+      # @example Return http version.
+      #  response.http_version
+      #
+      # @return [ String ] The http version.
+      def http_version
+        @http_version ||= first_header_line ? first_header_line[/HTTP\/(\S+)/, 1] : nil
+      end
+
+      # Return whether the response is a success.
+      #
+      # @example Return if the response was successful.
+      #  response.success?
+      #
+      # @return [ Boolean ] Return true if successful, false else.
+      def success?
+        (mock || return_code == :ok) && response_code && has_good_response_code?
+      end
+
+      # Return whether the response is a failure.
+      #
+      # @example Return if the response was failed.
+      #  response.failure?
+      #
+      # @return [ Boolean ] Return true if failure, false else.
+      def failure?
+        (mock || return_code == :internal_server_error) && response_code && has_bad_response_code?
+      end
+
+      # Return wether the response is modified.
+      #
+      # @example Return if the response was modified.
+      #  response.modified?
+      #
+      # @return [ Boolean ] Return true if modified, false else.
+      def modified?
+        (mock || return_code == :ok) && response_code && response_code != 304
+      end
+
+      # Return whether the response is timed out.
+      #
+      # @example Return if the response timed out.
+      #  response.timed_out?
+      #
+      # @return [ Boolean ] Return true if timed out, false else.
+      def timed_out?
+        return_code == :operation_timedout
+      end
+
+      private
+
+      # :nodoc:
+      def first_header_line
+        @first_header_line ||= begin
+          if response_headers.to_s.include?("\r\n\r\n")
+            response_headers.to_s.split("\r\n\r\n").last.split("\r\n").first
+          else
+            response_headers.to_s.split("\r\n").first
+          end
+        end
+      end
+
+      # :nodoc:
+      def has_good_response_code?
+        response_code >= 200 && response_code < 300
+      end
+
+      # :nodoc:
+      def has_bad_response_code?
+        !has_good_response_code?
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/lib/typhoeus/response.rb

@@ -0,0 +1,68 @@
+require 'typhoeus/response/header'
+require 'typhoeus/response/informations'
+require 'typhoeus/response/status'
+require 'typhoeus/response/cacheable'
+
+module Typhoeus
+
+  # This class represents the response.
+  class Response
+    include Response::Informations
+    include Response::Status
+    include Response::Cacheable
+
+    # Remembers the corresponding request.
+    #
+    # @example Get request.
+    #   request = Typhoeus::Request.new("www.example.com")
+    #   response = request.run
+    #   request == response.request
+    #   #=> true
+    #
+    # @return [ Typhoeus::Request ]
+    attr_accessor :request
+
+    # The provided options, which contain all the
+    # informations about the request.
+    #
+    # @return [ Hash ]
+    attr_accessor :options
+
+    # Set the handled response.
+    attr_writer :handled_response
+
+    # @api private
+    attr_writer :mock
+
+    # Create a new response.
+    #
+    # @example Create a response.
+    #  Response.new
+    #
+    # @param [ Hash ] options The options hash.
+    #
+    # @return [ Response ] The new response.
+    def initialize(options = {})
+      @options = options
+      @headers = Header.new(options[:headers]) if options[:headers]
+    end
+
+    # Returns whether this request is mocked
+    # or not.
+    #
+    # @api private
+    def mock
+      defined?(@mock) ? @mock : options[:mock]
+    end
+    alias :mock? :mock
+
+    # Returns the handled_response if it has
+    # been defined; otherwise, returns the response
+    #
+    # @return [ Object ] The result of callbacks
+    #   done on the response or the original response.
+    def handled_response
+      @handled_response || self
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/lib/typhoeus/version.rb

@@ -0,0 +1,5 @@
+module Typhoeus
+
+  # The current Typhoeus version.
+  VERSION = '1.4.1'
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/lib/typhoeus.rb

@@ -0,0 +1,143 @@
+require 'digest/sha2'
+require 'ethon'
+
+require 'typhoeus/config'
+require 'typhoeus/easy_factory'
+require 'typhoeus/errors'
+require 'typhoeus/expectation'
+require 'typhoeus/hydra'
+require 'typhoeus/pool'
+require 'typhoeus/request'
+require 'typhoeus/response'
+require 'typhoeus/version'
+
+# If we are using any Rack-based application, then we need the Typhoeus rack
+# middleware to ensure our app is running properly.
+if defined?(Rack)
+  require "rack/typhoeus"
+end
+
+# If the Redis gem is available, load the redis cache adapter
+if defined?(Redis)
+  require "typhoeus/cache/redis"
+end
+
+# If the Dalli gem is available, load the Dalli cache adapter
+if defined?(Dalli)
+  require "typhoeus/cache/dalli"
+end
+
+# If we are using Rails, load the Rails cache adapter
+if defined?(Rails)
+  require "typhoeus/cache/rails"
+end
+
+# If we are using Rails, then we will include the Typhoeus railtie.
+# if defined?(Rails)
+#   require "typhoeus/railtie"
+# end
+
+# Typhoeus is a HTTP client library based on Ethon which
+# wraps libcurl. Sitting on top of libcurl makes Typhoeus
+# very reliable and fast.
+#
+# There are some gems using Typhoeus like
+# {https://github.com/myronmarston/vcr VCR},
+# {https://github.com/bblimke/webmock WebMock} or
+# {https://github.com/technoweenie/faraday Faraday}. VCR
+# and WebMock provide their own adapter whereas
+# Faraday relies on {Faraday::Adapter::Typhoeus}
+# since Typhoeus version 0.5.
+#
+# @example (see Typhoeus::Request)
+# @example (see Typhoeus::Hydra)
+#
+# @see Typhoeus::Request
+# @see Typhoeus::Hydra
+# @see Faraday::Adapter::Typhoeus
+#
+# @since 0.5.0
+module Typhoeus
+  extend Request::Actions
+  extend Request::Callbacks::Types
+
+  # The default Typhoeus user agent.
+  USER_AGENT = "Typhoeus - https://github.com/typhoeus/typhoeus"
+
+  # Set the Typhoeus configuration options by passing a block.
+  #
+  # @example (see Typhoeus::Config)
+  #
+  # @yield [ Typhoeus::Config ]
+  #
+  # @return [ Typhoeus::Config ] The configuration.
+  #
+  # @see Typhoeus::Config
+  def self.configure
+    yield Config
+  end
+
+  # Stub out a specific request.
+  #
+  # @example (see Typhoeus::Expectation)
+  #
+  # @param [ String ] base_url The url to stub out.
+  # @param [ Hash ] options The options to stub out.
+  #
+  # @return [ Typhoeus::Expectation ] The expecatation.
+  #
+  # @see Typhoeus::Expectation
+  def self.stub(base_url, options = {}, &block)
+    expectation = Expectation.all.find{ |e| e.base_url == base_url && e.options == options }
+    if expectation.nil?
+      expectation = Expectation.new(base_url, options)
+      Expectation.all << expectation
+    end
+
+    expectation.and_return(&block) unless block.nil?
+    expectation
+  end
+
+  # Add before callbacks.
+  #
+  # @example Add before callback.
+  #   Typhoeus.before { |request| p request.base_url }
+  #
+  # @param [ Block ] block The callback.
+  #
+  # @yield [ Typhoeus::Request ]
+  #
+  # @return [ Array<Block> ] All before blocks.
+  def self.before(&block)
+    @before ||= []
+    @before << block if block_given?
+    @before
+  end
+
+  # Execute given block as if block connection is turned off.
+  # The old block connection state is restored afterwards.
+  #
+  # @example Make a real request, no matter if it's blocked.
+  #   Typhoeus::Config.block_connection = true
+  #   Typhoeus.get("www.example.com").code
+  #   #=> raise Typhoeus::Errors::NoStub
+  #
+  #   Typhoeus.with_connection do
+  #     Typhoeus.get("www.example.com").code
+  #     #=> :ok
+  #   end
+  #
+  # @yield Yields control to the block after disabling block_connection.
+  #        Afterwards, the block_connection is set to its original
+  #        value.
+  # @return [ Object ] Returns the return value of the block.
+  #
+  # @see Typhoeus::Config.block_connection
+  def self.with_connection
+    old = Config.block_connection
+    Config.block_connection = false
+    result = yield if block_given?
+    Config.block_connection = old
+    result
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/perf/profile.rb

@@ -0,0 +1,14 @@
+require 'typhoeus'
+require 'ruby-prof'
+
+calls = 50
+base_url = "http://127.0.0.1:3000/"
+
+RubyProf.start
+calls.times do |i|
+  Typhoeus::Request.get(base_url+i.to_s)
+end
+result = RubyProf.stop
+
+printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT)

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/perf/vs_nethttp.rb

@@ -0,0 +1,64 @@
+require 'typhoeus'
+require 'net/http'
+require 'open-uri'
+require 'benchmark'
+
+URL = "http://localhost:300"
+hydra = Typhoeus::Hydra.new(max_concurrency: 3)
+
+if defined? require_relative
+  require_relative '../spec/support/localhost_server.rb'
+  require_relative '../spec/support/server.rb'
+else
+  require '../spec/support/localhost_server.rb'
+  require '../spec/support/server.rb'
+end
+LocalhostServer.new(TESTSERVER.new, 3000)
+LocalhostServer.new(TESTSERVER.new, 3001)
+LocalhostServer.new(TESTSERVER.new, 3002)
+
+def url_for(i)
+  "#{URL}#{i%3}/"
+end
+
+Benchmark.bm do |bm|
+
+  [1000].each do |calls|
+    puts "[ #{calls} requests ]"
+
+    bm.report("net/http        ") do
+      calls.times do |i|
+        uri = URI.parse(url_for(i))
+        Net::HTTP.get_response(uri)
+      end
+    end
+
+    bm.report("open            ") do
+      calls.times do |i|
+        open(url_for(i))
+      end
+    end
+
+    bm.report("request         ") do
+      calls.times do |i|
+        Typhoeus::Request.get(url_for(i))
+      end
+    end
+
+    bm.report("hydra           ") do
+      calls.times do |i|
+        hydra.queue(Typhoeus::Request.new(url_for(i)))
+      end
+      hydra.run
+    end
+
+    bm.report("hydra memoize   ") do
+      Typhoeus::Config.memoize = true
+      calls.times do |i|
+        hydra.queue(Typhoeus::Request.new(url_for(i)))
+      end
+      hydra.run
+      Typhoeus::Config.memoize = false
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/rack/typhoeus/middleware/params_decoder/helper_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+require "rack/typhoeus"
+
+describe "Rack::Typhoeus::Middleware::ParamsDecoder::Helper" do
+
+  let(:klass) do
+    Class.new do
+      include Rack::Typhoeus::Middleware::ParamsDecoder::Helper
+    end.new
+  end
+
+  describe "#decode" do
+    let(:decoded) { klass.decode(params) }
+    let(:params) { { :array => {'0' => :a, '1' => :b } } }
+
+    it "decodes" do
+      expect(decoded[:array]).to match_array([:a, :b])
+    end
+
+    it "doesn't modify" do
+      expect(decoded).to_not be(params)
+    end
+  end
+
+  describe "#decode!" do
+    let(:decoded) { klass.decode!(params) }
+
+    context "when hash" do
+      context "when encoded" do
+        context "when simple" do
+          let(:params) { { :array => {'0' => :a, '1' => :b } } }
+
+          it "decodes" do
+            expect(decoded[:array]).to match_array([:a, :b])
+          end
+
+          it "modifies" do
+            expect(decoded).to eq(params)
+          end
+        end
+
+        context "when longer and more complex" do
+          let(:params) do
+            {
+              :ids => {
+                "0"  => "407304",
+                "1"  => "407305",
+                "2"  => "407306",
+                "3"  => "407307",
+                "4"  => "407308",
+                "5"  => "407309",
+                "6"  => "407310",
+                "7"  => "407311",
+                "8"  => "407312",
+                "9"  => "407313",
+                "10" => "327012"
+              }
+            }
+          end
+
+          it "decodes ensuring arrays maintain their original order" do
+            expect(decoded[:ids]).to eq(["407304", "407305", "407306", "407307", "407308", "407309", "407310", "407311", "407312", "407313", "327012"])
+          end
+        end
+
+        context "when nested" do
+          let(:params) do
+            { :array => { '0' => 0, '1' => { '0' => 'sub0', '1' => 'sub1' } } }
+          end
+
+          it "decodes" do
+            expect(decoded[:array]).to include(0)
+            expect(decoded[:array].find{|e| e.is_a?(Array)}).to(
+              match_array(['sub0', 'sub1'])
+            )
+          end
+
+          it "modifies" do
+            expect(decoded).to eq(params)
+          end
+        end
+      end
+
+      context "when not encoded" do
+        let(:params) { {:a => :a} }
+
+        it "doesn't modify" do
+          expect(decoded).to be(params)
+        end
+      end
+    end
+
+    context "when no hash" do
+      let(:params) { "a" }
+
+      it "returns self" do
+        expect(decoded).to be(params)
+      end
+    end
+  end
+
+  describe "#encoded?" do
+    let(:encoded) { klass.send(:encoded?, params) }
+
+    context "when there is only one key" do
+      context "and its 0" do
+        let(:params){ {'0' => 1} }
+        it 'returns true' do
+          expect(encoded).to be_truthy
+        end
+      end
+      context "and its not 0" do
+        let(:params){ {'some-key' => 1}}
+        it 'returns false' do
+          expect(encoded).to be_falsey
+        end
+      end
+    end
+
+    context "when keys are ascending numbers starting with zero" do
+      let(:params) { Hash[12.times.map {|i| [i, (i+65).chr]}] }
+
+      it "returns true" do
+        expect(encoded).to be_truthy
+      end
+    end
+
+    context "when keys are not ascending numbers starting with zero" do
+      let(:params) { {:a => 1} }
+
+      it "returns false" do
+        expect(encoded).to be_falsey
+      end
+    end
+  end
+
+  describe "#convert" do
+    let(:converted) { klass.send(:convert, params) }
+
+    context "when encoded" do
+      let(:params) { {'0' => :a, '1' => :b} }
+
+      it "returns values" do
+        expect(converted).to match_array([:a, :b])
+      end
+    end
+
+    context "when not encoded" do
+      let(:params) { {:a => :a} }
+
+      it "returns unmodified" do
+        expect(converted).to be(params)
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/rack/typhoeus/middleware/params_decoder_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Rack::Typhoeus::Middleware::ParamsDecoder" do
+
+  before(:all) do
+    require "rack/typhoeus"
+  end
+
+  let(:app) do
+    double
+  end
+
+  let(:env) do
+    double
+  end
+
+  let(:klass) do
+    Rack::Typhoeus::Middleware::ParamsDecoder
+  end
+
+  describe "#call" do
+  end
+
+  context "when requesting" do
+    let(:response) { Typhoeus.get("localhost:3001", :params => {:x => [:a]}) }
+
+    it "transforms parameters" do
+      expect(response.body).to include("query_hash\":{\"x\":[\"a\"]}")
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "bundler"
+Bundler.setup
+require "typhoeus"
+require "rspec"
+
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  config.order = :rand
+
+  config.before(:suite) do
+    LocalhostServer.new(TESTSERVER.new, 3001)
+  end
+
+  config.after do
+    Typhoeus::Pool.clear
+    Typhoeus::Expectation.clear
+    Typhoeus.before.clear
+    Typhoeus.on_complete.clear
+    Typhoeus.on_success.clear
+    Typhoeus.on_failure.clear
+    Typhoeus::Config.verbose = false
+    Typhoeus::Config.block_connection = false
+    Typhoeus::Config.memoize = false
+  end
+end