dotopts 0.1.3 → 0.2.0

data/.index

@@ -49,7 +49,7 @@ paths:
 created: '2013-01-23'
 summary: Automatic Arguments for Ruby
 title: DotOpts
-version: 0.1.3
+version: 0.2.0
 name: dotopts
 description: DotOpts is an automatic commandline argument augmenter for Ruby tools.
-date: '2013-01-29'
+date: '2013-02-16'

data/HISTORY.md

@@ -1,5 +1,22 @@
 # RELEASE HISTORY
 
+## 0.2.0 / 2013-02-16
+
+Rethought overall design and reimplemented parser. The syntax of option
+files is essentially the same, but now arguments are only applied if
+there are no arguments provided on the command line. In other words,
+it is assumed that if the user supplies their own arguments, then
+they don't require any from DotOpts. This redesign prevents a lot of
+potential headaches with how prepend/append options can interact 
+with options proved by the end user. In the future, we might adds some
+additional flexibility, of argument substitutions.
+
+Changes:
+
+* Rethink when arguments are applied.
+* Reimplemented parser.
+
+
 ## 0.1.3 / 2013-01-30
 
 Environment settings were not being applied. This release improves the code

data/README.md

@@ -1,6 +1,6 @@
 # DotOpts
 
-**Automated Commandline Options (for Ruby Executables)**
+**Automated Command-line Options (for Ruby Executables)**
 
 [Website](http://rubyworks.github.com/dotopts) /
 [Report Issue](http://github.com/rubyworks/dotopts/issues) /
@@ -10,9 +10,9 @@
 
 ## About
 
-DotOpts is an automatic commandline argument augmenter. It looks for a
-project's local `.option` configuration file and applies the appropriate
-arguments when a matching command is invoked.
+DotOpts is an automatic command-line argument augmenter. It looks for a
+project's local `.option` (or `.opts`) configuration file and applies the 
+appropriate arguments when a matching command is invoked.
 
 
 ## Features
@@ -21,28 +21,37 @@ arguments when a matching command is invoked.
 * Can be used to set environment variables in addition to arguments.
 * Supports environment variable substitution.
 * Supports conditional augmentation using environment settings.
-* Simple and easy to use plain-text configuration format.
+* Simple and easy to understand plain-text configuration format.
 
 
 ## Install
 
-DotOpts can be install via RubyGems:
+If you are using an application that depends on DotOpts for configuration,
+there is nothing you have to do. Installing the said application via
+RubyGems should also install DotOpts and require it as needed.
+
+### General Setup
+
+To use DotOpts universally, even for command-line applications that do not
+directly utilize it, you can install DotOpts via RubyGems:
 
     gem install dotopts
 
-There are two wasy to setup DotOpts for use by all Ruby tools (regardless
-of whether they have built-in support for DotOpts or not). The most
-univeral approach is to add `-rdotopts` to you `RUBYOPT` environment
-variable.
+Then add `-rdotopts` to your `RUBYOPT` environment variable.
 
     export RUBYOPT="-rdotopts"
 
-This ensures DotOpts is required whenever Ruby is used. The other
-approach is to use Bundler by adding DotOpts to your project's Gemfile.
+This ensures DotOpts is used whenever Ruby is used.
+
+### Special Setup
+
+Another approach is to use DotOpts per-project development project using
+via Bundler, adding DotOpts to your project's Gemfile.
 
     gem 'dotopts'
 
-This will allow dotopts to run whenever using `bundle exec`.
+This will allow DotOpts to work whenever using `bundle exec` or Bundler
+created binstub.
 
 
 ## Usage
@@ -55,9 +64,9 @@ A simple example of a projects `.option` file:
     yard doc
       --title="Bad Ass Program"
 
-This simply says, that whenever `yardoc` or `yard doc` is executed then
-add the `--title="Bad Ass Program"` argument to the end of the command
-line arguments (internally `ARGV`).
+This simply says, that whenever `yardoc` or `yard doc` is executed, and
+no other arguments are given, then add the `--title="Bad Ass Program"`
+argument to the end of the command's arguments (internally `ARGV`).
 
 
 ### Setting Environment Variables
@@ -67,7 +76,7 @@ lines with `$ `.
 
     yardoc
     yard doc
-      $ RUBYOPTS="-rbadass"
+      $ RUBYOPT="-rbadass"
       --title="Bad Ass Program"
 
 The space after the cash sign is important! Otherwise it will be interpreted 
@@ -76,16 +85,16 @@ as a variable substitution.
 
 ### Conditional Profiles
 
-The `.option` configuration file support profiles via the square brackets.
+The `.option` configuration file supports profiles via the square brackets.
 Profiles are chosen via the `$profile` or `$p` environment variable.
 
 ```
   [coverage]
   rubytest
-    -r simplecov
+    -r microtest
 ```
 
-So the above means that `-r simplecov` should be added the argument list when
+So the above means that `-r micortest` should be added the argument list when
 `rubytest` is executed, but only if `$profile` or `$p` is equal to `"coverage"`.
 
 Square brackets can also be used to match against any environment variable
@@ -104,38 +113,38 @@ to the square brackets separated by a space.
   [coverage RUBY_ENGINE=jruby]
   rubytest
     -r jruby-sandbox
-    -r simplecov
+    -r microtest
 ```
 
 Finally, environment values can be matched against simple regular expressions
-using a tilde (`~`) before the value. Be sure to out the value in quotes when
+using a tilde (`~`) before the value. Be sure to put the value in quotes when
 using regular expressions.
 
 ```
   [~"cov(erage)?" RUBY_ENGINE=~"jruby|rubinius"]
   rubytest
     -r jruby-sandbox
-    -r simplecov
+    -r microtest
 ```
 
 ### Tool Support
 
-Ruby tool developers can support dotopts out-of-the-box simple by running
-`require 'dotopts'` in their program before parsing the commandline. DotOpts
-simply injects arguments into `ARGV` so it can work with any commandline
-option parser.
+Ruby tool developers can support DotOpts out-of-the-box simple by running
+`require 'dotopts'` in their program before parsing ARGV. DotOpts
+simply injects arguments into `ARGV` so it can work with any command-line
+options parser.
 
 
 ## Development
 
 ### Suggestions & Contributions
 
-DotOpts is a brand new application, and still rather wet behind the years, so to
+DotOpts is a brand new application, and still rather wet behind the ears, so to
 speak. So your input is critical to making it better. Any and all suggestions and
 contributions are much appreciated. If you have any ideas on how to improve DotOpts,
 or find any flaws in its design that need address, please drop a comment on the
 [Issues](http://github.com/rubyworks/dotopts/issues) page. Or even better, be proactive!
-Fork the project submit a pull request. Thanks.
+Fork the project and submit a pull request. Thanks.
 
 ### Universal Solution?
 

data/demo/applique/battery.rb

@@ -15,14 +15,19 @@ When 'we run `/(.*?)/`' do |command|
   end
 
   ENV['cmd'] = args.shift
-
   ARGV.replace(args)
 
-  @opts_parser = DotOpts::Parser.parse(@opts_text)
+  DotOpts.configure!(@opts_text)
 end
 
 When 'we should get the arguments' do |text|
+  #opts_args = []
+  #@opts_cmds.each do |c|
+  #  next unless c.current?
+  #  opts_args += c.arguments
+  #end
+
   args = text.split("\n").map{ |x| x.strip }
-  args.assert == @opts_parser.arguments
+  args.assert == ARGV #opts_args
 end
 

data/lib/dotopts/api.rb

@@ -1,36 +1,46 @@
 module DotOpts
   require 'dotopts/parser'
 
-  # Configuration file name.
-  OPTIONS_FILE = '.option'
+  # Configuration file names.
+  #
+  # @note Sorry, I could not decide between these two.
+  OPTIONS_FILES = ['.opts', '.option']
 
   # Configure
   #
   # @param [String] file
   #   The configuration file to load. (optional)
   #
-  # @return nothing
-  def self.configure!(file=nil)
-    file = options_file unless file
-    if file
-      text   = File.read(file)
-      parser = Parser.parse(text)
-
-      argv = parser.arguments
-      env  = parser.environment
-
-      debug(file, argv, env)
-      apply(argv, env)
+  # @return [void]
+  def self.configure!(io=nil)
+    text, file = read_config(io)
+
+    if text
+      cmds = Parser.parse(text)
+
+      applicable = cmds.select do |c|
+        c.current?
+      end
+
+      applicable.each do |c|
+        argv = c.arguments
+        env  = c.environment
+
+        debug(file, argv, env)
+        apply(argv, env)
+      end
     end
   end
 
   # Returns the options file of the current project.
   #
-  # @return {String] The options file of the project.
+  # @return [String] The options file of the project.
   def self.options_file
     if project_root
-      file = File.join(project_root, OPTIONS_FILE)
-      return file if File.exist?(file)
+      OPTIONS_FILES.each do |optfile|
+        file = File.join(project_root, optfile)
+        return file if File.exist?(file)
+      end
     end
   end
 
@@ -41,8 +51,10 @@ module DotOpts
     dir  = start_dir
     home = File.expand_path('~')
     until dir == home || dir == '/'
-      if file = Dir[File.join(dir, '{.ruby,.git,.hg}')].first
-        return dir
+      OPTIONS_FILES.each do |optfile|
+        if File.exist?(File.join(dir, optfile))
+          return dir
+        end
       end
       dir = File.dirname(dir)
     end
@@ -51,17 +63,16 @@ module DotOpts
 
   # Apply arguments and environment options.
   #
-  # TODO: Support argument prepending in future version?
-  #
-  # @return nothing
+  # @return [void]
   def self.apply(argv, env={})
-    env.each{ |k,v|  ENV[k.to_s] = v.to_s }
+    env.each{ |k,v| ENV[k.to_s] = v.to_s }
     ARGV.concat(argv)
+    #ARGV.replace(argv + ARGV)
   end
 
   # Print message to stderr if dopts_debug flag it set.
   #
-  # @return nothing
+  # @return [void]
   def self.debug(file, argv, env)
     return unless ENV['dotopts_debug'] 
 
@@ -78,4 +89,29 @@ module DotOpts
     end
   end
 
+  # Take an IO object and read it in. If it is a File
+  # object also return the file name. Strings are passed
+  # through untouched.
+  #
+  # @return [Array<String>]
+  def self.read_config(io)
+    text, file = nil, '(io)'
+
+    case io
+    when String
+      text = io
+    when File
+      text = io.read
+      file = io.path
+    when nil
+      if file = options_file
+        text = File.read(file)
+      end
+    else
+      text = io.read
+    end
+
+    return text, file
+  end
+
 end

data/lib/dotopts/command.rb

@@ -0,0 +1,149 @@
+module DotOpts
+
+  # Get the current command.
+  #
+  # @note This is take from basename of `$0`. In the future, we may
+  #       need to find a way to tweak this to somehow include parrent
+  #       directories.
+  #
+  # @todo Is ENV['cmd'] okay? Maybe ['dotopts_command'] would be better?
+  def self.command
+    ENV['cmd'] || File.basename($0)
+  end
+
+  ##
+  # Command class encapsulate a configuration for a given command and
+  # a given profile.
+  #
+  class Command
+
+    # Initialize new instance of Command.
+    #
+    # @param [String] name
+    #   The name of the command. Can include subcommand, e.g. `yard doc`.
+    #
+    # @option settings [String,nil] :profile
+    #   The profile for which this command configuation would be applicable.
+    #
+    # @return [void]
+    def initialize(name, settings={})
+      @name = name
+
+      self.profile = settings[:profile]
+
+      @arguments   = []
+      @environment = {}
+    end
+
+    # Command name. [String]
+    attr :name
+
+    # Profile designation.
+    #
+    # @return [String,nil]
+    def profile
+      @profile
+    end
+
+    # Set profile designation.
+    #
+    # @param [String,nil] 
+    #   The profile designation.
+    #
+    # @return [String,nil]
+    def profile=(profile)
+      @profile = profile ? profile.to_str : nil  #? shellwords(profile).first : nil
+    end
+
+    # Environment settings.
+    #
+    # @return [Hash]
+    def environment
+      @environment
+    end
+
+    # Arguments.
+    #
+    # @return [Array]
+    def arguments
+      @arguments
+    end
+
+    # Add argument or environment entries to command.
+    #
+    # TODO: Is there too much "parsing" going on here?
+    #       Should some of this be in Parser instead?
+    def <<(entry)
+      entry = entry.strip
+      if entry.start_with?('$ ')
+        # environment
+        entry.sub!(/\$\s+/, '')
+        shellwords(entry).each do |s|
+          name, value = s.split('=')
+          @environment[name] = subenv(value) unless name.empty?
+        end
+      else
+        # argument
+        shellwords(entry).each do |s|
+          @arguments << subenv(s) unless s.empty?
+        end
+      end
+    end
+
+    # Is the command applicable to the current command line?
+    #
+    # @return [Boolean]
+    def current?
+      command? && profile?
+    end
+
+    # Does the command's name match the current command?
+    #
+    # @return [Boolean]
+    def command?
+      this = @name.split(' ')
+      real = [DotOpts.command, *ARGV][0,this.size]
+      this == real && ARGV.size < this.size  # no other arguments
+    end
+
+    # Does the command's profile match the current environment?
+    #
+    # @return [Boolean]
+    def profile?
+      shellwords(profile || "").all? do |sw|
+        case sw
+        when /^\~/
+          true if Regexp.new(sw.sub('~','')) === (ENV['profile'] || ENV['p']).to_s
+        when /=~/
+          name, value = sw.split('=~')
+          #name = 'profile' if name.empty?
+          true if Regexp.new(value) === ENV[name]
+        when /=/
+          name, value = sw.split('=')
+          #name = 'profile' if name.empty?
+          true if subenv(value) == ENV[name]
+        else
+          true if sw.to_s == (ENV['profile'] || ENV['p']).to_s
+        end
+      end
+    end
+
+  private
+
+    # Split a string up into shellwords.
+    #
+    # @return [Array]
+    def shellwords(value)
+      Shellwords.shellwords(value)
+    end
+
+    # Substitute environment variables.
+    #
+    # @return [String]
+    def subenv(value)
+      value.gsub(/\$(\w+)/){ |m| ENV[$1] }
+    end
+
+  end
+
+end

data/lib/dotopts/parser.rb

@@ -2,15 +2,22 @@ module DotOpts
 
   class Parser
     require 'shellwords'
+    require_relative 'command'
 
     # Regular expression to match profile headers.
-    RE_PROFILE_HEADER = /^\[/
+    RE_PROFILE = /^\[(.*)\]/
 
     # Regular expression to match command headers.
-    RE_COMMAND_HEADER = /^\w/
+    RE_COMMAND = /^\w/
+
+    # Regular expression to match arguments.
+    RE_ARGUMENT = /^\s+\S+/
+
+    # Regular expression to match environment setting.
+    RE_ENVIRONMENT = /^\s+\$/
 
     # Regular expression to match blank strings.
-    RE_BLANK_STRING = /^\s*$/
+    RE_BLANK = /^\s*$/
 
     # Convenience constructor for `new(text).parse`.
     #
@@ -18,7 +25,7 @@ module DotOpts
     def self.parse(text)
       parser = new(text)
       parser.parse
-      parser
+      parser.commands
     end
 
     # Initialize new instance.
@@ -27,43 +34,120 @@ module DotOpts
     #
     def initialize(text)
       @text = text.to_s
-      @arguments = []
-      @environment = {}
-    end
 
-    # The configuration document text.
-    attr :text
+      #
+      @commands = []
 
-    # The applicable arguments parsed from the config text.
-    attr :arguments
+      # Holds the current commands being parsed.
+      @_commands = []
+      @_profiles = []
+    end
+
+    #
+    attr :commands
 
-    # The applicable environment parsed from the config text.
-    attr :environment
+    # The configuration document text. [String]
+    attr :text
 
     # Parse the configuration text.
+    #
+    #
     def parse
       lines = @text.lines.to_a
 
-      remove_initial_blank_lines(lines)
+      remove_blanks(lines)
 
       # put initial non-profiled settings last 
-      if lines.first !~ RE_PROFILE_HEADER
-        index = lines.index{ |line| line =~ RE_PROFILE_HEADER }
-        if index
-          lines = lines[index..-1] + ['[]'] + lines[0...index]
+      #if lines.first !~ RE_PROFILE
+      #  index = lines.index{ |line| line =~ RE_PROFILE }
+      #  if index
+      #    lines = lines[index..-1] + ['[]'] + lines[0...index]
+      #  else
+      #    #lines = ['[]'] + lines
+      #  end
+      #end
+
+      parse_profiles(lines)
+    end
+
+    #
+    #
+    #
+    def parse_profiles(lines)
+      @_profiles = []
+      until lines.empty?
+        line = lines.first.rstrip
+        case line
+        when RE_BLANK
+          lines.shift
+        when RE_PROFILE
+          @_profiles << $1
+          lines.shift
         else
-          lines = ['[]'] + lines
+          #@_commands = []
+          parse_command(lines)
         end
       end
+    end
 
-      parse_profiles(lines)
+    # Parse lines from command onward until another profile
+    # or end of document is reached.
+    #
+    # @return [void]
+    def parse_command(lines)
+      previous = nil
+      while line = lines.first
+        case line
+        when RE_BLANK
+        when RE_COMMAND
+          if previous != :command
+            @commands.concat @_commands
+            @_commands = []
+          end
+          if @_profiles.empty?
+            @_commands << Command.new(line.strip, :profile=>nil)
+          else
+            @_profiles.each do |profile|
+              @_commands << Command.new(line.strip, :profile=>profile)
+            end
+          end
+          previous = :command
+        when RE_ARGUMENT, RE_ENVIRONMENT
+          if @_commands.empty?
+            raise SyntaxError, "no command before arguments\n@ #{line}"
+          end
+          @_commands.each{ |c| c << line }
+          previous = :argument
+        when RE_PROFILE
+          @commands.concat @_commands
+          @_commands = []
+          @_profiles = []
+          return
+        end
+        lines.shift
+      end
+      @commands.concat @_commands
     end
 
+    # Remove intialize blank lines for an array of strings.
+    #
+    # @param [Array<String>] lines
+    #
+    # @return [Array<String>]
+    def remove_blanks(lines)
+      lines.shift while RE_BLANK =~ lines.first
+    end
+
+  end
+
+end
+
+=begin
     # Parse profiles.
     def parse_profiles(lines)
       until lines.empty?
         line = lines.first.rstrip
-        if md = RE_PROFILE_HEADER.match(line)
+        if md = RE_PROFILE_HEADER.match(line)  # TODO: this is a bit wanky
           profile = md.post_match.chomp(']')
           matches = shellwords(profile).all? do |shellword|
             case shellword
@@ -146,30 +230,8 @@ module DotOpts
     def current_command
       ENV['cmd'] || File.basename($0)
     end
-
-    # Substitute environment variables.
-    #
-    # @return [String]
-    def subenv(value)
-      value.gsub(/\$(\w+)/){ |m| ENV[$1] }
-    end
-
-    # Split a string up into shellwords.
-    #
-    # @return [Array]
-    def shellwords(value)
-      Shellwords.shellwords(value)
-    end
-
-    # Remove intialize blank lines for an array of strings.
-    #
-    # @param [Array<String>] lines
-    #
-    # @return [Array<String>]
-    def remove_initial_blank_lines(lines)
-      lines.shift while RE_BLANK_STRING =~ lines.first
-    end
-
   end
 
 end
+
+=end

data/spec/helper.rb

@@ -1,6 +1,19 @@
+if ENV['RUBYOPT'].to_s.include?('-rdotopts')
+  abort "Remove `-rdotopts` from RUBYOPT environment first."
+end
+
 require 'spectroscope'
 require 'ae'
 
+#if ENV['cov']
+#  require 'simplecov'
+#  SimpleCov.command_name File.basename($0)
+#  SimpleCov.start do
+#    add_filter "spec/"
+#    coverage_dir 'log/coverage'
+#  end
+#end
+
 require 'dotopts/api'
 
 module Kernel

data/spec/spec_api.rb

@@ -3,15 +3,27 @@ require_relative "helper"
 describe DotOpts do
 
   it "can configure!" do
-    ENV['cmd'] = 'yard'  # FIXME: try `foo` and watch what happens
+    ENV['cmd'] = 'yard'
+    ARGV.replace([])
 
     example_avex_file = File.dirname(__FILE__) + '/fixtures/yard.opts'
 
-    DotOpts.configure!(example_avex_file)
+    DotOpts.configure!(File.new(example_avex_file))
 
     ARGV[-2].assert == '--title'
     ARGV[-1].assert == 'Big Title'
   end
 
+  it "can should not configure! when arguments are given" do
+    ENV['cmd'] = 'yard'
+    ARGV.replace(['--private'])
+
+    example_avex_file = File.dirname(__FILE__) + '/fixtures/yard.opts'
+
+    DotOpts.configure!(File.new(example_avex_file))
+
+    ARGV[-1].assert == '--private'
+  end
+
 end
 

data/spec/spec_parser.rb

@@ -2,47 +2,68 @@ require_relative "helper"
 
 describe DotOpts::Parser do
 
-  before do
-    ENV['cmd'] = 'yard'  # FIXME: try `foo` and watch what happens
-  end
+  #before do
+  #  ENV['cmd'] = 'yard'  # FIXME: try `foo` and watch what happens
+  #end
 
   describe "without profiles" do
-
     it "can parse configuration" do
       text = "yard\n" +
              "  --title Super"
-      parser = DotOpts::Parser.parse(text)
+      cmds = DotOpts::Parser.parse(text)
 
-      parser.arguments.assert == ['--title', 'Super']
+      cmds.size.assert == 1
+      cmds[0].name.assert == 'yard'
+      cmds[0].arguments.assert == ['--title', 'Super']
+      cmds[0].profile.assert.nil?
     end
 
     it "can parse configuration with multiple arguments" do
       text = "yard\n" +
              "  --title Super\n" +
              "  --private\n"
+      cmds = DotOpts::Parser.parse(text)
 
-      parser = DotOpts::Parser.parse(text)
-
-      parser.arguments.assert == ['--title', 'Super', '--private']
+      cmds.size.assert == 1
+      cmds[0].name.assert == 'yard'
+      cmds[0].arguments.assert == ['--title', 'Super', '--private']
+      cmds[0].profile.assert.nil?
     end
 
+    it "can parse configuration with multiple commands" do
+      text = "yard\n" +
+             "  --title Super\n" +
+             "  --private\n" +
+             "rdoc\n" +
+             "  --private\n"
+      cmds = DotOpts::Parser.parse(text)
+
+      cmds.size.assert == 2
+
+      cmds[0].name.assert == 'yard'
+      cmds[0].arguments.assert == ['--title', 'Super', '--private']
+      cmds[0].profile.assert.nil?
+
+      cmds[1].name.assert == 'rdoc'
+      cmds[1].arguments.assert == ['--private']
+      cmds[1].profile.assert.nil?
+    end
   end
 
   describe "with profiles" do
-
     it "can parse configuration with initial profile" do
       text = "[example]\n" +
              "yard\n" +
              "  --title Super"
+      cmds = DotOpts::Parser.parse(text)
 
-      parser = with_env('profile'=>'example') do
-        DotOpts::Parser.parse(text)
-      end
-
-      parser.arguments.assert == ['--title', 'Super']
+      cmds.size.assert == 1
+      cmds.first.name.assert == 'yard'
+      cmds.first.profile.assert == 'example'
+      cmds.first.arguments.assert == ['--title', 'Super']
     end
 
-    it "can parse configuration with lower profile" do
+    it "can parse configuration with multiple profiles" do
       text = "[something]\n" +
              "yard\n" +
              "  --title Sucky\n" +
@@ -51,18 +72,23 @@ describe DotOpts::Parser do
              "yard\n" +
              "  --title Super"
 
-      parser = with_env('profile'=>'example') do
-        DotOpts::Parser.parse(text)
-      end
+      cmds = DotOpts::Parser.parse(text)
 
-      parser.arguments.assert == ['--title', 'Super']
-    end
+      cmds.size.assert == 2
 
-  end
+      cmds[0].name.assert == 'yard'
+      cmds[0].profile.assert == 'something'
+      cmds[0].arguments.assert == ['--title', 'Sucky']
 
-  after do
-    ENV['cmd'] = nil
+      cmds[1].name.assert == 'yard'
+      cmds[1].profile.assert == 'example'
+      cmds[1].arguments.assert == ['--title', 'Super']
+    end
   end
 
+  #after do
+  #  ENV['cmd'] = nil
+  #end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dotopts
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-05 00:00:00.000000000 Z
+date: 2013-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: qed
@@ -70,24 +70,25 @@ extra_rdoc_files:
 - README.md
 files:
 - .index
-- demo/09_battery/profiles_basic.md
 - demo/09_battery/commands_only.md
-- demo/09_battery/profiles_regex.md
+- demo/09_battery/profiles_basic.md
 - demo/09_battery/profiles_complex.md
+- demo/09_battery/profiles_regex.md
 - demo/09_battery/substitution.md
-- demo/applique/require.rb
 - demo/applique/battery.rb
+- demo/applique/require.rb
 - lib/dotopts/api.rb
+- lib/dotopts/command.rb
 - lib/dotopts/parser.rb
 - lib/dotopts.rb
-- spec/spec_api.rb
+- spec/fixtures/yard.opts
 - spec/helper.rb
+- spec/spec_api.rb
+- spec/spec_command.rb
 - spec/spec_parser.rb
-- spec/fixtures/yard.opts
-- Gemfile.lock
-- LICENSE.txt
 - HISTORY.md
 - README.md
+- LICENSE.txt
 homepage: http://rubyworks.github.com/dotopts
 licenses:
 - BSD-2-Clause
@@ -117,4 +118,5 @@ test_files:
 - spec/spec_api.rb
 - spec/helper.rb
 - spec/spec_parser.rb
+- spec/spec_command.rb
 has_rdoc: 

data/Gemfile.lock

@@ -1,30 +0,0 @@
-PATH
-  remote: .
-  specs:
-    dotopts (0.1.3)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    ae (1.8.1)
-      ansi
-    ansi (1.4.3)
-    brass (1.2.1)
-    facets (2.9.3)
-    qed (2.9.1)
-      ansi
-      brass
-      facets (>= 2.8)
-    rubytest (0.6.0)
-      ansi
-    spectroscope (0.1.0)
-      rubytest
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  ae
-  dotopts!
-  qed
-  spectroscope