rprogram 0.0.9

data/History.txt

@@ -0,0 +1,8 @@
+== 0.0.9 / 2008-01-09
+
+* Initial release.
+* Provides cross-platform access to the PATH variable.
+* Supports mapping long and short options.
+* Supports mapping leading and tailing non-options.
+* Supports custom formating of options.
+

data/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/rprogram.rb
+lib/rprogram/version.rb
+lib/rprogram/compat.rb
+lib/rprogram/exceptions/program_not_found.rb
+lib/rprogram/exceptions.rb
+lib/rprogram/extensions/meta/object.rb
+lib/rprogram/extensions/meta.rb
+lib/rprogram/extensions.rb
+lib/rprogram/option.rb
+lib/rprogram/non_option.rb
+lib/rprogram/options.rb
+lib/rprogram/task.rb
+lib/rprogram/nameable.rb
+lib/rprogram/program.rb
+test/test_rprogram.rb

data/README.txt

@@ -0,0 +1,46 @@
+RProgram
+    by Postmodern Modulus III
+    http://rubyforge.org/projects/rprogram/
+
+== DESCRIPTION:
+  
+RProgram is a library for creating wrappers around command-line programs.
+RProgram provides a Rubyful interface to programs and all their options
+or non-options. RProgram can also search for programs installed on a
+system.
+
+== FEATURES/PROBLEMS:
+
+* Provides cross-platform access to the PATH variable.
+* Supports leading/tailing non-options.
+* Supports long-options and short-options.
+* Supports custom formating of options.
+  
+== INSTALL:
+
+  $ sudo gem install rprogram
+
+== LICENSE:
+
+The MIT License
+
+Copyright (c) 2008 Hal Brodigan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/rprogram/version.rb'
+
+Hoe.new('rprogram', RProgram::VERSION) do |p|
+  p.rubyforge_name = 'rprogram'
+  p.author = 'Postmodern Modulus III'
+  p.email = 'postmodern.mod3@gmail.com'
+  p.summary = 'RProgram is a library for creating ruby wrappers around command-line programs'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/rprogram/compat.rb

@@ -0,0 +1,58 @@
+module RProgram
+  module Compat
+    #
+    # Returns the native _platform_.
+    #
+    #   Compat.arch  #=> "linux"
+    #
+    def self.platform
+      RUBY_PLATFORM.split('-').last
+    end
+
+    #
+    # Returns an array representing the +PATH+ environment variable.
+    # If the +PATH+ environment variable is not setup, an empty array will
+    # be returned.
+    #
+    #   Compat.PATH  #=> ["/bin", "/usr/bin"]
+    #
+    def self.PATH
+      # return an empty array in case
+      # the PATH variable does not exist
+      return [] unless ENV['PATH']
+
+      if self.platform =~ /mswin32/
+        return ENV['PATH'].split(';')
+      else
+        return ENV['PATH'].split(':')
+      end
+    end
+
+    #
+    # Finds the program matching _name_ and returns it's full path.
+    # If the program was not found, +nil+ will be returned.
+    #
+    #   Compat.find_program('as')  #=> "/usr/bin/as"
+    #
+    def self.find_program(name)
+      self.PATH.each do |dir|
+        full_path = File.expand_path(File.join(dir,name))
+
+        return full_path if File.file?(full_path)
+      end
+
+      return nil
+    end
+
+    #
+    # Finds the program matching one of the names within _names_ and
+    # returns it's full path. If no program was found matching any of
+    # the names, the +nil+ will be returned.
+    #
+    #   Compat.find_program_by_names("gas","as")  #=> "/usr/bin/as"
+    #
+    def self.find_program_by_names(*names)
+      names.map { |name| self.find_program(name) }.compact.first
+    end
+  end
+end

data/lib/rprogram/exceptions/program_not_found.rb

@@ -0,0 +1,4 @@
+module RProgram
+  class ProgramNotFound < RuntimeError
+  end
+end

data/lib/rprogram/exceptions.rb

@@ -0,0 +1 @@
+require 'rprogram/exceptions/program_not_found'

data/lib/rprogram/extensions/meta/object.rb

@@ -0,0 +1,24 @@
+# metaprogramming assistant -- metaid.rb
+class Object # :nodoc:
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval(&blk); metaclass.instance_eval(&blk); end
+
+  # A class_eval version of meta_eval
+  def metaclass_eval(&blk); metaclass.class_eval(&blk); end
+  
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method(name, &blk) }
+  end
+
+  # Adds class methods to a metaclass
+  def metaclass_def(name, &blk)
+    metaclass_eval { define_method(name, &blk) }
+  end
+  
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method(name, &blk) }
+  end
+end

data/lib/rprogram/extensions/meta.rb

@@ -0,0 +1 @@
+require 'rprogram/extensions/meta/object.rb'

data/lib/rprogram/extensions.rb

@@ -0,0 +1 @@
+require 'rprogram/extensions/meta'

data/lib/rprogram/nameable.rb

@@ -0,0 +1,67 @@
+require 'rprogram/extensions/meta'
+require 'rprogram/compat'
+
+module RProgram
+  module Nameable
+    def self.included(base)
+      base.metaclass_eval do
+        def program_name
+          @program_name
+        end
+
+        def program_name=(name)
+          @program_name = name.to_s
+        end
+
+        def program_aliases
+          @program_aliases ||= []
+        end
+
+        def program_aliases=(aliases)
+          @program_aliases = aliases.to_a.map { |name| name.to_s }
+        end
+
+        def find_program
+          names = self.program_aliases
+          names.unshift(self.program_name) if self.program_name
+
+          return Compat.find_program_by_names(*names)
+        end
+      end
+    end
+
+    #
+    # Returns the program name of a class.
+    #
+    def program_name
+      self.class.program_name
+    end
+
+    #
+    # Returns the program aliases.
+    #
+    def program_aliases
+      self.class.program_aliases
+    end
+
+    protected
+
+    #
+    # Sets the program name for a class to the specified _name_.
+    #
+    #   name_program 'ls'
+    #
+    def Object.name_program(name)
+      self.program_name = name
+    end
+
+    #
+    # Sets the program aliases for a class to the specified _aliases_.
+    #
+    #   name_program 'vim', 'vi'
+    #
+    def Object.alias_program(*aliases)
+      self.program_aliases = aliases
+    end
+  end
+end

data/lib/rprogram/non_option.rb

@@ -0,0 +1,41 @@
+module RProgram
+  class NonOption
+
+    # Name of the argument(s)
+    attr_reader :name
+
+    # Is the argument a leading argument(s)
+    attr_reader :leading
+
+    # Is the argument a tailing argument(s)
+    attr_reader :tailing
+
+    # Can the argument be specified multiple times
+    attr_reader :multiple
+
+    def initialize(opts={:name => nil, :leading => false, :tailing => false, :multiple => false})
+      @name = opts[:name]
+
+      @leading = opts[:leading] || false
+      @tailing = opts[:tailing] || true
+      @multiple = opts[:multiple] || false
+    end
+
+    def arguments(value)
+      return [] if (value==nil || value==false)
+
+      if value.kind_of?(Hash)
+        return value.map { |name,value| "#{name}=#{value}" }
+      elsif value.kind_of?(Array)
+        if @multiple
+          return value.compact
+        else
+          return value.join
+        end
+      else
+        return [value]
+      end
+    end
+
+  end
+end

data/lib/rprogram/option.rb

@@ -0,0 +1,59 @@
+module RProgram
+  class Option
+
+    # Flag of the option
+    attr_reader :flag
+
+    # Is the option in equals format
+    attr_reader :equals
+
+    # Can the option be specified multiple times
+    attr_reader :multiple
+
+    def initialize(opts={:flag => nil, :equals => false, :multiple => false},&block)
+      @flag = opts[:flag]
+
+      @equals = opts[:equals] || false
+      @multiple = opts[:multiple] || false
+
+      @formating = block
+    end
+
+    def arguments(value)
+      return [@flag] if value==true
+      return [] if (value==nil || value==false)
+
+      if value.kind_of?(Hash)
+        value = value.map { |name,value| "#{name}=#{value}" }
+      elsif value.kind_of?(Array)
+        value = value.compact
+      end
+
+      if @multiple
+        args = []
+
+        value.each { |arg| args += format(arg) }
+        return args
+      else
+        return format(value)
+      end
+    end
+
+    protected
+
+    def default_format(value)
+      return [@flag] + value if value.kind_of?(Array)
+      return ["#{flag}=#{value}"] if @equals
+      return [@flag, value]
+    end
+
+    def format(value)
+      if @formating
+        return @formating.call(@flag,value).to_a
+      else
+        return default_format(value)
+      end
+    end
+
+  end
+end

data/lib/rprogram/options.rb

@@ -0,0 +1,83 @@
+require 'rprogram/extensions/meta'
+require 'rprogram/non_option'
+require 'rprogram/option'
+
+module RProgram
+  module Options
+    def self.included(base)
+      base.metaclass_eval do
+        def non_options
+          @non_options ||= {}
+        end
+
+        def has_non_option?(name)
+          name = name.to_sym
+
+          ancestors.each do |base|
+            if base.include?(Options)
+              return true if base.non_options.include?(name)
+            end
+          end
+
+          return false
+        end
+
+        def get_non_option(name)
+          name = name.to_sym
+
+          ancestors.each do |base|
+            if base.include?(Options)
+              return base.non_options[name] if base.non_options.has_key?(name)
+            end
+          end
+
+          return nil
+        end
+
+        def options
+          @options ||= {}
+        end
+
+        def has_option?(name)
+          name = name.to_sym
+
+          ancestors.each do |base|
+            if base.include?(Options)
+              return true if base.options.has_key?(name)
+            end
+          end
+
+          return false
+        end
+
+        def get_option(name)
+          name = name.to_sym
+
+          ancestors.each do |base|
+            if base.include?(Options)
+              return base.options[name] if base.options.has_key?(name)
+            end
+          end
+
+          return nil
+        end
+      end
+    end
+
+    def has_non_option?(name)
+      self.class.has_non_option?(name)
+    end
+
+    def get_non_option(name)
+      self.class.get_non_option(name)
+    end
+
+    def has_option?(name)
+      self.class.has_option?(name)
+    end
+
+    def get_option(name)
+      self.class.get_option(name)
+    end
+  end
+end

data/lib/rprogram/program.rb

@@ -0,0 +1,105 @@
+require 'rprogram/compat'
+require 'rprogram/task'
+require 'rprogram/exceptions/program_not_found'
+
+module RProgram
+  class Program
+
+    # Path to the program
+    attr_reader :path
+
+    # Name of the program
+    attr_reader :name
+
+    #
+    # Creates a new Program object from _path_. If _block_ is given, it will
+    # be passed the newly created Program.
+    #
+    #   Program.new('/usr/bin/ls')
+    #
+    def initialize(path,&block)
+      @path = File.expand_path(path)
+      @name = File.basename(@path)
+    end
+
+    #
+    # Finds the program with the specified _name_ and returns a new
+    # Program object. If no programs could be found with the matching _name_,
+    # a ProramNotFound exception will be raised.
+    #
+    #   Program.find_by_name('cat') # => Program
+    #
+    def self.find_by_name(name)
+      path = Compat.find_program(name)
+      unless path
+        raise(ProgramNotFound,"program '#{name}' could not be found",caller)
+      end
+
+      return self.new(path)
+    end
+
+    def self.find_by_names(*names)
+      path = Compat.find_program_by_names(*names)
+
+      unless path
+        names = names.map { |name| name.dump }.join(', ')
+
+        raise(ProgramNotFound,"programs #{names} were not be found",caller)
+      end
+
+      return self.new(path)
+    end
+
+    #
+    # Creates a new Program object with the specified _path_,
+    # if _path_ is a valid file.
+    #
+    #   Program.create_from_path('/bin/cd') # => Program
+    #
+    #   Program.create_from_path('/obviously/fake') # => nil
+    #
+    def self.create_from_path(path)
+      return self.new(path) if File.file?(path)
+    end
+
+    def self.create_from_paths(*paths)
+      paths.each do |path|
+        return self.new(path) if File.file?(path)
+      end
+    end
+
+    #
+    # Runs the program with the specified _args_ and returns
+    # an Array of the programs output.
+    #
+    #   echo = Program.find_by_name('echo')
+    #   echo.run("hello") # => ["hello\n"]
+    #
+    def run(*args)
+      command = [@path] + args
+
+      IO.popen(command.join(' ')) do |process|
+        return process.readlines
+      end
+    end
+
+    #
+    # Runs the program with the specified _task_ object.
+    #
+    def run_task(task)
+      run(*(task.arguments))
+    end
+
+    #
+    # Returns the path of the program.
+    #
+    #   puts Program.find_by_name('echo')
+    #   /usr/bin/echo
+    #   # => nil
+    #
+    def to_s
+      @path.to_s
+    end
+
+  end
+end

data/lib/rprogram/task.rb

@@ -0,0 +1,233 @@
+require 'rprogram/options'
+
+module RProgram
+  class Task
+
+    include Options
+
+    #
+    # Creates a new Task object with the given _options_. If a block is
+    # given, it is passed the newly created Task object.
+    #
+    #   Task.new(:test => 'example', :count => 2, :verbose => true)
+    #   Task.new(:help => true) { |task| ... }
+    #
+    def initialize(options={},&block)
+      @subtasks = {}
+      @options = options
+
+      block.call(self) if block
+    end
+
+    #
+    # Returns the compiled _arguments_ from a Task object created
+    # with the given _options_ and _block_.
+    #
+    #   MyTask.arguments(:verbose => true, :count => 2)
+    #
+    #   MyTask.arguments do |task|
+    #     task.verbose = true
+    #     task.file = 'output.txt'
+    #   end
+    #
+    def self.arguments(options={},&block)
+      self.new(options,&block).arguments
+    end
+
+    #
+    # Returns an array of _arguments_ generated from all the leading
+    # non-options of the task and it's sub-tasks.
+    #
+    def leading_non_options
+      args = []
+
+      # add the task leading non-options
+      @options.each do |name,value|
+        non_opt = get_non_option(name)
+
+        if (non_opt && non_opt.leading)
+          args += non_opt.arguments(value)
+        end
+      end
+
+      # add all leading subtask non-options
+      @subtasks.each_value do |task|
+        args += task.leading_non_options
+      end
+
+      return args
+    end
+
+    #
+    # Returns an array of _arguments_ generated from all the options
+    # of the task and it's sub-tasks.
+    #
+    def options
+      args = []
+
+      # add all subtask options
+      @subtasks.each_value do |task|
+        args += task.arguments
+      end
+
+      # add the task options
+      @options.each do |name,value|
+        opt = get_option(name)
+        args += opt.arguments(value) if opt
+      end
+
+      return args
+    end
+
+    #
+    # Returns an array of _arguments_ generated from all the tailing
+    # non-options of the task and it's sub-tasks.
+    #
+    def tailing_non_options
+      args = []
+
+      # add all tailing subtask non-options
+      @subtasks.each_value do |task|
+        args += task.tailing_non_options
+      end
+
+      # add the task tailing non-options
+      @options.each do |name,value|
+        non_opt = get_non_option(name)
+
+        if (non_opt && non_opt.tailing)
+          args += non_opt.arguments(value)
+        end
+      end
+
+      return args
+    end
+
+    #
+    # Returns an array of _arguments_ compiled from the _arguments_ of
+    # the tasks leading non_options, options and tailing non-options.
+    #
+    def arguments
+      leading_non_options + options + ['--'] + tailing_non_options
+    end
+
+    protected
+
+    #
+    # Defines a sub-task of _name_ and class of _task_.
+    #
+    #   subtask :extra, ExtraTask
+    #
+    def Object.subtask(name,task)
+      class_eval %{
+        def #{name}(options={},&block)
+          if @subtasks[#{name.dump}]
+            @subtasks[#{name.dump}].options.merge!(options)
+
+            block.call(@subtasks[#{name.dump}]) if block
+          else
+            @subtasks[#{name.dump}] = #{task}.new(options,&block)
+          end
+
+          return @subtasks[#{name.dump}]
+        end
+      }
+    end
+
+    #
+    # Defines a non-option with the given _opts_.
+    #
+    #   non_option :name => 'input_file', :tailing => true
+    #
+    #   non_option :name => 'file', :tailing => true, :multiple => true
+    #
+    def Object.non_option(opts={})
+      name = opts[:name].to_sym
+
+      self.non_options[name] = NonOption.new(opts)
+
+      class_def(name) do
+        if opts[:multiple]
+          @options[name] ||= []
+        else
+          @options[name]
+        end
+      end
+
+      class_def("#{name}=") do |value|
+        @options[name] = value
+      end
+    end
+
+    #
+    # Defines a long-option with the given _opts_.
+    #
+    #   long_option :flag => '--output'
+    #
+    #   long_option :flag => '-f', :name => :file
+    #
+    def Object.long_option(opts={},&block)
+      flag = opts[:flag].to_s
+      method_name = (opts[:name] || Task.flag_namify(flag)).to_sym
+
+      self.options[method_name] = Option.new(opts,&block)
+
+      class_def(method_name) do
+        if opts[:multiple]
+          @options[method_name] ||= []
+        else
+          @options[method_name]
+        end
+      end
+
+      class_def("#{method_name}=") do |value|
+        @options[method_name] = value
+      end
+    end
+
+    #
+    # Defines a short_option with the given _opts_.
+    #
+    #   short_option :flag => '-c', :name => :count
+    #
+    def Object.short_option(opts={},&block)
+      method_name = opts[:name].to_sym
+
+      self.options[method_name] = Option.new(opts,&block)
+
+      class_def(method_name) do
+        if opts[:multiple]
+          @options[method_name] ||= []
+        else
+          @options[method_name]
+        end
+      end
+
+      class_def("#{method_name}=") do |value|
+        @options[method_name] = value
+      end
+    end
+
+    #
+    # Converts a long-option flag to a Ruby method name.
+    # 
+    #   Task.flag_namify('--output-file')  #=> "output_files"
+    #
+    def Task.flag_namify(flag)
+      flag = flag.to_s
+
+      # remove leading dashes
+      if flag =~ /^--/
+        method_name = flag[2..-1]
+      elsif flag =~ /^-/
+        method_name = flag[1..-1]
+      else
+        method_name = flag
+      end
+
+      # replace remaining dashes with underscores
+      return method_name.gsub(/[-.]/,'_')
+    end
+
+  end
+end

data/lib/rprogram/version.rb

@@ -0,0 +1,3 @@
+module RProgram
+  VERSION = '0.0.9'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: rprogram
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+date: 2008-01-09 00:00:00 -08:00
+summary: RProgram is a library for creating ruby wrappers around command-line programs
+require_paths: 
+- lib
+email: postmodern.mod3@gmail.com
+homepage: "    by Postmodern Modulus III"
+rubyforge_project: rprogram
+description: "== FEATURES/PROBLEMS:  * Provides cross-platform access to the PATH variable. * Supports leading/tailing non-options. * Supports long-options and short-options. * Supports custom formating of options.  == INSTALL:  $ sudo gem install rprogram  == LICENSE:"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Postmodern Modulus III
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/rprogram.rb
+- lib/rprogram/version.rb
+- lib/rprogram/compat.rb
+- lib/rprogram/exceptions/program_not_found.rb
+- lib/rprogram/exceptions.rb
+- lib/rprogram/extensions/meta/object.rb
+- lib/rprogram/extensions/meta.rb
+- lib/rprogram/extensions.rb
+- lib/rprogram/option.rb
+- lib/rprogram/non_option.rb
+- lib/rprogram/options.rb
+- lib/rprogram/task.rb
+- lib/rprogram/nameable.rb
+- lib/rprogram/program.rb
+- test/test_rprogram.rb
+test_files: 
+- test/test_rprogram.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: