rprogram 0.1.5 → 0.1.6

data/lib/rprogram/rprogram.rb

@@ -4,7 +4,7 @@ module RProgram
   # +false+ if they are not enabled.
   #
   def RProgram.debug
-    @@debug ||= false
+    @@rprogram_debug ||= false
   end
 
   #
@@ -12,6 +12,6 @@ module RProgram
   # specified _value_.
   #
   def RProgram.debug=(value)
-    @@debug = value
+    @@rprogram_debug = value
   end
 end

data/lib/rprogram/task.rb

@@ -49,7 +49,7 @@ module RProgram
       @options.each do |name,value|
         non_opt = get_non_option(name)
 
-        if (non_opt && non_opt.leading)
+        if (non_opt && non_opt.leading?)
           args += non_opt.arguments(value)
         end
       end
@@ -99,7 +99,7 @@ module RProgram
       @options.each do |name,value|
         non_opt = get_non_option(name)
 
-        if (non_opt && non_opt.tailing)
+        if (non_opt && non_opt.tailing?)
           args += non_opt.arguments(value)
         end
       end
@@ -123,6 +123,8 @@ module RProgram
     #   subtask :extra, ExtraTask
     #
     def self.subtask(name,task)
+      name = name.to_s
+
       class_eval %{
         def #{name}(options={},&block)
           if @subtasks[#{name.dump}]
@@ -139,19 +141,19 @@ module RProgram
     end
 
     #
-    # Defines a non-option with the given _opts_.
+    # Defines a non-option with the given _options_.
     #
     #   non_option :name => 'input_file', :tailing => true
     #
     #   non_option :name => 'file', :tailing => true, :multiple => true
     #
-    def self.non_option(opts={})
-      name = opts[:name].to_sym
+    def self.non_option(options={})
+      name = options[:name].to_sym
 
-      self.non_options[name] = NonOption.new(opts)
+      self.non_options[name] = NonOption.new(options)
 
       class_def(name) do
-        if opts[:multiple]
+        if options[:multiple]
           @options[name] ||= []
         else
           @options[name]
@@ -164,15 +166,15 @@ module RProgram
     end
 
     #
-    # Defines a long-option with the specified _opts_.
+    # Defines a long-option with the specified _options_.
     #
-    # _opts_ must contain the following keys:
+    # _options_ must contain the following keys:
     # <tt>:flag</tt>:: The flag to use for the option.
     #
-    # _opts_ may also contain the following keys:
+    # _options_ may also contain the following keys:
     # <tt>:name</tt>:: The name of the option. Defaults to the
-    #                  flag_namify'ed form of <tt>opts[:flag]</tt>, if not
-    #                  given.
+    #                  flag_namify'ed form of <tt>options[:flag]</tt>,
+    #                  if not given.
     # <tt>:multiply</tt>:: Specifies that the option may appear multiple
     #                      times in the arguments.
     # <tt>:sub_options</tt>:: Specifies that the option contains multiple
@@ -182,20 +184,22 @@ module RProgram
     #
     #   long_option :flag => '-f', :name => :file
     #
-    def self.long_option(opts={},&block)
-      opts[:name] ||= Task.flag_namify(opts[:flag])
+    def self.long_option(options={},&block)
+      if (options[:name].nil? && options[:flag])
+        options[:name] = Task.flag_namify(options[:flag])
+      end
 
-      define_option(opts,&block)
+      return define_option(options,&block)
     end
 
     #
-    # Defines a short_option with the specified _opts_.
+    # Defines a short_option with the specified _options_.
     #
-    # _opts_ must contain the following keys:
+    # _options_ must contain the following keys:
     # <tt>:name</tt>:: The name of the option.
     # <tt>:flag</tt>:: The flag to use for the option.
     #
-    # _opts_ may also contain the following keys:
+    # _options_ may also contain the following keys:
     # <tt>:multiply</tt>:: Specifies that the option may appear multiple
     #                      times in the arguments.
     # <tt>:sub_options</tt>:: Specifies that the option contains multiple
@@ -203,32 +207,32 @@ module RProgram
     #
     #   short_option :flag => '-c', :name => :count
     #
-    def self.short_option(opts,&block)
-      define_option(opts,&block)
+    def self.short_option(options,&block)
+      define_option(options,&block)
     end
 
     #
-    # Defines an option with the specified _opts_ and the given _block_.
+    # Defines an option with the specified _options_ and the given _block_.
     #
-    # _opts_ must contain the following keys:
+    # _options_ must contain the following keys:
     # <tt>:name</tt>:: The name of the option.
     # <tt>:flag</tt>:: The flag to use for the option.
     #
-    # _opts_ may also contain the following keys:
+    # _options_ may also contain the following keys:
     # <tt>:multiply</tt>:: Specifies that the option may appear multiple
     #                      times in the arguments.
     # <tt>:sub_options</tt>:: Specifies that the option contains multiple
     #                  sub-options.
     #
-    def self.define_option(opts,&block)
-      method_name = opts[:name].to_sym
+    def self.define_option(options,&block)
+      method_name = options[:name].to_sym
 
-      self.options[method_name] = Option.new(opts,&block)
+      self.options[method_name] = Option.new(options,&block)
 
       class_def(method_name) do
-        if opts[:sub_options]
+        if options[:sub_options]
           @options[method_name] ||= OptionList.new
-        elsif opts[:multiple]
+        elsif options[:multiple]
           @options[method_name] ||= []
         else
           @options[method_name]
@@ -236,7 +240,7 @@ module RProgram
       end
 
       class_def("#{method_name}=") do |value|
-        if opts[:sub_options]
+        if options[:sub_options]
           @options[method_name] = OptionList.new(value)
         else
           @options[method_name] = value
@@ -250,19 +254,19 @@ module RProgram
     #   Task.flag_namify('--output-file')  # => "output_file"
     #
     def Task.flag_namify(flag)
-      flag = flag.to_s
+      flag = flag.to_s.downcase
 
       # remove leading dashes
-      if flag =~ /^--/
+      if flag[0..1] == '--'
         method_name = flag[2..-1]
-      elsif flag =~ /^-/
+      elsif flag[0..0] == '-'
         method_name = flag[1..-1]
       else
         method_name = flag
       end
 
       # replace remaining dashes with underscores
-      return method_name.gsub(/[-.]/,'_')
+      return method_name.gsub(/[-_\.\s]+/,'_')
     end
 
   end

data/lib/rprogram/version.rb

@@ -1,3 +1,3 @@
 module RProgram
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

data/spec/classes/aliased_program.rb

@@ -0,0 +1,10 @@
+require 'rprogram/nameable'
+
+class AliasedProgram
+
+  include RProgram::Nameable
+
+  name_program 'ls'
+  alias_program 'dir'
+
+end

data/spec/classes/ls_program.rb

@@ -0,0 +1,8 @@
+require 'rprogram/program'
+
+class LS < RProgram::Program
+
+  name_program 'ls'
+  alias_program 'dir'
+
+end

data/spec/classes/ls_selinux_task.rb

@@ -0,0 +1,7 @@
+require 'classes/ls_task'
+
+class LSSELinuxTask < LSTask
+
+  long_option :flag => '--lcontext', :name => :security_context
+
+end

data/spec/classes/ls_task.rb

@@ -0,0 +1,12 @@
+require 'rprogram/task'
+
+class LSTask < RProgram::Task
+
+  short_option :flag => '-a', :name => :all
+  long_option :flag => '--author'
+  long_option :flag => '--group-directories-first', :name => :group_dirs_first
+  long_option :flag => '--hide', :multiple => true
+
+  non_option :tailing => true, :multiple => true, :name => :files
+
+end

data/spec/classes/named_program.rb

@@ -0,0 +1,9 @@
+require 'rprogram/nameable'
+
+class NamedProgram
+
+  include RProgram::Nameable
+
+  name_program 'ls'
+
+end

data/spec/compat_spec.rb

@@ -0,0 +1,21 @@
+require 'rprogram/compat'
+
+require 'spec_helper'
+
+describe Compat do
+  it "should have a list of directories that contain programs" do
+    Compat.paths.should_not be_empty
+
+    Compat.paths.any? { |dir|
+      File.directory?(dir)
+    }.should == true
+  end
+
+  it "should be able to find programs" do
+    File.executable?(Compat.find_program('dir')).should == true
+  end
+
+  it "should be able to find programs by multiple names" do
+    File.executable?(Compat.find_program_by_names('ls','dir')).should == true
+  end
+end

data/spec/nameable_spec.rb

@@ -0,0 +1,55 @@
+require 'rprogram/nameable'
+
+require 'spec_helper'
+require 'classes/named_program'
+require 'classes/aliased_program'
+
+describe Nameable do
+  describe "named program" do
+    it "should be able to give a class a program name" do
+      NamedProgram.program_name.should == 'ls'
+    end
+
+    it "should not have any program aliases" do
+      NamedProgram.program_aliases.should be_empty
+    end
+
+    it "should have one program name" do
+      NamedProgram.program_names.should == ['ls']
+    end
+
+    it "should provide an instance method for the program name" do
+      obj = NamedProgram.new
+
+      obj.program_name.should == 'ls'
+    end
+
+    it "should provide an instance method for the program names" do
+      obj = NamedProgram.new
+
+      obj.program_names.should == ['ls']
+    end
+  end
+
+  describe "aliased program" do
+    it "should have program aliases" do
+      AliasedProgram.program_aliases.should == ['dir']
+    end
+
+    it "should have one program name" do
+      AliasedProgram.program_names.should == ['ls', 'dir']
+    end
+
+    it "should provide an instance method for the program aliases" do
+      obj = AliasedProgram.new
+
+      obj.program_aliases.should == ['dir']
+    end
+
+    it "should provide an instance method for the program names" do
+      obj = AliasedProgram.new
+
+      obj.program_names.should == ['ls', 'dir']
+    end
+  end
+end

data/spec/non_option_spec.rb

@@ -0,0 +1,48 @@
+require 'rprogram/non_option'
+
+require 'spec_helper'
+
+describe NonOption do
+  before(:all) do
+    @non_option = NonOption.new(:name => 'files')
+  end
+
+  it "should keep :leading and :tailing options mutually exclusive" do
+    leading = NonOption.new(:name => 'files', :leading => true)
+    tailing = NonOption.new(:name => 'files', :tailing => true)
+
+    leading.should be_leading
+    leading.should_not be_tailing
+
+    tailing.should_not be_leading
+    tailing.should be_tailing
+  end
+
+  it "should return an empty Array when passed nil" do
+    @non_option.arguments(nil).should == []
+  end
+
+  it "should return an empty Array when passed false" do
+    @non_option.arguments(false).should == []
+  end
+
+  it "should return an empty Array when passed []" do
+    @non_option.arguments([]).should == []
+  end
+
+  it "should return an Array when passed a single value" do
+    @non_option.arguments('foo').should == ['foo']
+  end
+
+  it "should return an Array when passed multiple values" do
+    @non_option.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']
+  end
+
+  it "should return an Array when passed a Hash of values" do
+    @non_option.arguments({:foo => 'bar'}).should == ['foo=bar']
+  end
+end

data/spec/option_examples.rb

@@ -0,0 +1,17 @@
+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 == []
+  end
+
+  it "should return an empty Array when passed false" do
+    @option.arguments(false).should == []
+  end
+
+  it "should return a single flag when passed true" do
+    @option.arguments(true).should == ['-f']
+  end
+end

data/spec/option_list_spec.rb

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

data/spec/option_spec.rb

@@ -0,0 +1,178 @@
+require 'rprogram/option'
+
+require 'spec_helper'
+require 'option_examples'
+
+describe Option do
+  describe "single flag" do
+    before(:all) do
+      @option = Option.new(:flag => '-f')
+    end
+
+    it_should_behave_like 'Option'
+
+    it "should render a single flag with an optional value" do
+      value = 'foo'
+
+      @option.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']
+    end
+
+    it "should render a single flag with a Hash of keys" do
+      value = {:foo => true, :bar => false}
+
+      @option.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']
+    end
+  end
+
+  describe "equals flag" do
+    before(:all) do
+      @option = Option.new(:equals => true, :flag => '-f')
+    end
+
+    it_should_behave_like 'Option'
+
+    it "should render a single flag with a value" do
+      value = 'foo'
+
+      @option.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']
+    end
+
+    it "should render a single flag with a Hash of keys" do
+      value = {:foo => true, :bar => false}
+
+      @option.arguments(value).should == ['-f=foo']
+    end
+  end
+
+  describe "multiple flags" do
+    before(:all) do
+      @option = Option.new(:multiple => true, :flag => '-f')
+    end
+
+    it_should_behave_like 'Option'
+
+    it "should render a single flag with a value" do
+      value = 'foo'
+
+      @option.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']
+    end
+
+    it "should render multiple flags for a Hash of keys" do
+      value = {:foo => true, :bar => true, :baz => false}
+      args = @option.arguments(value)
+      
+      (args & ['-f', 'foo']).should == ['-f', 'foo']
+      (args & ['-f', 'bar']).should == ['-f', 'bar']
+    end
+
+    it "should render multiple flags for a Hash of values" do
+      value = {:foo => 'bar'}
+
+      @option.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')
+    end
+
+    it_should_behave_like 'Option'
+
+    it "should render a single flag with a value" do
+      value = 'foo'
+
+      @option.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']
+    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.include?('-f=foo').should == true
+      args.include?('-f=bar').should == true
+    end
+
+    it "should render multiple equal flags for a Hash of values" do
+      value = {:foo => 'bar', :bar => 'baz'}
+      args = @option.arguments(value)
+
+      args.include?('-f=foo=bar').should == true
+      args.include?('-f=bar=baz').should == true
+    end
+  end
+
+  describe "separated values" do
+    before(:all) do
+      @option = Option.new(:separator => ',', :flag => '-f')
+    end
+
+    it_should_behave_like 'Option'
+
+    it "should render a single flag with a value" do
+      value = 'foo'
+
+      @option.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']
+    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[0].should == '-f'
+
+      sub_args = args[1].split(',')
+      
+      sub_args.include?('foo').should == true
+      sub_args.include?('bar').should == true
+    end
+
+    it "should render a single flag with a Hash of values" do
+      value = {:foo => 'bar', :bar => 'baz'}
+      args = @option.arguments(value)
+      
+      args[0].should == '-f'
+
+      sub_args = args[1].split(',')
+
+      sub_args.include?('foo=bar').should == true
+      sub_args.include?('bar=baz').should == true
+    end
+  end
+end