command_kit 0.4.1 → 0.5.1

data/spec/terminal_spec.rb

@@ -1,231 +0,0 @@
-require 'spec_helper'
-require 'command_kit/terminal'
-
-require 'stringio'
-
-describe CommandKit::Terminal do
-  module TestTerminal
-    class TestCommand
-      include CommandKit::Terminal
-    end
-  end
-
-  let(:command_class) { TestTerminal::TestCommand }
-  subject { command_class.new }
-
-  describe "#terminal?" do
-    context "when stdout is connected to a TTY" do
-      subject { command_class.new(stdout: STDOUT) }
-
-      it do
-        skip "STDOUT is not a TTY" unless STDOUT.tty?
-
-        expect(subject.terminal?).to be(true)
-      end
-    end
-
-    context "when stdout is not connected to a TTY" do
-      subject { command_class.new(stdout: StringIO.new) }
-
-      it do
-        expect(subject.terminal?).to be(false)
-      end
-    end
-
-    context "when IO.console is missing" do
-      before do
-        expect(IO).to receive(:respond_to?).with(:console).and_return(false)
-      end
-
-      it do
-        expect(subject.terminal?).to be(false)
-      end
-    end
-  end
-
-  describe "#tty?" do
-    context "when stdout is connected to a TTY" do
-      subject { command_class.new(stdout: STDOUT) }
-
-      it do
-        skip "STDOUT is not a TTY" unless STDOUT.tty?
-
-        expect(subject.tty?).to be(true)
-      end
-    end
-
-    context "when stdout is not connected to a TTY" do
-      subject { command_class.new(stdout: StringIO.new) }
-
-      it do
-        expect(subject.tty?).to be(false)
-      end
-    end
-
-    context "when IO.console is missing" do
-      before do
-        expect(IO).to receive(:respond_to?).with(:console).and_return(false)
-      end
-
-      it do
-        expect(subject.tty?).to be(false)
-      end
-    end
-  end
-
-  describe "#terminal" do
-    context "when stdout is connected to a TTY" do
-      subject { command_class.new(stdout: STDOUT) }
-
-      it do
-        skip "STDOUT is not a TTY" unless STDOUT.tty?
-
-        expect(subject.terminal).to eq(IO.console)
-      end
-    end
-
-    context "when stdout is not connected to a TTY" do
-      subject { command_class.new(stdout: StringIO.new) }
-
-      it do
-        expect(subject.terminal).to eq(nil)
-      end
-    end
-
-    context "when IO.console is missing" do
-      before do
-        expect(IO).to receive(:respond_to?).with(:console).and_return(false)
-      end
-
-      it do
-        expect(subject.terminal).to be(nil)
-      end
-    end
-  end
-
-  describe "#terminal_height" do
-    context "when stdout is connected to a TTY" do
-      subject { command_class.new(stdout: STDOUT) }
-
-      it do
-        skip "STDOUT is not a TTY" unless STDOUT.tty?
-
-        expect(subject.terminal_height).to eq(STDOUT.winsize[0])
-      end
-    end
-
-    context "when stdout is not connected to a TTY" do
-      subject { command_class.new(stdout: StringIO.new) }
-
-      it "must fallback to DEFAULT_TERMINAL_HEIGHT" do
-        expect(subject.terminal_height).to eq(described_class::DEFAULT_TERMINAL_HEIGHT)
-      end
-
-      context "but the LINES env variable was set" do
-        let(:lines) { 10 }
-        let(:env)   { {'LINES' => lines.to_s} }
-
-        subject { command_class.new(stdout: StringIO.new, env: env) }
-
-        it "must fallback to the LINES environment variable" do
-          expect(subject.terminal_height).to eq(lines)
-        end
-      end
-    end
-  end
-
-  describe "#terminal_width" do
-    context "when stdout is connected to a TTY" do
-      subject { command_class.new(stdout: STDOUT) }
-
-      it do
-        skip "STDOUT is not a TTY" unless STDOUT.tty?
-
-        expect(subject.terminal_width).to eq(STDOUT.winsize[1])
-      end
-    end
-
-    context "when stdout is not connected to a TTY" do
-      subject { command_class.new(stdout: StringIO.new) }
-
-      it "must fallback to DEFAULT_TERMINAL_WIDTH" do
-        expect(subject.terminal_width).to eq(described_class::DEFAULT_TERMINAL_WIDTH)
-      end
-
-      context "but the COLUMNS env variable was set" do
-        let(:columns) { 50 }
-        let(:env)     { {'COLUMNS' => columns.to_s} }
-
-        subject { command_class.new(stdout: StringIO.new, env: env) }
-
-        it "must fallback to the COLUMNS environment variable" do
-          expect(subject.terminal_width).to eq(columns)
-        end
-      end
-    end
-  end
-
-  describe "#terminal_size" do
-    context "when stdout is connected to a TTY" do
-      subject { command_class.new(stdout: STDOUT) }
-
-      it do
-        skip "STDOUT is not a TTY" unless STDOUT.tty?
-
-        expect(subject.terminal_size).to eq(STDOUT.winsize)
-      end
-    end
-
-    context "when stdout is not connected to a TTY" do
-      subject { command_class.new(stdout: StringIO.new) }
-
-      it "must fallback to [DEFAULT_TERMINAL_HEIGHT, DEFAULT_TERMINAL_WIDTH]" do
-        expect(subject.terminal_size).to eq(
-          [described_class::DEFAULT_TERMINAL_HEIGHT, described_class::DEFAULT_TERMINAL_WIDTH]
-        )
-      end
-
-      context "but the LINES env variable was set" do
-        let(:lines) { 10 }
-        let(:env)   { {'LINES' => lines.to_s} }
-
-        subject { command_class.new(stdout: StringIO.new, env: env) }
-
-        it "must fallback to the [$LINES, DEFAULT_TERMINAL_WIDTH]" do
-          expect(subject.terminal_size).to eq(
-            [lines, described_class::DEFAULT_TERMINAL_WIDTH]
-          )
-        end
-      end
-
-      context "but the COLUMNS env variable was set" do
-        let(:columns) { 50 }
-        let(:env)     { {'COLUMNS' => columns.to_s} }
-
-        subject { command_class.new(stdout: StringIO.new, env: env) }
-
-        it "must fallback to the [DEFAULT_TERMINAL_HEIGHT, COLUMNS]" do
-          expect(subject.terminal_size).to eq(
-            [described_class::DEFAULT_TERMINAL_HEIGHT, columns]
-          )
-        end
-      end
-
-      context "but the LINES and COLUMNS env variable was set" do
-        let(:lines) { 10 }
-        let(:columns) { 50 }
-        let(:env) do
-          {'LINES' => lines.to_s, 'COLUMNS' => columns.to_s}
-        end
-
-        subject { command_class.new(stdout: StringIO.new, env: env) }
-
-        it "must fallback to the [LINES, COLUMNS]" do
-          expect(subject.terminal_size).to eq(
-            [lines, columns]
-          )
-        end
-      end
-    end
-  end
-end

data/spec/usage_spec.rb

@@ -1,237 +0,0 @@
-require 'spec_helper'
-require 'command_kit/usage'
-
-describe CommandKit::Usage do
-  module TestUsage
-    class ImplicitCmd
-      include CommandKit::Usage
-    end
-  end
-
-  let(:command_class) { TestUsage::ImplicitCmd }
-
-  describe ".included" do
-    it { expect(command_class).to include(CommandKit::CommandName) }
-    it { expect(command_class).to include(CommandKit::Help) }
-  end
-
-  describe ".usage" do
-    subject { TestUsage::ImplicitCmd }
-
-    context "when no usage has been set" do
-      it "should default to nil" do
-        expect(subject.usage).to be_nil
-      end
-    end
-
-    context "when a usage is explicitly set" do
-      module TestUsage
-        class ExplicitCmd
-          include CommandKit::Usage
-          usage 'EXPLICIT'
-        end
-      end
-
-      subject { TestUsage::ExplicitCmd }
-
-      it "must return the explicitly set usage" do
-        expect(subject.usage).to eq("EXPLICIT")
-      end
-    end
-
-    context "when the command class inherites from another class" do
-      context "but no usage is set" do
-        module TestUsage
-          class BaseCmd
-            include CommandKit::Usage
-          end
-
-          class InheritedCmd < BaseCmd
-          end
-        end
-
-        subject { TestUsage::InheritedCmd }
-
-        it "must search each class then return nil "do
-          expect(subject.usage).to be_nil
-        end
-      end
-
-      module TestUsage
-        class ExplicitBaseCmd
-          include CommandKit::Usage
-          usage 'EXPLICIT'
-        end
-      end
-
-      context "when the superclass defines an explicit usage" do
-        module TestUsage
-          class ImplicitInheritedCmd < ExplicitBaseCmd
-          end
-        end
-
-        let(:super_subject) { TestUsage::ExplicitBaseCmd }
-        subject { TestUsage::ImplicitInheritedCmd }
-
-        it "must inherit the superclass'es usage" do
-          expect(subject.usage).to eq(super_subject.usage)
-        end
-
-        it "must not change the superclass'es usage" do
-          expect(super_subject.usage).to eq("EXPLICIT")
-        end
-      end
-
-      context "when the subclass defines an explicit usage" do
-        module TestUsage
-          class ImplicitBaseCmd
-            include CommandKit::Usage
-          end
-
-          class ExplicitInheritedCmd < ImplicitBaseCmd
-            usage 'EXPLICIT'
-          end
-        end
-
-        let(:super_subject) { TestUsage::ImplicitBaseCmd }
-        subject { TestUsage::ExplicitInheritedCmd }
-
-        it "must return the subclass'es usage" do
-          expect(subject.usage).to eq("EXPLICIT")
-        end
-
-        it "must not change the superclass'es usage" do
-          expect(super_subject.usage).to be_nil
-        end
-      end
-
-      context "when both the subclass overrides the superclass's usages" do
-        module TestUsage
-          class ExplicitOverridingInheritedCmd < ExplicitBaseCmd
-            usage 'EXPLICIT_OVERRIDE'
-          end
-        end
-
-        let(:super_subject) { TestUsage::ExplicitBaseCmd }
-        subject { TestUsage::ExplicitOverridingInheritedCmd }
-
-        it "must return the subclass'es usage" do
-          expect(subject.usage).to eq("EXPLICIT_OVERRIDE")
-        end
-
-        it "must not change the superclass'es usage" do
-          expect(super_subject.usage).to eq("EXPLICIT")
-        end
-      end
-    end
-  end
-
-  module TestUsage
-    class NoUsage
-      include CommandKit::Usage
-    end
-  end
-
-  module TestUsage
-    class SingleUsage
-      include CommandKit::Usage
-
-      usage 'ONE USAGE'
-    end
-  end
-
-  module TestUsage
-    class MultipleUsage
-      include CommandKit::Usage
-
-      usage [
-        'ONE USAGE',
-        'TWO USAGE',
-        'THREE USAGE'
-      ]
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#usage" do
-    context "when .usage is nil" do
-      let(:command_class) { TestUsage::NoUsage }
-      subject { command_class.new }
-
-      it "must not print anything" do
-        expect(subject.usage).to be(nil)
-      end
-    end
-
-    context "when .usage is a String" do
-      let(:command_class) { TestUsage::SingleUsage }
-      subject { command_class.new }
-
-      it "must return .usage, but with #command_name prepended" do
-        expect(subject.usage).to eq("#{subject.command_name} #{command_class.usage}")
-      end
-    end
-
-    context "when #usage is an Array of Strings" do
-      let(:command_class) { TestUsage::MultipleUsage }
-      subject { command_class.new }
-
-      it "must return .usage, but with #command_name prepended to each element" do
-        expect(subject.usage).to eq(
-          [
-            "#{subject.command_name} #{command_class.usage[0]}",
-            "#{subject.command_name} #{command_class.usage[1]}",
-            "#{subject.command_name} #{command_class.usage[2]}"
-          ]
-        )
-      end
-    end
-  end
-
-  describe "#help_usage" do
-    context "when #usage is nil" do
-      let(:command_class) { TestUsage::NoUsage }
-      subject { command_class.new }
-
-      it "must not print anything" do
-        expect { subject.help_usage }.to_not output.to_stdout
-      end
-    end
-
-    context "when #usage is a String" do
-      let(:command_class) { TestUsage::SingleUsage }
-      subject { command_class.new }
-
-      it "must print out 'usage:' and only one usage" do
-        expect { subject.help_usage }.to output(
-          "usage: #{subject.usage}#{$/}"
-        ).to_stdout
-      end
-    end
-
-    context "when #usage is an Array of Strings" do
-      let(:command_class) { TestUsage::MultipleUsage }
-      subject { command_class.new }
-
-      it "must print out the 'usage:' and all usage Strings" do
-        expect { subject.help_usage }.to output(
-          [
-            "usage: #{subject.usage[0]}",
-            "       #{subject.usage[1]}",
-            "       #{subject.usage[2]}",
-            ''
-          ].join($/)
-        ).to_stdout
-      end
-    end
-  end
-
-  describe "#help" do
-    it "must call #help_usage" do
-      expect(subject).to receive(:help_usage)
-
-      subject.help
-    end
-  end
-end

data/spec/xdg_spec.rb

@@ -1,191 +0,0 @@
-require 'spec_helper'
-require 'command_kit/xdg'
-
-describe CommandKit::XDG do
-  module TestXDG
-    class TestCommand
-      include CommandKit::XDG
-    end
-  end
-
-  let(:command_class) { TestXDG::TestCommand }
-  subject { command_class.new }
-
-  describe ".xdg_namespace" do
-    subject { command_class }
-
-    context "when no xdg_namespace has been defined" do
-      it "must default to the .command_name" do
-        expect(subject.xdg_namespace).to eq(subject.command_name)
-      end
-    end
-
-    context "when an xdg_namespace has been defined in a super-class" do
-      module TestXDG
-        class SuperClassWithXDGNamespace
-          include CommandKit::XDG
-
-          xdg_namespace 'foo'
-        end
-
-        class SubClassWithoutXDGNamespace < SuperClassWithXDGNamespace
-        end
-      end
-
-      let(:command_superclass) { TestXDG::SuperClassWithXDGNamespace }
-      let(:command_class) { TestXDG::SubClassWithoutXDGNamespace }
-
-      it "must default to the superclass'es .xdg_namespace" do
-        expect(subject.xdg_namespace).to eq(command_superclass.xdg_namespace)
-      end
-
-      context "but the sub-class also defines an .xdg_namespace" do
-        module TestXDG
-          class SubClassWithXDGNamespace < SuperClassWithXDGNamespace
-
-            xdg_namespace 'bar'
-
-          end
-        end
-
-        let(:command_class) { TestXDG::SubClassWithXDGNamespace }
-
-        it "must return the subclass'es .xdg_namespace" do
-          expect(command_class.xdg_namespace).to eq('bar')
-        end
-
-        it "must not override the superclass'es .xdg_namespace" do
-          expect(command_superclass.xdg_namespace).to eq('foo')
-        end
-      end
-    end
-  end
-  
-  describe "#xdg_namespace" do
-    it "must return .xdg_namespace" do
-      expect(subject.xdg_namespace).to eq(command_class.xdg_namespace)
-    end
-  end
-
-  let(:xdg_config_home) { '/path/to/.config'      }
-  let(:xdg_data_home)   { '/path/to/.local/share' }
-  let(:xdg_cache_home)  { '/path/to/.cache'       }
-
-  describe "#initialize" do
-    let(:xdg_namespace) { subject.xdg_namespace }
-
-    context "when env: contains 'XDG_CONFIG_HOME'" do
-      let(:env) do
-        {'XDG_CONFIG_HOME' => xdg_config_home}
-      end
-
-      subject { command_class.new(env: env) }
-
-      it "must initialize #config_dir to '$XDG_CONFIG_HOME/<xdg_namespace>'" do
-        expect(subject.config_dir).to eq(
-          File.join(xdg_config_home,xdg_namespace)
-        )
-      end
-    end
-
-    context "when env: does not contains 'XDG_DATA_HOME'" do
-      it "must initialize #config_dir to '$HOME/.config/<xdg_namespace>'" do
-        expect(subject.config_dir).to eq(
-          File.join(subject.home_dir,'.config',subject.xdg_namespace)
-        )
-      end
-    end
-
-    context "when env: contains 'XDG_DATA_HOME'" do
-      let(:env) do
-        {'XDG_DATA_HOME' => xdg_data_home}
-      end
-
-      subject { command_class.new(env: env) }
-
-      it "must initialize #local_share_dir to '$XDG_DATA_HOME/<xdg_namespace>'" do
-        expect(subject.local_share_dir).to eq(
-          File.join(xdg_data_home,xdg_namespace)
-        )
-      end
-    end
-
-    context "when env: does not contains 'XDG_DATA_HOME'" do
-      it "must initialize #local_share_dir to '$HOME/.local/share/<xdg_namespace>'" do
-        expect(subject.local_share_dir).to eq(
-          File.join(subject.home_dir,'.local','share',xdg_namespace)
-        )
-      end
-    end
-
-    context "when env: contains 'XDG_CACHE_HOME'" do
-      let(:env) do
-        {'XDG_CACHE_HOME' => xdg_cache_home}
-      end
-
-      subject { command_class.new(env: env) }
-
-      it "must initialize #cache_dir to '$XDG_CACHE_HOME/<xdg_namespace>'" do
-        expect(subject.cache_dir).to eq(
-          File.join(xdg_cache_home,xdg_namespace)
-        )
-      end
-    end
-
-    context "when env: does not contains 'XDG_CACHE_HOME'" do
-      it "must initialize #cache_dir to '$HOME/.cache/<xdg_namespace>'" do
-        expect(subject.cache_dir).to eq(
-          File.join(subject.home_dir,'.cache',xdg_namespace)
-        )
-      end
-    end
-  end
-
-  describe "#config_dir" do
-    let(:env) do
-      {'XDG_CONFIG_HOME' => xdg_config_home}
-    end
-
-    subject { command_class.new(env: env) }
-
-    let(:xdg_namespace) { subject.xdg_namespace }
-
-    it "must return the initialized #config_dir" do
-      expect(subject.config_dir).to eq(
-        File.join(xdg_config_home,xdg_namespace)
-      )
-    end
-  end
-
-  describe "#local_share_dir" do
-    let(:env) do
-      {'XDG_DATA_HOME' => xdg_data_home}
-    end
-
-    subject { command_class.new(env: env) }
-
-    let(:xdg_namespace) { subject.xdg_namespace }
-
-    it "must return the initialized #local_share_dir" do
-      expect(subject.local_share_dir).to eq(
-        File.join(xdg_data_home,xdg_namespace)
-      )
-    end
-  end
-
-  describe "#cache_dir" do
-    let(:env) do
-      {'XDG_CACHE_HOME' => xdg_cache_home}
-    end
-
-    subject { command_class.new(env: env) }
-
-    let(:xdg_namespace) { subject.xdg_namespace }
-
-    it "must return the initialized #cache_dir" do
-      expect(subject.cache_dir).to eq(
-        File.join(xdg_cache_home,xdg_namespace)
-      )
-    end
-  end
-end