RubyGems - ory-client - Versions diffs - 0.2.0.alpha60 → 1.0.0 - Mend

ory-client 0.2.0.alpha60 → 1.0.0

Files changed (1277) hide show

data/vendor/bundle/ruby/2.5.0/gems/ethon-0.15.0/spec/ethon/easy/operations_spec.rb DELETED Viewed

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-describe Ethon::Easy::Operations do
-  let(:easy) { Ethon::Easy.new }
-  describe "#handle" do
-    it "returns a pointer" do
-      expect(easy.handle).to be_a(FFI::Pointer)
-    end
-  end
-  describe "#perform" do
-    let(:url) { nil }
-    let(:timeout) { nil }
-    let(:connect_timeout) { nil }
-    let(:follow_location) { nil }
-    let(:max_redirs) { nil }
-    let(:user_pwd) { nil }
-    let(:http_auth) { nil }
-    let(:headers) { nil }
-    let(:protocols) { nil }
-    let(:redir_protocols) { nil }
-    let(:username) { nil }
-    let(:password) { nil }
-    before do
-      Ethon.logger.level = Logger::DEBUG
-      easy.url = url
-      easy.timeout = timeout
-      easy.connecttimeout = connect_timeout
-      easy.followlocation = follow_location
-      easy.maxredirs = max_redirs
-      easy.httpauth = http_auth
-      easy.headers = headers
-      easy.protocols = protocols
-      easy.redir_protocols = redir_protocols
-      if user_pwd
-        easy.userpwd = user_pwd
-      else
-        easy.username = username
-        easy.password = password
-      end
-      easy.perform
-    end
-    it "calls Curl.easy_perform" do
-      expect(Ethon::Curl).to receive(:easy_perform)
-      easy.perform
-    end
-    it "calls Curl.easy_cleanup" do
-      expect_any_instance_of(FFI::AutoPointer).to receive(:free)
-      easy.cleanup
-    end
-    it "logs" do
-      expect(Ethon.logger).to receive(:debug)
-      easy.perform
-    end
-    it "doesn't log after completing because completing could reset" do
-      easy.on_complete{ expect(Ethon.logger).to receive(:debug).never }
-      easy.perform
-    end
-    context "when url" do
-      let(:url) { "http://localhost:3001/" }
-      it "returns ok" do
-        expect(easy.return_code).to eq(:ok)
-      end
-      it "sets response body" do
-        expect(easy.response_body).to be
-      end
-      it "sets response headers" do
-        expect(easy.response_headers).to be
-      end
-      context "when request timed out" do
-        let(:url) { "http://localhost:3001/?delay=1" }
-        let(:timeout) { 1 }
-        it "returns operation_timedout" do
-          expect(easy.return_code).to eq(:operation_timedout)
-        end
-      end
-      context "when connection timed out" do
-        let(:url) { "http://localhost:3009" }
-        let(:connect_timeout) { 1 }
-        it "returns couldnt_connect" do
-          expect(easy.return_code).to eq(:couldnt_connect)
-        end
-      end
-      context "when no follow location" do
-        let(:url) { "http://localhost:3001/redirect" }
-        let(:follow_location) { false }
-        it "doesn't follow" do
-          expect(easy.response_code).to eq(302)
-        end
-      end
-      context "when follow location" do
-        let(:url) { "http://localhost:3001/redirect" }
-        let(:follow_location) { true }
-        it "follows" do
-          expect(easy.response_code).to eq(200)
-        end
-        context "when infinite redirect loop" do
-          let(:url) { "http://localhost:3001/bad_redirect" }
-          let(:max_redirs) { 5 }
-          context "when max redirect set" do
-            it "follows only x times" do
-              expect(easy.response_code).to eq(302)
-            end
-          end
-        end
-      end
-      context "when user agent" do
-        let(:headers) { { 'User-Agent' => 'Ethon' } }
-        it "sets" do
-          expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon"')
-        end
-      end
-    end
-    context "when auth url" do
-      before { easy.url = url }
-      context "when basic auth" do
-        let(:url) { "http://localhost:3001/auth_basic/username/password" }
-        context "when no user_pwd" do
-          it "returns 401" do
-            expect(easy.response_code).to eq(401)
-          end
-        end
-        context "when invalid user_pwd" do
-          let(:user_pwd) { "invalid:invalid" }
-          it "returns 401" do
-            expect(easy.response_code).to eq(401)
-          end
-        end
-        context "when valid user_pwd" do
-          let(:user_pwd) { "username:password" }
-          it "returns 200" do
-            expect(easy.response_code).to eq(200)
-          end
-        end
-        context "when user and password" do
-          let(:username) { "username" }
-          let(:password) { "password" }
-          it "returns 200" do
-            expect(easy.response_code).to eq(200)
-          end
-        end
-      end
-      context "when ntlm" do
-        let(:url) { "http://localhost:3001/auth_ntlm" }
-        let(:http_auth) { :ntlm }
-        context "when no user_pwd" do
-          it "returns 401" do
-            expect(easy.response_code).to eq(401)
-          end
-        end
-        context "when user_pwd" do
-          let(:user_pwd) { "username:password" }
-          it "returns 200" do
-            expect(easy.response_code).to eq(200)
-          end
-        end
-      end
-    end
-    context "when protocols" do
-      context "when asking for a allowed url" do
-        let(:url) { "http://localhost:3001" }
-        let(:protocols) { :http }
-        it "returns ok" do
-          expect(easy.return_code).to be(:ok)
-        end
-      end
-      context "when asking for a not allowed url" do
-        let(:url) { "http://localhost:3001" }
-        let(:protocols) { :https }
-        it "returns unsupported_protocol" do
-          expect(easy.return_code).to be(:unsupported_protocol)
-        end
-      end
-    end
-    context "when multiple protocols" do
-      context "when asking for a allowed url" do
-        let(:protocols) { [:http, :https] }
-        context "when http" do
-          let(:url) { "http://localhost:3001" }
-          it "returns ok for http" do
-            expect(easy.return_code).to be(:ok)
-          end
-        end
-        context "when https" do
-          let(:url) { "https://localhost:3001" }
-          it "returns ssl_connect_error for https" do
-            expect(easy.return_code).to be(:ssl_connect_error)
-          end
-        end
-      end
-      context "when asking for a not allowed url" do
-        let(:url) { "ssh://localhost" }
-        let(:protocols) { [:https, :http] }
-        it "returns unsupported_protocol" do
-          expect(easy.return_code).to be(:unsupported_protocol)
-        end
-      end
-    end
-    context "when redir_protocols" do
-      context "when redirecting to a not allowed url" do
-        let(:url) { "http://localhost:3001/redirect" }
-        let(:follow_location) { true }
-        let(:redir_protocols) { :https }
-        it "returns unsupported_protocol" do
-          expect(easy.return_code).to be(:unsupported_protocol)
-        end
-      end
-    end
-    context "when no url" do
-      it "returns url_malformat" do
-        expect(easy.perform).to eq(:url_malformat)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/parser-3.1.2.1/lib/parser/ast/processor.rb DELETED Viewed

@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-module Parser
-  module AST
-    ##
-    # @api public
-    #
-    class Processor < ::AST::Processor
-      def process_regular_node(node)
-        node.updated(nil, process_all(node))
-      end
-      alias on_dstr     process_regular_node
-      alias on_dsym     process_regular_node
-      alias on_regexp   process_regular_node
-      alias on_xstr     process_regular_node
-      alias on_splat    process_regular_node
-      alias on_kwsplat  process_regular_node
-      alias on_array    process_regular_node
-      alias on_pair     process_regular_node
-      alias on_hash     process_regular_node
-      alias on_kwargs   process_regular_node
-      alias on_irange   process_regular_node
-      alias on_erange   process_regular_node
-      def on_var(node)
-        node
-      end
-      # @private
-      def process_variable_node(node)
-        on_var(node)
-      end
-      alias on_lvar     process_variable_node
-      alias on_ivar     process_variable_node
-      alias on_gvar     process_variable_node
-      alias on_cvar     process_variable_node
-      alias on_back_ref process_variable_node
-      alias on_nth_ref  process_variable_node
-      def on_vasgn(node)
-        name, value_node = *node
-        if !value_node.nil?
-          node.updated(nil, [
-            name, process(value_node)
-          ])
-        else
-          node
-        end
-      end
-      # @private
-      def process_var_asgn_node(node)
-        on_vasgn(node)
-      end
-      alias on_lvasgn   process_var_asgn_node
-      alias on_ivasgn   process_var_asgn_node
-      alias on_gvasgn   process_var_asgn_node
-      alias on_cvasgn   process_var_asgn_node
-      alias on_and_asgn process_regular_node
-      alias on_or_asgn  process_regular_node
-      def on_op_asgn(node)
-        var_node, method_name, value_node = *node
-        node.updated(nil, [
-          process(var_node), method_name, process(value_node)
-        ])
-      end
-      alias on_mlhs     process_regular_node
-      alias on_masgn    process_regular_node
-      def on_const(node)
-        scope_node, name = *node
-        node.updated(nil, [
-          process(scope_node), name
-        ])
-      end
-      def on_casgn(node)
-        scope_node, name, value_node = *node
-        if !value_node.nil?
-          node.updated(nil, [
-            process(scope_node), name, process(value_node)
-          ])
-        else
-          node.updated(nil, [
-            process(scope_node), name
-          ])
-        end
-      end
-      alias on_args     process_regular_node
-      def on_argument(node)
-        arg_name, value_node = *node
-        if !value_node.nil?
-          node.updated(nil, [
-            arg_name, process(value_node)
-          ])
-        else
-          node
-        end
-      end
-      # @private
-      def process_argument_node(node)
-        on_argument(node)
-      end
-      alias on_arg            process_argument_node
-      alias on_optarg         process_argument_node
-      alias on_restarg        process_argument_node
-      alias on_blockarg       process_argument_node
-      alias on_shadowarg      process_argument_node
-      alias on_kwarg          process_argument_node
-      alias on_kwoptarg       process_argument_node
-      alias on_kwrestarg      process_argument_node
-      alias on_forward_arg    process_argument_node
-      def on_procarg0(node)
-        if node.children[0].is_a?(Symbol)
-          # This branch gets executed when the builder
-          # is not configured to emit and 'arg' inside 'procarg0', i.e. when
-          #   Parser::Builders::Default.emit_arg_inside_procarg0
-          # is set to false.
-          #
-          # If this flag is set to true this branch is unreachable.
-          # s(:procarg0, :a)
-          on_argument(node)
-        else
-          # s(:procarg0, s(:arg, :a), s(:arg, :b))
-          process_regular_node(node)
-        end
-      end
-      alias on_arg_expr       process_regular_node
-      alias on_restarg_expr   process_regular_node
-      alias on_blockarg_expr  process_regular_node
-      alias on_block_pass     process_regular_node
-      alias on_module         process_regular_node
-      alias on_class          process_regular_node
-      alias on_sclass         process_regular_node
-      def on_def(node)
-        name, args_node, body_node = *node
-        node.updated(nil, [
-          name,
-          process(args_node), process(body_node)
-        ])
-      end
-      def on_defs(node)
-        definee_node, name, args_node, body_node = *node
-        node.updated(nil, [
-          process(definee_node), name,
-          process(args_node), process(body_node)
-        ])
-      end
-      alias on_undef    process_regular_node
-      alias on_alias    process_regular_node
-      def on_send(node)
-        receiver_node, method_name, *arg_nodes = *node
-        receiver_node = process(receiver_node) if receiver_node
-        node.updated(nil, [
-          receiver_node, method_name, *process_all(arg_nodes)
-        ])
-      end
-      alias on_csend on_send
-      alias on_index     process_regular_node
-      alias on_indexasgn process_regular_node
-      alias on_block    process_regular_node
-      alias on_lambda   process_regular_node
-      def on_numblock(node)
-        method_call, max_numparam, body = *node
-        node.updated(nil, [
-          process(method_call), max_numparam, process(body)
-        ])
-      end
-      alias on_while      process_regular_node
-      alias on_while_post process_regular_node
-      alias on_until      process_regular_node
-      alias on_until_post process_regular_node
-      alias on_for        process_regular_node
-      alias on_return   process_regular_node
-      alias on_break    process_regular_node
-      alias on_next     process_regular_node
-      alias on_redo     process_regular_node
-      alias on_retry    process_regular_node
-      alias on_super    process_regular_node
-      alias on_yield    process_regular_node
-      alias on_defined? process_regular_node
-      alias on_not      process_regular_node
-      alias on_and      process_regular_node
-      alias on_or       process_regular_node
-      alias on_if       process_regular_node
-      alias on_when     process_regular_node
-      alias on_case     process_regular_node
-      alias on_iflipflop process_regular_node
-      alias on_eflipflop process_regular_node
-      alias on_match_current_line process_regular_node
-      alias on_match_with_lvasgn  process_regular_node
-      alias on_resbody  process_regular_node
-      alias on_rescue   process_regular_node
-      alias on_ensure   process_regular_node
-      alias on_begin    process_regular_node
-      alias on_kwbegin  process_regular_node
-      alias on_preexe   process_regular_node
-      alias on_postexe  process_regular_node
-      alias on_case_match              process_regular_node
-      alias on_in_match                process_regular_node
-      alias on_match_pattern           process_regular_node
-      alias on_match_pattern_p         process_regular_node
-      alias on_in_pattern              process_regular_node
-      alias on_if_guard                process_regular_node
-      alias on_unless_guard            process_regular_node
-      alias on_match_var               process_variable_node
-      alias on_match_rest              process_regular_node
-      alias on_pin                     process_regular_node
-      alias on_match_alt               process_regular_node
-      alias on_match_as                process_regular_node
-      alias on_array_pattern           process_regular_node
-      alias on_array_pattern_with_tail process_regular_node
-      alias on_hash_pattern            process_regular_node
-      alias on_const_pattern           process_regular_node
-      alias on_find_pattern            process_regular_node
-      # @private
-      def process_variable_node(node)
-        warn 'Parser::AST::Processor#process_variable_node is deprecated as a' \
-          ' public API and will be removed. Please use ' \
-          'Parser::AST::Processor#on_var instead.'
-        on_var(node)
-      end
-      # @private
-      def process_var_asgn_node(node)
-        warn 'Parser::AST::Processor#process_var_asgn_node is deprecated as a' \
-          ' public API and will be removed. Please use ' \
-          'Parser::AST::Processor#on_vasgn instead.'
-        on_vasgn(node)
-      end
-      # @private
-      def process_argument_node(node)
-        warn 'Parser::AST::Processor#process_argument_node is deprecated as a' \
-          ' public API and will be removed. Please use ' \
-          'Parser::AST::Processor#on_argument instead.'
-        on_argument(node)
-      end
-      def on_empty_else(node)
-        node
-      end
-    end
-  end
-end