valet 0.0.7 → 0.0.8

data/lib/valet/option/switch.rb

@@ -0,0 +1,32 @@
+require 'valet/option/common'
+
+module Valet
+  module Option
+    class Switch < Common
+      attr_reader :default, :value
+
+      def initialize(long_name)
+        super
+        @default = false
+        @value = @default
+      end
+
+      def default=(new_default)
+        @default = new_default ? true : false
+        @value = @default
+      end
+
+      def switch
+        @value = ! @value
+      end
+
+      def long_name_to_s
+        if default
+          "--no-#{long_name}".gsub(/_/, '-')
+        else
+          "--#{long_name}".gsub(/_/, '-')
+        end
+      end
+    end
+  end
+end

data/lib/valet/options.rb

@@ -0,0 +1,31 @@
+require 'set'
+
+module Valet
+  class Options < Set
+    def [](name)
+      find_option(name)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if (option = find_switch(method_name)) || (option = find_flag(method_name))
+        option.value
+      else
+        super
+      end
+    end
+
+    private
+
+    def find_option(name)
+      self.find { |option| name == option.name }
+    end
+
+    def find_switch(name)
+      self.find { |option| name =~ /#{option.name}\?/ if option.switch? }
+    end
+
+    def find_flag(name)
+      self.find { |option| name == option.name if option.flag? }
+    end
+  end
+end

data/lib/valet/version.rb

@@ -2,7 +2,7 @@ module Valet
   module VERSION
     MAJOR = 0
     MINOR = 0
-    BUILD = 7
+    BUILD = 8
     PRE   = nil
 
     STRING = [MAJOR, MINOR, BUILD, PRE].compact.join('.')

data/spec/spec_helper.rb

@@ -15,19 +15,15 @@ Dir[File.expand_path('spec/support/**/*.rb')].each { |file| require file }
 require 'valet'
 include Valet
 
-# Capture STDOUT and STDIN in new IO streams
-require 'stringio'
-$stdout = StringIO.new
-$stderr = StringIO.new
-
-# Reset ARGV to contain no arguments
-ARGV.clear
-
 # Configure RSpec
 RSpec.configure do |config|
+  # Ensure usage of RSpec's new expectation syntax
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+
+  # Metadata keys can be written as ":symbol" instead of "symbol: true"
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
-  # Use a :focus tag for running only specific example(s)
+  # Use a ":focus" tag for running only specific example(s)
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
 end

data/spec/support/shared_examples.rb

@@ -0,0 +1,54 @@
+shared_examples_for "a common option" do
+  subject(:opt) { described_class.new(:format) }
+
+  its(:long_name)   { should be_a(Symbol) }
+  its(:short_name)  { should be_nil }
+  its(:summary)     { should be_nil }
+  its(:description) { should be_nil }
+
+  describe "#initialize" do
+    context "raises an OptionError" do
+      it "if the long name is not a symbol" do
+        expect { described_class.new('format') }.to raise_error(OptionError)
+      end
+
+      it "if the long name is only one character long" do
+        expect { described_class.new(:f) }.to raise_error(OptionError)
+      end
+    end
+  end
+
+  describe "attributes" do
+    it "can be given a short name" do
+      opt.short_name = :f
+      expect(opt.short_name).to be(:f)
+    end
+
+    it "can be given a summary" do
+      opt.summary = 'Specify a format (Markdown or Textile)'
+      expect(opt.summary).to eq('Specify a format (Markdown or Textile)')
+    end
+
+    it "can be given a description" do
+      opt.description = 'A longer option description...'
+      expect(opt.description).to eq('A longer option description...')
+    end
+
+    context "raises an OptionError" do
+      it "if the short name is not a symbol" do
+        expect { opt.short_name = 'f' }.to raise_error(OptionError)
+      end
+
+      it "if the short name is longer than one character" do
+        expect { opt.short_name = 'format' }.to raise_error(OptionError)
+      end
+    end
+  end
+
+  describe "#short_name_to_s" do
+    it "returns the short name's string representation" do
+      opt.short_name = :f
+      expect(opt.short_name_to_s).to eq('-f')
+    end
+  end
+end

data/spec/support/terminal_helper.rb

@@ -0,0 +1,20 @@
+require 'stringio'
+
+RSpec.configure do |config|
+  # Clear all remaining arguments in ARGV to make it testable
+  config.before(:suite) { ARGV.clear }
+
+  # Reroute STDOUT, STDERR and STDIN to testable streams
+  config.before(:each) do
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+    $stdin  = StringIO.new
+  end
+
+  # Set STDOUT, STDERR and STDIN back to default
+  config.after(:each) do
+    $stdout = STDOUT
+    $stderr = STDERR
+    $stdin  = STDIN
+  end
+end

data/spec/valet/application_spec.rb

@@ -1,52 +1,82 @@
 require 'spec_helper'
 
 describe Valet::Application do
-  let(:app) { Application.new }
+  subject(:app) { Application.new }
 
-  describe "class attributes" do
-    it "can have a name" do
-      Application.name = 'Backup'
-      Application.name.should == 'Backup'
+  its(:arguments)   { should be(ARGV) }
+  its(:options)     { should be_an_instance_of(Options) }
+  its(:commands)    { should be_an_instance_of(Commands) }
+
+  its(:name)        { should be_nil }
+  its(:version)     { should be_nil }
+  its(:authors)     { should be_nil }
+  its(:email)       { should be_nil }
+  its(:homepage)    { should be_nil }
+  its(:copyright)   { should be_nil }
+  its(:license)     { should be_nil }
+  its(:summary)     { should be_nil }
+  its(:description) { should be_nil }
+  its(:examples)    { should eq([]) }
+
+  describe "attributes" do
+    it "can be given a name" do
+      app.name = 'Backup'
+      expect(app.name).to eq('Backup')
+    end
+
+    it "can be given a version" do
+      app.version = '1.2.3'
+      expect(app.version).to eq('1.2.3')
     end
 
-    it "can have a version" do
-      Application.version = '1.2.3'
-      Application.version.should == '1.2.3'
+    it "can be given authors" do
+      app.authors = ['Alexander Baumann', 'Bob the Builder']
+      expect(app).to have(2).authors
     end
 
-    it "can have authors" do
-      Application.authors = ['Alexander Baumann', 'Bob the Builder']
-      Application.authors.should == ['Alexander Baumann', 'Bob the Builder']
+    it "can be given email addresses" do
+      app.email = ['alexander.baumann@arclight.ch', 'bob@builder.com']
+      expect(app.email).to have(2).emails
     end
 
-    it "can have a copyright notice" do
-      Application.copyright = 'Copyright (c) 2012 Free Software Foundation, Inc.'
-      Application.copyright.should == 'Copyright (c) 2012 Free Software Foundation, Inc.'
+    it "can be given a homepage" do
+      app.homepage = 'http://gitkeeper.github.com/valet'
+      expect(app.homepage).to eq('http://gitkeeper.github.com/valet')
     end
 
-    it "can have a license" do
-      Application.license = <<-LICENSE.gsub(/^ {6}/, '').strip
+    it "can be given a copyright notice" do
+      app.copyright = 'Copyright (c) 2012 Free Software Foundation, Inc.'
+      expect(app.copyright).to eq('Copyright (c) 2012 Free Software Foundation, Inc.')
+    end
+
+    it "can be given a license" do
+      app.license = <<-LICENSE.gsub(/^ {8}/, '').strip
         License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
         This is free software: You are free to change and redistribute it.
         There is NO WARRANTY, to the extent permitted by law.
       LICENSE
-      Application.license.should include('GNU GPL version 3 or later')
+      expect(app.license).to include('GNU GPL version 3 or later')
     end
-  end
 
-  describe ".start" do
-    it "passes ARGV as arguments to it's new instance by default" do
-      app = Application.start
-      app.args.should == ARGV
+    it "can be given a summary" do
+      app.summary = 'A framework for creating GNU compliant CLIs.'
+      expect(app.summary).to eq('A framework for creating GNU compliant CLIs.')
     end
 
-    it "can pass custom arguments to it's new instance" do
-      app = Application.start(%w( --custom arguments ))
-      app.args.should == %w( --custom arguments )
+    it "can be given a description" do
+      app.description = <<-DESC.gsub(/^ {8}/, '').strip
+        Valet helps you write the sophisticated command-line interfaces you're
+        so used to from GNU/Linux. It provides a beautiful API, rich template
+        support, smart configuration, man page generator, and many other useful
+        features. No matter how large or complex your application is, Valet tops
+        it off with the command-line interface it deserves.
+      DESC
+      expect(app.description).to include('provides a beautiful API')
     end
 
-    it "returns the new application" do
-      Application.start.should be_an_instance_of(Application)
+    it "can be given examples" do
+      app.examples << ['Generate command files' 'valet generate command backup']
+      expect(app.examples).to have(1).example
     end
   end
 end

data/spec/valet/command_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Valet::Command do
+  subject(:cmd) { Command.new(:backup) }
+
+  its(:name)        { should be_a(Symbol) }
+  its(:aliases)     { should be_nil }
+  its(:action)      { should be_nil }
+  its(:options)     { should be_an_instance_of(Options) }
+  its(:commands)    { should be_an_instance_of(Commands) }
+  its(:syntax)      { should be_nil }
+  its(:summary)     { should be_nil }
+  its(:description) { should be_nil }
+  its(:examples)    { should eq([]) }
+
+  describe "#initialize" do
+    context "raises a CommandError" do
+      it "if the name is not a symbol" do
+        expect { Command.new('backup') }.to raise_error(CommandError)
+      end
+    end
+  end
+
+  describe "attributes" do
+    it "can be given aliases" do
+      cmd.aliases = [:bak, :b]
+      expect(cmd.aliases).to eq([:bak, :b])
+    end
+
+    it "can be given options" do
+      cmd.options << double("Option")
+      expect(cmd.options).to have(1).option
+    end
+
+    it "can be given (sub-)commands" do
+      cmd.commands << double("Command")
+      expect(cmd.commands).to have(1).command
+    end
+
+    it "can be given a syntax" do
+      cmd.syntax = 'backup [OPTION]... SOURCE... DIRECTORY'
+      expect(cmd.syntax).to eq('backup [OPTION]... SOURCE... DIRECTORY')
+    end
+
+    it "can be given a summary" do
+      cmd.summary = 'Backup compresses and archives your precious data.'
+      expect(cmd.summary).to eq('Backup compresses and archives your precious data.')
+    end
+
+    it "can be given a description" do
+      description = <<-DESC.gsub(/ {8}/, '')
+        Backup tends to your precious data by scheduling cron jobs that
+        compress and archive your files efficiently. You can specify one or
+        multiple locations to copy your archives to.
+      DESC
+      cmd.description = description
+      expect(cmd.description).to be(description)
+    end
+
+    it "can be given examples" do
+      cmd.examples << ['A zipped backup', 'backup --gzip ~/projects ~/backups ']
+      expect(cmd.examples).to have(1).example
+    end
+  end
+
+  describe "#action" do
+    before { cmd.action { 'Backing up...' } }
+
+    it "attaches a new action if a block is supplied" do
+      cmd.action { 'Deleting all backups...' }
+      expect(cmd.action.call).to eq('Deleting all backups...')
+    end
+
+    it "attaches actions with one block parameter (options)" do
+      expect { cmd.action { |opts| "#{opts}" } }.not_to raise_error
+    end
+
+    it "attaches actions with two block parameters (operands, options)" do
+      expect { cmd.action { |args, opts| "#{args} #{opts}" } }.not_to raise_error
+    end
+
+    it "raises a CommandError if more than two block parameters are given" do
+      expect { cmd.action { |a, b, c| a + b + c } }.to raise_error(CommandError)
+    end
+
+    it "raises a CommandError if arbitrary number of parameters are given" do
+      expect { cmd.action { |*args, opts| "#{args} #{opts}" } }.to raise_error(CommandError)
+    end
+
+    it "returns the action if no block is supplied" do
+      expect(cmd.action.call).to eq('Backing up...')
+    end
+  end
+
+  describe "#execute" do
+    it "can call an action without block parameters" do
+      cmd.stub(action: -> { 'Backing up...' })
+      expect(cmd.execute).to eq('Backing up...')
+    end
+
+    it "can call an action with one block parameter (options)" do
+      cmd.stub(options: double("Options", verbose?: true))
+      cmd.stub(action: ->(opts) { 'Backing up...' if opts.verbose? })
+
+      cmd.options.should_receive(:verbose?)
+      cmd.execute
+    end
+
+    it "can call an action with two block parameters (operands, options)" do
+      cmd.stub(options: double("Options", verbose?: true))
+      cmd.stub(action: ->(args, opts) { args.shift if opts.verbose? })
+
+      expect(cmd.execute('Backing up...')).to eq('Backing up...')
+    end
+  end
+end

data/spec/valet/commands_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Valet::Commands do
+  pending
+end

data/spec/valet/helpers/type_cast_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Valet::Helpers::TypeCast do
+  subject(:obj) { Class.new.extend(Helpers::TypeCast) }
+
+  let(:array) { %w( Bob Alisha Fred ) }
+  let(:array_comma) { 'Bob,Alisha,Fred' }
+  let(:array_space) { 'Bob Alisha Fred' }
+
+  let(:hash) { { name: 'Bob', gender: 'male', age: '42' } }
+  let(:hash_comma) { 'name:Bob,gender:male,age:42' }
+  let(:hash_space) { 'name:Bob gender:male age:42' }
+
+  let(:time) { Time.parse('11.07.2012 08:00') }
+  let(:time_string) { '11.07.2012 08:00'}
+
+  describe "#string_to" do
+    specify { expect(obj.string_to(String, 'Bob')).to eq('Bob') }
+    specify { expect(obj.string_to(Integer, '13')).to eq(13) }
+    specify { expect(obj.string_to(Float, '13.37')).to eq(13.37) }
+    specify { expect(obj.string_to(Array, array_comma)).to eq(array) }
+    specify { expect(obj.string_to(Array, array_space)).to eq(array) }
+    specify { expect(obj.string_to(Hash, hash_comma)).to eq(hash) }
+    specify { expect(obj.string_to(Hash, hash_space)).to eq(hash) }
+    specify { expect(obj.string_to(Time, time_string)).to eq(time) }
+
+    context "it raises a TypeError" do
+      it "if the given type is not allowed" do
+        expect { obj.string_to(Mutex, 'Bob') }.to raise_error(TypeError)
+      end
+    end
+  end
+end