rprogram 0.3.1 → 0.3.2

data/lib/rprogram/task.rb

@@ -25,11 +25,11 @@ module RProgram
     #     # ...
     #   end
     #
-    def initialize(options={},&block)
+    def initialize(options={})
       @subtasks = {}
-      @options = options
+      @options  = options
 
-      block.call(self) if block
+      yield self if block_given?
     end
 
     #
@@ -293,7 +293,12 @@ module RProgram
       return leading_non_options + options + tailing_args
     end
 
-    alias to_a arguments
+    #
+    # @see #arguments
+    #
+    def to_a
+      arguments
+    end
 
     protected
 
@@ -487,17 +492,14 @@ module RProgram
     #   Task.flag_namify('--output-file')
     #   # => "output_file"
     #
-    def Task.flag_namify(flag)
+    def self.flag_namify(flag)
       flag = flag.to_s.downcase
 
       # remove leading dashes
-      if flag[0..1] == '--'
-        method_name = flag[2..-1]
-      elsif flag[0..0] == '-'
-        method_name = flag[1..-1]
-      else
-        method_name = flag
-      end
+      method_name = if    flag.start_with?('--') then flag[2..-1]
+                    elsif flag.start_with?('-')  then flag[1..-1]
+                    else                              flag
+                    end
 
       # replace remaining dashes with underscores
       return method_name.gsub(/[-_\.\s]+/,'_')

data/lib/rprogram/version.rb

@@ -1,4 +1,4 @@
 module RProgram
   # Version of RProgram
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/rprogram.gemspec

@@ -2,104 +2,59 @@
 
 require 'yaml'
 
-Gem::Specification.new do |gemspec|
-  root    = File.dirname(__FILE__)
-  lib_dir = File.join(root,'lib')
-  files   = `git ls-files`.split($/)
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
 
-  filter_files = lambda { |paths|
-    files & case paths
-            when Array
-              paths
-            when String
-              Dir[paths]
-            end
-  }
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
 
-  version = {
-    :file     => 'rprogram/version',
-    :constant => 'RProgram::VERSION'
-  }
+                  require 'rprogram/version'
+                  RProgram::VERSION
+                end
 
-  defaults = {
-    'name'            => File.basename(root),
-    'files'           => files,
-    'require_paths'   => ['ext', 'lib'].select { |dir| File.directory?(dir) },
-    'executables'     => filter_files['bin/*'].map { |path| File.basename(path) },
-    'test_files'      => filter_files['{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'],
-    'doc_files'       => filter_files['*.{txt,rdoc,md,markdown,tt,textile}'],
-    'extra_doc_files' => filter_files['*.{txt,rdoc,md,markdown,tt,textile}']
-  }
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
 
-  metadata = defaults.merge(YAML.load_file('gemspec.yml'))
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
 
-  gemspec.name    = metadata['name']
-  gemspec.version = if metadata['version']
-                      metadata['version']
-                    else
-                      $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
 
-                      require version[:file]
-                      eval(version[:constant])
-                    end
-
-  gemspec.summary     = metadata.fetch('summary',metadata['description'])
-  gemspec.description = metadata.fetch('description',metadata['summary'])
-
-  gemspec.licenses = Array(metadata['license'])
-  gemspec.authors  = Array(metadata['authors'])
-
-  gemspec.email    = metadata['email']
-  gemspec.homepage = metadata['homepage']
-
-  gemspec.require_paths = Array(metadata['require_paths'])
-  gemspec.files         = filter_files[metadata['files']]
-  gemspec.files        += Array(metadata['generated_files'])
-  gemspec.executables   = metadata['executables']
-  gemspec.extensions    = metadata['extensions']
-
-  if Gem::VERSION < '1.7.'
-    gemspec.default_executable = gemspec.executables.first
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
   end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
 
-  gemspec.test_files       = filter_files[metadata['test_files']]
-  gemspec.extra_rdoc_files = Array(metadata['extra_doc_files'])
-
-  gemspec.post_install_message = metadata['post_install_message']
-  gemspec.requirements         = metadata['requirements']
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
 
-  if gemspec.respond_to?(:required_ruby_version=)
-    gemspec.required_ruby_version = metadata['required_ruby_version']
-  end
-
-  if gemspec.respond_to?(:required_rubygems_version=)
-    gemspec.required_rubygems_version = metadata['required_ruby_version']
-  end
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
 
-  parse_versions = lambda { |versions|
-    case versions
-    when Array
-      versions.map { |v| v.to_s }
-    when String
-      versions.split(/,\s*/)
-    end
-  }
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
 
-  if metadata['dependencies']
-    metadata['dependencies'].each do |name,versions|
-      gemspec.add_dependency(name,parse_versions[versions])  
-    end
-  end
+  split = lambda { |string| string.split(/,\s*/) }
 
-  if metadata['runtime_dependencies']
-    metadata['runtime_dependencies'].each do |name,versions|
-      gemspec.add_runtime_dependency(name,parse_versions[versions])  
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
     end
   end
 
-  if metadata['development_dependencies']
-    metadata['development_dependencies'].each do |name,versions|
-      gemspec.add_development_dependency(name,parse_versions[versions])  
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
     end
   end
 end

data/spec/classes/aliased_program.rb

@@ -1,3 +1,5 @@
+require 'rprogram/program'
+
 class AliasedProgram < RProgram::Program
 
   name_program 'ls'

data/spec/classes/named_program.rb

@@ -1,3 +1,5 @@
+require 'rprogram/program'
+
 class NamedProgram < RProgram::Program
 
   name_program 'ls'

data/spec/non_option_spec.rb

@@ -1,11 +1,9 @@
-require 'rprogram/non_option'
-
 require 'spec_helper'
 
+require 'rprogram/non_option'
+
 describe NonOption do
-  before(:all) do
-    @non_option = NonOption.new(:name => 'files')
-  end
+  subject { NonOption.new(:name => 'files') }
 
   it "should keep :leading and :tailing options mutually exclusive" do
     leading = NonOption.new(:name => 'files', :leading => true)
@@ -19,30 +17,30 @@ describe NonOption do
   end
 
   it "should return an empty Array when passed nil" do
-    @non_option.arguments(nil).should == []
+    subject.arguments(nil).should == []
   end
 
   it "should return an empty Array when passed false" do
-    @non_option.arguments(false).should == []
+    subject.arguments(false).should == []
   end
 
   it "should return an empty Array when passed []" do
-    @non_option.arguments([]).should == []
+    subject.arguments([]).should == []
   end
 
   it "should return an Array when passed a single value" do
-    @non_option.arguments('foo').should == ['foo']
+    subject.arguments('foo').should == ['foo']
   end
 
   it "should return an Array when passed multiple values" do
-    @non_option.arguments(['foo', 'bar']).should == ['foo', 'bar']
+    subject.arguments(['foo', 'bar']).should == ['foo', 'bar']
   end
 
   it "should return an Array when passed a Hash of keys" do
-    @non_option.arguments({:foo => true, :bar => false}).should == ['foo']
+    subject.arguments({:foo => true, :bar => false}).should == ['foo']
   end
 
   it "should return an Array when passed a Hash of values" do
-    @non_option.arguments({:foo => 'bar'}).should == ['foo=bar']
+    subject.arguments({:foo => 'bar'}).should == ['foo=bar']
   end
 end

data/spec/option_examples.rb

@@ -1,17 +1,15 @@
-require 'rprogram/option'
-
 require 'spec_helper'
 
 shared_examples_for 'Option' do
   it "should return an empty Array when passed nil" do
-    @option.arguments(nil).should == []
+    subject.arguments(nil).should == []
   end
 
   it "should return an empty Array when passed false" do
-    @option.arguments(false).should == []
+    subject.arguments(false).should == []
   end
 
   it "should return a single flag when passed true" do
-    @option.arguments(true).should == ['-f']
+    subject.arguments(true).should == ['-f']
   end
 end

data/spec/option_list_spec.rb

@@ -1,25 +1,21 @@
-require 'rprogram/option_list'
-
 require 'spec_helper'
 
-describe OptionList do
-  before(:each) do
-    @options = OptionList.new
-  end
+require 'rprogram/option_list'
 
+describe OptionList do
   it "should behave like a Hash" do
-    @options[:bla] = 2
-    @options[:bla].should == 2
+    subject[:bla] = 2
+    subject[:bla].should == 2
   end
 
   it "should provide reader and writer methods" do
-    @options.bla = 5
-    @options.bla.should == 5
+    subject.bla = 5
+    subject.bla.should == 5
   end
 
   it "should raise a NoMethodError exception when calling other methods" do
     lambda {
-      @options.bla(5)
+      subject.bla(5)
     }.should raise_error(NoMethodError)
   end
 end

data/spec/option_spec.rb

@@ -1,52 +1,50 @@
-require 'rprogram/option'
-
 require 'spec_helper'
 require 'option_examples'
 
+require 'rprogram/option'
+
 describe Option do
   describe "custom formatting" do
     it "should allow the format block to return nil" do
-      opt = Option.new(:flag => '-f') { |opt,value| }
+      opt = described_class.new(:flag => '-f') { |opt,value| }
 
       opt.arguments('bla').should == []
     end
   end
 
   describe "single flag" do
-    before(:all) do
-      @option = Option.new(:flag => '-f')
-    end
+    subject { described_class.new(:flag => '-f') }
 
     it_should_behave_like 'Option'
 
     it "should render a single flag with an optional value" do
       value = 'foo'
 
-      @option.arguments('foo').should == ['-f', 'foo']
+      subject.arguments('foo').should == ['-f', 'foo']
     end
 
     it "should render a single flag with multiple values" do
       value = ['foo','bar','baz']
 
-      @option.arguments(value).should == ['-f','foo','bar','baz']
+      subject.arguments(value).should == ['-f','foo','bar','baz']
     end
 
     it "should render a single flag with a Hash of keys" do
       value = {:foo => true, :bar => false}
 
-      @option.arguments(value).should == ['-f','foo']
+      subject.arguments(value).should == ['-f','foo']
     end
 
     it "should render a single flag with a Hash of keys and values" do
       value = {:foo => 'bar'}
 
-      @option.arguments(value).should == ['-f','foo=bar']
+      subject.arguments(value).should == ['-f','foo=bar']
     end
   end
 
   describe "equals flag" do
-    before(:all) do
-      @option = Option.new(:equals => true, :flag => '-f')
+    subject do
+      described_class.new(:equals => true, :flag => '-f')
     end
 
     it_should_behave_like 'Option'
@@ -54,25 +52,25 @@ describe Option do
     it "should render a single flag with a value" do
       value = 'foo'
 
-      @option.arguments('foo').should == ['-f=foo']
+      subject.arguments('foo').should == ['-f=foo']
     end
 
     it "should render a single flag with multiple values" do
       value = ['foo', 'bar', 'baz']
 
-      @option.arguments(value).should == ['-f=foo bar baz']
+      subject.arguments(value).should == ['-f=foo bar baz']
     end
 
     it "should render a single flag with a Hash of keys" do
       value = {:foo => true, :bar => false}
 
-      @option.arguments(value).should == ['-f=foo']
+      subject.arguments(value).should == ['-f=foo']
     end
   end
 
   describe "multiple flags" do
-    before(:all) do
-      @option = Option.new(:multiple => true, :flag => '-f')
+    subject do
+      described_class.new(:multiple => true, :flag => '-f')
     end
 
     it_should_behave_like 'Option'
@@ -80,18 +78,18 @@ describe Option do
     it "should render a single flag with a value" do
       value = 'foo'
 
-      @option.arguments(value).should == ['-f', 'foo']
+      subject.arguments(value).should == ['-f', 'foo']
     end
 
     it "should render multiple flags for multiple values" do
       value = ['foo','bar','baz']
 
-      @option.arguments(value).should == ['-f', 'foo', '-f', 'bar', '-f', 'baz']
+      subject.arguments(value).should == ['-f', 'foo', '-f', 'bar', '-f', 'baz']
     end
 
     it "should render multiple flags for a Hash of keys" do
       value = {:foo => true, :bar => true, :baz => false}
-      args = @option.arguments(value)
+      args = subject.arguments(value)
       
       (args & ['-f', 'foo']).should == ['-f', 'foo']
       (args & ['-f', 'bar']).should == ['-f', 'bar']
@@ -100,13 +98,13 @@ describe Option do
     it "should render multiple flags for a Hash of values" do
       value = {:foo => 'bar'}
 
-      @option.arguments(value).should == ['-f', 'foo=bar']
+      subject.arguments(value).should == ['-f', 'foo=bar']
     end
   end
 
   describe "multiple equals flags" do
-    before(:all) do
-      @option = Option.new(:multiple => true, :equals => true, :flag => '-f')
+    subject do
+      described_class.new(:multiple => true, :equals => true, :flag => '-f')
     end
 
     it_should_behave_like 'Option'
@@ -114,18 +112,18 @@ describe Option do
     it "should render a single flag with a value" do
       value = 'foo'
 
-      @option.arguments(value).should == ['-f=foo']
+      subject.arguments(value).should == ['-f=foo']
     end
 
     it "should render multiple equal flags for multiple values" do
       value = ['foo', 'bar']
 
-      @option.arguments(value).should == ['-f=foo', '-f=bar']
+      subject.arguments(value).should == ['-f=foo', '-f=bar']
     end
 
     it "should render multiple equal flags for a Hash of keys" do
       value = {:foo => true, :bar => true, :baz => false}
-      args = @option.arguments(value)
+      args = subject.arguments(value)
       
       args.include?('-f=foo').should == true
       args.include?('-f=bar').should == true
@@ -133,7 +131,7 @@ describe Option do
 
     it "should render multiple equal flags for a Hash of values" do
       value = {:foo => 'bar', :bar => 'baz'}
-      args = @option.arguments(value)
+      args = subject.arguments(value)
 
       args.include?('-f=foo=bar').should == true
       args.include?('-f=bar=baz').should == true
@@ -141,8 +139,8 @@ describe Option do
   end
 
   describe "separated values" do
-    before(:all) do
-      @option = Option.new(:separator => ',', :flag => '-f')
+    subject do
+      described_class.new(:separator => ',', :flag => '-f')
     end
 
     it_should_behave_like 'Option'
@@ -150,18 +148,18 @@ describe Option do
     it "should render a single flag with a value" do
       value = 'foo'
 
-      @option.arguments('foo').should == ['-f', 'foo']
+      subject.arguments('foo').should == ['-f', 'foo']
     end
 
     it "should render a single flag with multiple values" do
       value = ['foo', 'bar', 'baz']
 
-      @option.arguments(value).should == ['-f', 'foo,bar,baz']
+      subject.arguments(value).should == ['-f', 'foo,bar,baz']
     end
 
     it "should render a single flag with a Hash of keys" do
       value = {:foo => true, :bar => true, :baz => false}
-      args = @option.arguments(value)
+      args = subject.arguments(value)
       
       args[0].should == '-f'
 
@@ -173,7 +171,7 @@ describe Option do
 
     it "should render a single flag with a Hash of values" do
       value = {:foo => 'bar', :bar => 'baz'}
-      args = @option.arguments(value)
+      args = subject.arguments(value)
       
       args[0].should == '-f'