mx-platform-ruby 0.3.0 → 0.3.1

data/vendor/bundle/ruby/2.6.0/gems/rainbow-3.0.0/spec/integration/string_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'rainbow/ext/string'
+
+RSpec.describe 'String mixin' do
+  before do
+    Rainbow.enabled = true
+  end
+
+  it 'proxies foreground to Rainbow().foreground' do
+    expect('hello'.foreground(:red)).to eq(Rainbow('hello').foreground(:red))
+  end
+
+  it 'proxies color to Rainbow().color' do
+    expect('hello'.color(:red)).to eq(Rainbow('hello').color(:red))
+  end
+
+  it 'proxies x11 color to Rainbow().color' do
+    expect('hello'.color(:midnightblue)).to eq(Rainbow('hello').color(:midnightblue))
+  end
+
+  it 'proxies colour to Rainbow().colour' do
+    expect('hello'.colour(:red)).to eq(Rainbow('hello').colour(:red))
+  end
+
+  it 'proxies background to Rainbow().background' do
+    expect('hello'.background(:red)).to eq(Rainbow('hello').background(:red))
+  end
+
+  it 'proxies bright to Rainbow().bright' do
+    expect('hello'.bright).to eq(Rainbow('hello').bright)
+  end
+
+  it 'proxies faint to Rainbow().faint' do
+    expect('hello'.faint).to eq(Rainbow('hello').faint)
+  end
+
+  it 'proxies italic to Rainbow().italic' do
+    expect('hello'.italic).to eq(Rainbow('hello').italic)
+  end
+
+  it 'proxies underline to Rainbow().underline' do
+    expect('hello'.underline).to eq(Rainbow('hello').underline)
+  end
+
+  it 'proxies blink to Rainbow().blink' do
+    expect('hello'.blink).to eq(Rainbow('hello').blink)
+  end
+
+  it 'proxies inverse to Rainbow().inverse' do
+    expect('hello'.inverse).to eq(Rainbow('hello').inverse)
+  end
+
+  it 'proxies hide to Rainbow().hide' do
+    expect('hello'.hide).to eq(Rainbow('hello').hide)
+  end
+
+  it 'proxies reset to Rainbow().reset' do
+    expect('hello'.reset).to eq(Rainbow('hello').reset)
+  end
+
+  context "when Rainbow is disabled" do
+    before do
+      Rainbow.enabled = false
+    end
+
+    it "allows chaining but doesn't wrap with escape codes" do
+      result = 'hello'
+               .foreground(:red)
+               .bright
+               .italic
+               .background('#ff8040')
+               .underline
+               .color(:blue)
+               .blink
+               .inverse
+               .hide
+
+      expect(result).to eq('hello')
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rainbow-3.0.0/spec/integration/uncolor_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'rainbow'
+
+RSpec.describe 'uncolor method' do
+
+  it 'strips ansi color escape code' do
+    expect(Rainbow.uncolor("\e[35mhello\e[0mm")).to eq 'hellom'
+  end
+
+  it 'does not strip scroll down escape code' do
+    expect(Rainbow.uncolor("\e[1Thello")).to eq "\e[1Thello"
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/rainbow-3.0.0/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+if ENV["CI"] && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby")
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |file| require file }
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+end

data/vendor/bundle/ruby/2.6.0/gems/rainbow-3.0.0/spec/support/presenter_shared_examples.rb

@@ -0,0 +1,9 @@
+RSpec.shared_examples_for "presenter with shortcut color methods" do
+  %i[black red green yellow blue magenta cyan white aqua].each do |name|
+    describe "##{name}" do
+      subject { presenter.public_send(name) }
+
+      it { should eq(presenter.color(name)) }
+    end
+  end
+end

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

@@ -0,0 +1,296 @@
+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.6.0/gems/rainbow-3.0.0/spec/unit/null_presenter_spec.rb

@@ -0,0 +1,110 @@
+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