mothership 0.0.15 → 0.1.0

data/lib/mothership/base.rb

@@ -5,12 +5,12 @@ class Mothership
   # all commands
   @@commands = {}
 
-  # parsed global input set
-  @@inputs = nil
+  attr_accessor :input
 
   # Initialize with the command being executed.
-  def initialize(command = nil)
+  def initialize(command = nil, input = nil)
     @command = command
+    @input = input
   end
 
   class << self
@@ -41,8 +41,8 @@ class Mothership
     end
   end
 
-  def execute(cmd, argv)
-    cmd.invoke(Parser.new(cmd).inputs(argv))
+  def execute(cmd, argv, global = {})
+    cmd.invoke({}, Parser.new(cmd).parse_argv(argv), global)
   rescue Mothership::Error => e
     $stderr.puts e
     $stderr.puts ""
@@ -51,10 +51,16 @@ class Mothership
     exit_status 1
   end
 
+  # wrap this with your error handling/etc.
+  def run(name)
+    send(name)
+  end
+
   # invoke a command with inputs
-  def invoke(name, inputs = {}, given = {})
+  def invoke(
+      name, inputs = {}, given = {}, global = @input ? @input.global : {})
     if cmd = @@commands[name]
-      cmd.invoke(given, inputs)
+      cmd.invoke(inputs, given, global)
     else
       unknown_command(name)
     end

data/lib/mothership/command.rb

@@ -52,28 +52,30 @@ class Mothership
       str
     end
 
-    def invoke(given, inputs = {})
+    def invoke(inputs = {}, given = {}, global = {})
       @before.each { |f, c| c.new.instance_exec(&f) }
 
       name = @name
       ctx = @context.new(self)
-      input = Inputs.new(self, ctx, given, inputs)
+      ctx.input = Inputs.new(self, ctx, inputs, given, global)
 
       action = proc do |*given_inputs|
-        ctx.send(name, given_inputs.first || input)
+        ctx.input = given_inputs.first || ctx.input
+        ctx.run(name)
       end
 
       cmd = self
       @around.each do |a, c|
         before = action
 
-        sub = c.new(cmd)
+        sub = c.new(cmd, ctx.input)
         action = proc do |*given_inputs|
-          sub.instance_exec(before, given_inputs.first || input, &a)
+          ctx.input = given_inputs.first || ctx.input
+          sub.instance_exec(before, ctx.input, &a)
         end
       end
 
-      res = ctx.instance_exec(input, &action)
+      res = ctx.instance_exec(ctx.input, &action)
 
       @after.each { |f, c| c.new.instance_exec(&f) }
 

data/lib/mothership/help.rb

@@ -215,7 +215,7 @@ class Mothership
   desc "Help!"
   input :command, :argument => :optional
   input :all, :type => :boolean
-  def help(input)
+  def help
     if name = input[:command]
       Mothership::Help.command_help(@@commands[name.gsub("-", "_").to_sym])
     elsif Help.has_groups?

data/lib/mothership/inputs.rb

@@ -1,12 +1,15 @@
 class Mothership
   class Inputs
-    attr_reader :inputs
+    attr_reader :inputs, :given, :global
 
-    def initialize(command, context = nil, given = {}, inputs = {})
+    def initialize(
+        command, context = nil,
+        inputs = {}, given = {}, global = {})
       @command = command
       @context = context
-      @given = given
       @inputs = inputs
+      @given = given
+      @global = global
     end
 
     def given?(name)
@@ -14,15 +17,19 @@ class Mothership
     end
 
     def given(name)
-      @inputs[name] || @given[name]
+      if @inputs.key?(name)
+        @inputs[name]
+      else
+        @given[name]
+      end
     end
 
     def merge(inputs)
-      self.class.new(@command, @context, @given, @inputs.merge(inputs))
+      self.class.new(@command, @context, @inputs.merge(inputs), @given)
     end
 
     def merge_given(inputs)
-      self.class.new(@command, @context, @given.merge(inputs), @inputs)
+      self.class.new(@command, @context, @inputs, @given.merge(inputs))
     end
 
     def without(*names)
@@ -40,31 +47,32 @@ class Mothership
       get(name, @context, *args)
     end
 
+    # search:
+    # 1. cache
+    # 2. cache, singular
+    # 3. given
+    # 4. given, singular
+    # 5. global
+    # 6. global, singular
     def get(name, context, *args)
       return @inputs[name] if @inputs.key?(name)
 
-      meta = @command.inputs[name]
-      return unless meta
+      if meta = @command.inputs[name]
+        # special case so #invoke can be called with singular-named inputs
+        singular = meta[:singular]
+        return @inputs[name] = [@inputs[singular]] if @inputs.key?(singular)
 
-      singular = meta[:singular]
-      return @inputs[name] = [@inputs[singular]] if @inputs.key?(singular)
-
-      given = @given[name] if @given.key?(name)
-      given ||= [@given[singular]] if @given.key?(singular)
-
-      # value given; convert if needed
-      if given && given != []
-        return @inputs[name] = convert_given(meta, context, given, *args)
+        found, val = find_in(@given, name, meta, context, *args)
       end
 
-      # no value given; set as default
-      val = default_for(meta, context, *args)
-
-      unless meta[:forget]
-        @inputs[name] = val
+      # if not found locally and the default is nil, search globally
+      if !found && val.nil? && meta = Mothership.global_option(name)
+        found, val = find_in(@global, name, meta, context, *args)
       end
 
-      val
+      return val if not found
+
+      @inputs[name] = convert_given(meta, context, val, *args)
     end
 
     def forget(name)
@@ -74,6 +82,24 @@ class Mothership
 
     private
 
+    def find_in(where, name, meta, context, *args)
+      singular = meta[:singular]
+
+      if where.key?(name)
+        [true, where[name]]
+      elsif where.key?(singular)
+        [true, [where[singular]]]
+      else
+        # no value given; set as default
+        val = default_for(meta, context, *args)
+
+        # cache default value
+        @inputs[name] = val unless meta[:forget]
+
+        [false, val]
+      end
+    end
+
     def convert_given(meta, context, given, *args)
       if convert = meta[:from_given]
         if given.is_a?(Array)

data/lib/mothership/parser.rb

@@ -1,20 +1,21 @@
 class Mothership
   class Parser
-    def initialize(command)
+    attr_reader :given
+
+    def initialize(command, given = {})
       @command = command
+      @given = given
     end
 
-    def inputs(argv)
-      inputs = {}
-
-      args = parse_flags(inputs, argv.dup)
+    def parse_argv(argv)
+      args = parse_flags(argv.dup)
 
-      parse_arguments(inputs, args)
+      parse_arguments(args)
 
-      inputs
+      @given
     end
 
-    def parse_flags(inputs, argv, find_in = nil)
+    def parse_flags(argv, find_in = nil)
       local = nil
       args = []
 
@@ -43,19 +44,19 @@ class Mothership
         case input[:type]
         when :bool, :boolean
           if argv.first == "false" || argv.first == "true"
-            inputs[name] = argv.shift == "true"
+            @given[name] = argv.shift == "true"
           else
-            inputs[name] = true
+            @given[name] = true
           end
         when :float, :floating
           if !argv.empty? && argv.first =~ /^[0-9]+(\.[0-9]*)?$/
-            inputs[name] = argv.shift.to_f
+            @given[name] = argv.shift.to_f
           else
             raise TypeMismatch.new(@command.name, name, "floating")
           end
         when :integer, :number, :numeric
           if !argv.empty? && argv.first =~ /^[0-9]+$/
-            inputs[name] = argv.shift.to_i
+            @given[name] = argv.shift.to_i
           else
             raise TypeMismatch.new(@command.name, name, "numeric")
           end
@@ -63,7 +64,7 @@ class Mothership
           if argv.empty? || !argv.first.start_with?("-")
             arg = argv.shift || ""
 
-            inputs[name] =
+            @given[name] =
               if input[:argument] == :splat
                 arg.split(",")
               else
@@ -80,7 +81,7 @@ class Mothership
     #   1 2 => :fizz => 1, :buzz => 2
     #   1 2 3 => :foo => 1, :fizz => 2, :buzz => 3
     #   1 2 3 4 => :foo => 1, :bar => 2, :fizz => 3, :buzz => 4
-    def parse_arguments(inputs, args)
+    def parse_arguments(args)
       total = @command.arguments.size
       required = 0
       optional = 0
@@ -99,25 +100,25 @@ class Mothership
 
       @command.arguments.each do |arg|
         name = arg[:name]
-        next if inputs.key? name
+        next if @given.key? name
 
         case arg[:type]
         when :splat
-          inputs[name] = []
+          @given[name] = []
 
           until args.empty?
-            inputs[name] << args.shift
+            @given[name] << args.shift
           end
 
         when :optional
           if parse_optionals > 0 && val = args.shift
-            inputs[name] = val
+            @given[name] = val
             parse_optionals -= 1
           end
 
         else
           if val = args.shift
-            inputs[name] = val
+            @given[name] = val
           elsif !@command.inputs[name][:default]
             raise MissingArgument.new(@command.name, name)
           end

data/lib/mothership/version.rb

@@ -1,3 +1,3 @@
 class Mothership
-  VERSION = "0.0.15"
+  VERSION = "0.1.0"
 end

data/lib/mothership.rb

@@ -9,9 +9,6 @@ class Mothership
   # [Mothership::Command] global options
   @@global = Command.new(self, "(global options)")
 
-  # [Mothershp::Inputs] inputs from global options
-  @@inputs = Inputs.new(@@global)
-
   # [Fixnum] exit status; reassign as appropriate error code (e.g. 1)
   @@exit_status = 0
 
@@ -27,11 +24,8 @@ class Mothership
     # arguments and flags can be in any order; all flags will be parsed out
     # first, and the bits left over will be treated as arguments
     def start(argv)
-      name, *argv =
-        Parser.new(@@global).parse_flags(
-          @@inputs.inputs,
-          argv,
-          @@commands)
+      global_parser = Parser.new(@@global)
+      name, *argv = global_parser.parse_flags(argv, @@commands)
 
       app = new
 
@@ -42,7 +36,7 @@ class Mothership
       cmd = @@commands[cmdname]
       return app.unknown_command(cmdname) unless cmd
 
-      app.execute(cmd, argv)
+      app.execute(cmd, argv, global_parser.given)
 
       code = @@exit_status
 
@@ -51,20 +45,14 @@ class Mothership
 
       exit code
     end
+
+    def global_option(name)
+      @@global.inputs[name]
+    end
   end
 
   # set the exit status
   def exit_status(num)
     @@exit_status = num
   end
-
-  # get value of global option
-  def option(name, *args)
-    @@inputs.get(name, self, *args)
-  end
-
-  # test if an option was explicitly provided
-  def option_given?(name)
-    @@inputs.given? name
-  end
 end

data/spec/helpers.rb

@@ -14,7 +14,7 @@ module MothershipHelpers
   end
 
   def inputs(cmd, *argv)
-    Mothership::Parser.new(cmd).inputs(argv)
+    Mothership::Parser.new(cmd).parse_argv(argv)
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mothership
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 15
-  version: 0.0.15
+  version: 0.1.0
 platform: ruby
 authors: 
 - Alex Suraci
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-21 00:00:00 Z
+date: 2012-08-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake