ory-client 0.0.1.alpha41 → 0.0.1.alpha45

data/vendor/bundle/ruby/2.5.0/gems/rainbow-3.0.0/spec/unit/color_spec.rb

@@ -1,296 +0,0 @@
-require 'spec_helper'
-require 'rainbow/color'
-
-module Rainbow
-  RSpec.describe Color do
-    describe '.build' do
-      subject { described_class.build(ground, values) }
-
-      let(:ground) { :foreground }
-
-      context "when single fixnum given" do
-        let(:values) { [1] }
-
-        it { should be_instance_of(Color::Indexed) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.num).to eq(1) }
-      end
-
-      context "when single ansi symbol given" do
-        let(:values) { [:red] }
-
-        it { should be_instance_of(Color::Named) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.num).to eq(1) }
-      end
-
-      context "when single x11 symbol given" do
-        let(:values) { [:midnightblue] }
-
-        it { should be_instance_of(Color::X11Named) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.r).to eq(25) }
-        specify { expect(subject.g).to eq(25) }
-        specify { expect(subject.b).to eq(112) }
-      end
-
-      context "when single string given" do
-        let(:values) { ['#deadcc'] }
-
-        it { should be_instance_of(Color::RGB) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.r).to eq(222) }
-        specify { expect(subject.g).to eq(173) }
-        specify { expect(subject.b).to eq(204) }
-      end
-
-      context "when 2 elements" do
-        let(:values) { [1, 2] }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context "when 3 elements given" do
-        let(:values) { [1, 2, 3] }
-
-        it { should be_instance_of(Color::RGB) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.r).to eq(1) }
-        specify { expect(subject.g).to eq(2) }
-        specify { expect(subject.b).to eq(3) }
-      end
-
-      context "when 4 elements" do
-        let(:values) { [1, 2, 3, 4] }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-  RSpec.describe Color::Indexed do
-    let(:color) { described_class.new(ground, 5) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      context "when ground is :foreground" do
-        let(:ground) { :foreground }
-
-        it { should eq([35]) }
-      end
-
-      context "when ground is :background" do
-        let(:ground) { :background }
-
-        it { should eq([45]) }
-      end
-    end
-  end
-
-  RSpec.describe Color::Named do
-    let(:color) { described_class.new(ground, name) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      context "when ground is :foreground" do
-        let(:ground) { :foreground }
-
-        context "and name is :black" do
-          let(:name) { :black }
-
-          it { should eq([30]) }
-        end
-
-        context "and name is :red" do
-          let(:name) { :red }
-
-          it { should eq([31]) }
-        end
-
-        context "and name is :green" do
-          let(:name) { :green }
-
-          it { should eq([32]) }
-        end
-
-        context "and name is :yellow" do
-          let(:name) { :yellow }
-
-          it { should eq([33]) }
-        end
-
-        context "and name is :blue" do
-          let(:name) { :blue }
-
-          it { should eq([34]) }
-        end
-
-        context "and name is :magenta" do
-          let(:name) { :magenta }
-
-          it { should eq([35]) }
-        end
-
-        context "and name is :cyan" do
-          let(:name) { :cyan }
-
-          it { should eq([36]) }
-        end
-
-        context "and name is :white" do
-          let(:name) { :white }
-
-          it { should eq([37]) }
-        end
-
-        context "and name is invalid" do
-          let(:name) { :foo }
-
-          it 'raises ArgumentError' do
-            expect { subject }.to raise_error(ArgumentError)
-          end
-        end
-      end
-
-      context "when ground is :background" do
-        let(:ground) { :background }
-
-        context "and name is :black" do
-          let(:name) { :black }
-
-          it { should eq([40]) }
-        end
-
-        context "and name is :red" do
-          let(:name) { :red }
-
-          it { should eq([41]) }
-        end
-
-        context "and name is :green" do
-          let(:name) { :green }
-
-          it { should eq([42]) }
-        end
-
-        context "and name is :yellow" do
-          let(:name) { :yellow }
-
-          it { should eq([43]) }
-        end
-
-        context "and name is :blue" do
-          let(:name) { :blue }
-
-          it { should eq([44]) }
-        end
-
-        context "and name is :magenta" do
-          let(:name) { :magenta }
-
-          it { should eq([45]) }
-        end
-
-        context "and name is :cyan" do
-          let(:name) { :cyan }
-
-          it { should eq([46]) }
-        end
-
-        context "and name is :white" do
-          let(:name) { :white }
-
-          it { should eq([47]) }
-        end
-
-        context "and name is invalid" do
-          let(:name) { :foo }
-
-          it 'raises ArgumentError' do
-            expect { subject }.to raise_error(ArgumentError)
-          end
-        end
-      end
-    end
-  end
-
-  RSpec.describe Color::RGB do
-    let(:color) { described_class.new(ground, r, g, b) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      let(:ground) { :foreground }
-      let(:r) { 0 }
-      let(:g) { 128 }
-      let(:b) { 255 }
-
-      context "when ground is :foreground" do
-        let(:ground) { :foreground }
-
-        it { should eq([38, 5, 39]) }
-      end
-
-      context "when ground is :background" do
-        let(:ground) { :background }
-
-        it { should eq([48, 5, 39]) }
-      end
-
-      context "when a component is lower than 0" do
-        let(:r) { -1 }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context "when a component is greater than 255" do
-        let(:b) { 256 }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-  RSpec.describe Color::X11Named do
-    let(:color) { described_class.new(ground, name) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      context "when ground is :foreground" do
-        let(:name) { :midnightblue }
-        let(:ground) { :foreground }
-        it { should eq([38, 5, 18]) }
-      end
-
-      context "when ground is :background" do
-        let(:name) { :midnightblue }
-        let(:ground) { :background }
-        it { should eq([48, 5, 18]) }
-      end
-
-      context "when name is invalid" do
-        let(:name) { :foo }
-        let(:ground) { :background }
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rainbow-3.0.0/spec/unit/null_presenter_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-require 'rainbow/null_presenter'
-
-module Rainbow
-  RSpec.describe NullPresenter do
-    let(:presenter) { described_class.new('hello') }
-
-    shared_examples_for "rainbow null string method" do
-      it "doesn't wrap the text with any sgr sequence" do
-        expect(subject).to eq('hello')
-      end
-
-      it "returns an instance of Rainbow::NullPresenter" do
-        expect(subject).to be_kind_of(Rainbow::NullPresenter)
-      end
-    end
-
-    describe '#color' do
-      subject { presenter.color(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#foreground' do
-      subject { presenter.foreground(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#fg' do
-      subject { presenter.fg(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#background' do
-      subject { presenter.background(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#bg' do
-      subject { presenter.bg(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#reset' do
-      subject { presenter.reset }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#bright' do
-      subject { presenter.bright }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#bold' do
-      subject { presenter.bold }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#faint' do
-      subject { presenter.faint }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#dark' do
-      subject { presenter.dark }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#italic' do
-      subject { presenter.italic }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#underline' do
-      subject { presenter.underline }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#blink' do
-      subject { presenter.blink }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#inverse' do
-      subject { presenter.inverse }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#hide' do
-      subject { presenter.hide }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    it_behaves_like "presenter with shortcut color methods"
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rainbow-3.0.0/spec/unit/presenter_spec.rb

@@ -1,199 +0,0 @@
-require 'spec_helper'
-require 'rainbow/presenter'
-
-module Rainbow
-  RSpec.describe Presenter do
-    let(:presenter) { described_class.new('hello') }
-
-    shared_examples_for "rainbow string method" do
-      it "wraps the text with a sgr sequence" do
-        expect(subject).to eq('[hello]')
-      end
-
-      it "returns an instance of Rainbow::Presenter" do
-        expect(subject).to be_kind_of(Rainbow::Presenter)
-      end
-    end
-
-    shared_examples_for "text color method" do
-      let(:color) { double('color', codes: [1, 2]) }
-
-      before do
-        allow(Color).to receive(:build)
-          .with(:foreground, [:arg1, 'arg2']) { color }
-      end
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with color codes' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr)
-          .with('hello', [1, 2])
-      end
-    end
-
-    shared_examples_for "text background method" do
-      let(:color) { double('color', codes: [1, 2]) }
-
-      before do
-        allow(Color).to receive(:build)
-          .with(:background, [:arg1, 'arg2']) { color }
-      end
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with color codes' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr)
-          .with('hello', [1, 2])
-      end
-    end
-
-    before do
-      allow(StringUtils).to receive(:wrap_with_sgr) { '[hello]' }
-    end
-
-    describe '#color' do
-      subject { presenter.color(:arg1, 'arg2') }
-
-      it_behaves_like "text color method"
-    end
-
-    describe '#foreground' do
-      subject { presenter.foreground(:arg1, 'arg2') }
-
-      it_behaves_like "text color method"
-    end
-
-    describe '#fg' do
-      subject { presenter.fg(:arg1, 'arg2') }
-
-      it_behaves_like "text color method"
-    end
-
-    describe '#background' do
-      subject { presenter.background(:arg1, 'arg2') }
-
-      it_behaves_like "text background method"
-    end
-
-    describe '#bg' do
-      subject { presenter.bg(:arg1, 'arg2') }
-
-      it_behaves_like "text background method"
-    end
-
-    describe '#reset' do
-      subject { presenter.reset }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 0 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [0])
-      end
-    end
-
-    describe '#bright' do
-      subject { presenter.bright }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 1 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [1])
-      end
-    end
-
-    describe '#bold' do
-      subject { presenter.bold }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 1 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [1])
-      end
-    end
-
-    describe '#faint' do
-      subject { presenter.faint }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 2 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [2])
-      end
-    end
-
-    describe '#dark' do
-      subject { presenter.dark }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 2 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [2])
-      end
-    end
-
-    describe '#italic' do
-      subject { presenter.italic }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 3 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr)
-          .with('hello', [3])
-      end
-    end
-
-    describe '#underline' do
-      subject { presenter.underline }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 4 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [4])
-      end
-    end
-
-    describe '#blink' do
-      subject { presenter.blink }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 5 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [5])
-      end
-    end
-
-    describe '#inverse' do
-      subject { presenter.inverse }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 7 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [7])
-      end
-    end
-
-    describe '#hide' do
-      subject { presenter.hide }
-
-      it_behaves_like "rainbow string method"
-
-      it 'wraps with 8 code' do
-        subject
-        expect(StringUtils).to have_received(:wrap_with_sgr).with('hello', [8])
-      end
-    end
-
-    it_behaves_like "presenter with shortcut color methods"
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rainbow-3.0.0/spec/unit/string_utils_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-require 'rainbow/string_utils'
-
-module Rainbow
-  RSpec.describe StringUtils do
-    describe '.wrap_with_sgr' do
-      subject { described_class.wrap_with_sgr(string, codes) }
-
-      let(:string) { 'hello' }
-      let(:codes) { [1] }
-
-      it "doesn't mutate original string" do
-        string.freeze
-        expect(subject).to eq("\e[1mhello\e[0m")
-        expect(string).to eq('hello')
-      end
-
-      context "when subclass of String class given" do
-        class Stringgg < ::String; end
-
-        let(:string) { Stringgg.new('hello') }
-
-        it { should eq("\e[1mhello\e[0m") }
-      end
-
-      context "when no codes given" do
-        let(:codes) { [] }
-
-        it "doesn't wrap the given string with any sgr sequence" do
-          expect(subject).to eq("hello")
-        end
-      end
-
-      context "when single code given" do
-        let(:codes) { [1] }
-
-        it "wraps the given string with sgr sequence for given codes" do
-          expect(subject).to eq("\e[1mhello\e[0m")
-        end
-      end
-
-      context "when multiple codes given" do
-        let(:codes) { [1, 2] }
-
-        it "wraps the given string with sgr sequence for given codes" do
-          expect(subject).to eq("\e[1;2mhello\e[0m")
-        end
-      end
-
-      context "when wrapping an already wrapped string" do
-        let(:string) { "\e[1;2mhello\e[0m" }
-        let(:codes) { [3, 4] }
-
-        it "wraps the given string with sgr sequence for given codes" do
-          expect(subject).to eq("\e[1;2m\e[3;4mhello\e[0m")
-        end
-      end
-    end
-
-    describe '.uncolor' do
-      subject { described_class.uncolor(string) }
-
-      context "when string with ansi color escape is passed" do
-        let(:string) do
-          rainbow = Rainbow.new
-          rainbow.enabled = true
-          rainbow.wrap('hello').
-            foreground(:red).
-            bright.
-            bold.
-            italic.
-            background('#ff8040').
-            underline.
-            color(:blue).
-            blink.
-            inverse.
-            hide
-        end
-
-        it "removes ansi color codes" do
-          expect(subject).to eq 'hello'
-        end
-      end
-
-      context "when string with scroll down ansi escape is passed" do
-        let(:string) { "\e[1Thello" }
-
-        it "does not remove ansi scroll down escape" do
-          expect(subject).to eq "\e[1Thello"
-        end
-      end
-    end
-  end
-end