couch-shell 0.0.4 → 0.0.5

data/bin/couch-shell

@@ -2,4 +2,4 @@
 
 require "couch-shell"
 
-CouchShell.run ARGV
+exit CouchShell.run(ARGV)

data/lib/couch-shell.rb

@@ -1,21 +1,54 @@
 # -*- encoding: utf-8 -*-
 
 require "couch-shell/shell"
-require "couch-shell/version"
+require "couch-shell/commandline"
 
 module CouchShell
 
   def self.run(args)
-    puts "couch-shell #{VERSION}"
-    shell = Shell.new(STDIN, STDOUT, STDERR)
-    if ARGV[0]
-      shell.server = ARGV[0]
-    end
-    if ARGV[1]
-      shell.cd ARGV[1], true
+    server = nil
+    path = nil
+    user = nil
+
+    begin
+      Commandline.new { |cmd|
+        cmd.arg { |arg|
+          if server.nil?
+            server = arg
+          elsif path.nil?
+            path = arg
+          else
+            raise Commandline::Error, "too many arguments"
+          end
+        }
+        cmd.opt "-u", "--user=USER",
+          "Connect with CouchDB as USER. Password will be asked." do |val|
+          user = val
+        end
+        cmd.opt "-h", "--help", "Show help and exit." do
+          STDOUT.puts "Usage: couch-shell [options] [--] [HOSTNAME[:PORT]] [PATH]"
+          STDOUT.puts
+          STDOUT.puts "Available options:"
+          STDOUT.puts cmd.optlisting
+          STDOUT.puts
+          STDOUT.puts "Example: couch-shell -u admin 127.0.0.1:5984 mydb"
+          return 0
+        end
+      }.process(args)
+    rescue Commandline::Error => e
+      STDERR.puts e.message
+      STDERR.puts "Run `couch-shell -h' for help."
+      return 1
     end
-    shell.repl
-    exit 0
+
+    shell = Shell.new(STDIN, STDOUT, STDERR)
+    shell.execute "user #{user}" if user
+    shell.execute "server #{server}" if server
+    shell.execute "cg #{path}" if path
+
+    shell.read_execute_loop
+
+    0
   end
 
 end

data/lib/couch-shell/commandline.rb

@@ -0,0 +1,213 @@
+# -*- encoding: utf-8 -*-
+
+module CouchShell
+
+  class Commandline
+
+    class Error < StandardError
+    end
+
+    class ArgNotAllowedError < Error
+      
+      attr_reader :arg
+
+      def initialize(arg)
+        @arg = arg
+      end
+
+      def message
+        "no argument allowed, argument `#{arg}' was given"
+      end
+
+    end
+
+    class UnknownOptError < Error
+      
+      attr_reader :optname
+
+      def initialize(optname)
+        @optname = optname
+      end
+
+      def message
+        "unkown option `#{optname}'"
+      end
+
+    end
+
+    class OptArgMissingError < Error
+
+      attr_reader :optname
+
+      def initialize(optname)
+        @optname = optname
+      end
+
+      def message
+        "option `#{optname}' requires argument"
+      end
+
+    end
+
+    class Opt
+
+      attr_accessor :short, :long, :value, :doc, :action
+
+      def initialize
+        @short = nil
+        @long = nil
+        @value = nil
+        @doc = nil
+        @action = nil
+      end
+
+      def parse_spec!(optspec)
+        value = nil
+        case optspec
+        when /\A--([^-= ][^= ]+)(=[^= ]+)?\z/
+          raise "long option already set" if @long
+          @long = $1
+          value = ($2 ? $2[1..-1] : nil)
+        when /\A-([^- ])( [^= ]+)?\z/
+          raise "short option already set" if @short
+          @short = $1
+          value = ($2 ? $2[1..-1] : nil)
+        else
+          raise "invalid optspec `#{optspec}'"
+        end
+        if value
+          if @value && @value != value
+            raise "option value name mismatch: `#{value}' != `#{@value}'"
+          end
+          @value = value
+        end
+      end
+
+    end
+
+    def initialize
+      @arg_action = nil
+      @opts = []
+      @leading_help = nil
+      @trailing_help = nil
+      yield self
+    end
+
+    def arg(&block)
+      @arg_action = block
+    end
+
+    def opt(optspec1, optspec2 = nil, doc = nil, &block)
+      raise "optspec and action block required" unless optspec1 && block
+      option = Opt.new
+      option.doc = doc
+      option.parse_spec! optspec1
+      if optspec2 && doc
+        option.parse_spec! optspec2 if optspec2
+      elsif optspec2
+        option.doc = doc
+      end
+      option.action = block
+      @opts << option
+    end
+
+    def optlisting(indent = "  ")
+      max_value_len = @opts.map(&:value).compact.map(&:length).max || 0
+      String.new.tap do |t|
+        @opts.each { |opt|
+          t << indent
+          if opt.short
+            t << "-#{opt.short} "
+            if opt.value
+              t << opt.value
+              t << (" " * (max_value_len - opt.value.length))
+            end
+          else
+            t << "   " << (" " * max_value_len)
+          end
+          t << "    "
+          if opt.long
+            t << "--#{opt.long}"
+            t << "=#{opt.value}" if opt.value
+          end
+          t << "\n"
+          if opt.doc
+            opt.doc.each_line { |l|
+              t << (indent * 3) << l
+            }
+          end
+          t << "\n"
+        }
+      end
+    end
+
+    # May raise Commandline::Error or subclass thereof.
+    def process(args)
+      optstop = false
+      opt_to_eat_arg = nil
+      opt_to_eat_arg_arg = nil
+      args.each { |arg|
+        if optstop
+          if opt_to_eat_arg
+            raise OptArgMissingError.new(opt_to_eat_arg_arg)
+          end
+          @arg_action.call(arg)
+          next
+        end
+        if opt_to_eat_arg
+          opt_to_eat_arg.action.call(arg)
+          opt_to_eat_arg = nil
+          opt_to_eat_arg_arg = nil
+          next
+        end
+        case arg
+        when "--"
+          optstop = true
+        when /\A--([^=]*)(=.*)?\z/
+          long = $1
+          if long.nil? || long.empty?
+            raise Error, "expected option name in `#{arg}'"
+          end
+          opt = @opts.find { |opt| opt.long == long }
+          raise UnknownOptError.new(arg) unless opt
+          if opt.value
+            if $2
+              opt.action.call($2[1..-1])
+            else
+              raise OptArgMissingError.new(arg)
+            end
+          else
+            if $2
+              raise ArgNotAllowedError.new(arg)
+            else
+              opt.action.call
+            end
+          end
+        when /\A-([^-])\z/
+          short = $1
+          opt = @opts.find { |opt| opt.short == short }
+          raise UnknownOptError.new(arg) unless opt
+          if opt.value
+            opt_to_eat_arg = opt
+            opt_to_eat_arg_arg = arg
+          else
+            opt.action.call
+          end
+        when /\A-/
+          raise UnknownOptError.new(arg)
+        else
+          if @arg_action
+            @arg_action.call(arg)
+          else
+            ArgNotAllowedError.new(arg)
+          end
+        end
+      }
+      if opt_to_eat_arg
+        raise OptArgMissingError.new(opt_to_eat_arg_arg)
+      end
+    end
+
+  end
+
+end

data/lib/couch-shell/shell.rb

@@ -5,15 +5,24 @@ require "uri"
 require "net/http"
 require "httpclient"
 require "highline"
+require "couch-shell/version"
 require "couch-shell/response"
 require "couch-shell/ring_buffer"
 require "couch-shell/eval_context"
 
 module CouchShell
 
+  # Starting a shell:
+  #
+  #   require "couch-shell/shell"
+  #
+  #   shell = CouchShell::Shell.new(STDIN, STDOUT, STDERR)
+  #   # returns at end of STDIN or on a quit command
+  #   shell.read_execute_loop
+  #
   class Shell
 
-    class BreakReplLoop < Exception
+    class Quit < Exception
     end
 
     class ShellUserError < Exception
@@ -62,6 +71,9 @@ module CouchShell
       @responses = RingBuffer.new(10)
       @eval_context = EvalContext.new(self)
       @viewtext = nil
+      @stdout.puts "couch-shell #{VERSION}"
+      @username = nil
+      @password = nil
     end
 
     def normalize_server_url(url)
@@ -186,6 +198,9 @@ module CouchShell
                else
                  raise "unsupported http method: `#{method}'"
                end).new(fpath)
+        if @username && @password
+          req.basic_auth @username, @password
+        end
         if body
           req.body = body
           if req.content_type.nil? && req.body =~ JSON_DOC_START_RX
@@ -203,12 +218,17 @@ module CouchShell
       if body.kind_of?(FileToUpload)
         file_to_upload = body
         file = File.open(file_to_upload.filename, "rb")
-        body = [{'Content-Type' => file_to_upload.content_type!,
-                 :content => file}]
+        #body = [{'Content-Type' => file_to_upload.content_type!,
+        #         :content => file}]
+        body = {'upload' => file}
       elsif body && body =~ JSON_DOC_START_RX
         headers['Content-Type'] = "application/json"
       end
-      res = HTTPClient.new.request(method, absolute_url, body, headers)
+      hclient = HTTPClient.new
+      if @username && @password
+        hclient.set_auth lookup_var("server"), @username, @password
+      end
+      res = hclient.request(method, absolute_url, body, headers)
       Response.new(res)
     ensure
       file.close if file
@@ -266,11 +286,36 @@ module CouchShell
       end
     end
 
-    def rep
-      input = read
+    # When the user enters something, it is passed to this method for
+    # execution. You may call if programmatically to simulate user input.
+    #
+    # If input is nil, it is interpreted as "end of input", raising a
+    # CouchShell::Shell::Quit exception. This exception is also raised by other
+    # commands (e.g. "exit" and "quit"). All other exceptions are caught and
+    # displayed on stderr.
+    def execute(input)
+      begin
+        execute!(input)
+      rescue Quit => e
+        raise e
+      rescue Interrupt
+        @stdout.puts
+        errmsg "interrupted"
+      rescue UndefinedVariable => e
+        errmsg "Variable `" + e.varname + "' is not defined."
+      rescue ShellUserError => e
+        errmsg e.message
+      rescue Exception => e
+        errmsg e.message
+        errmsg e.backtrace[0..5].join("\n")
+      end
+    end
+
+    # Basic execute without error handling. Raises various exceptions.
+    def execute!(input)
       case input
       when nil
-        raise BreakReplLoop
+        raise Quit
       when ""
         # do nothing
       else
@@ -284,20 +329,13 @@ module CouchShell
       end
     end
 
-    def repl
+    # Start regular shell operation, i.e. reading commands from stdin and
+    # executing them. Returns when the user issues a quit command.
+    def read_execute_loop
       loop {
-        begin
-          rep
-        rescue Interrupt
-          @stdout.puts
-          errmsg "interrupted"
-        rescue UndefinedVariable => e
-          errmsg "Variable `" + e.varname + "' is not defined."
-        rescue ShellUserError => e
-          errmsg e.message
-        end
+        execute(read)
       }
-    rescue BreakReplLoop
+    rescue Quit
       msg "bye"
     end
 
@@ -325,7 +363,7 @@ module CouchShell
             end
           elsif c == ')'
             if expr
-              res << shell_eval(expr)
+              res << shell_eval(expr).to_s
               expr = nil
             else
               res << c
@@ -352,7 +390,8 @@ module CouchShell
         command_uuids nil
         if @responses.current(&:ok?)
           json = @responses.current.json
-          if json && (uuids = json["uuids"]) && uuids.kind_of?(Array) && uuids.size > 0
+          if json && (uuids = json.couch_shell_ruby_value!["uuids"]) &&
+              uuids.kind_of?(Array) && uuids.size > 0
             uuids[0]
           else
             raise ShellUserError,
@@ -416,7 +455,9 @@ module CouchShell
       else
         body = bodyarg
       end
-      request method, interpolate(url), body
+      real_url = interpolate(url)
+      request method, real_url, body
+      real_url
     end
 
     def editor_bin!
@@ -432,6 +473,11 @@ module CouchShell
       request_command_with_body("PUT", argstr)
     end
 
+    def command_cput(argstr)
+      url = request_command_with_body("PUT", argstr)
+      cd url if @responses.current(&:ok?)
+    end
+
     def command_post(argstr)
       request_command_with_body("POST", argstr)
     end
@@ -449,11 +495,11 @@ module CouchShell
     end
 
     def command_exit(argstr)
-      raise BreakReplLoop
+      raise Quit
     end
 
     def command_quit(argstr)
-      raise BreakReplLoop
+      raise Quit
     end
 
     def command_uuids(argstr)
@@ -680,6 +726,14 @@ module CouchShell
       request "PUT", "?rev=#{rev}", json.to_s
     end
 
+    def command_user(argstr)
+      prompt_msg("Password:", false)
+      @password = @highline.ask(" ") { |q| q.echo = "*" }
+      # we save the username only after the password was entered
+      # to allow cancellation during password input
+      @username = argstr
+    end
+
   end
 
 end

data/lib/couch-shell/version.rb

@@ -2,6 +2,6 @@
 
 module CouchShell
 
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Stefan Lang
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-20 00:00:00 +01:00
+date: 2011-01-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,6 +59,7 @@ extra_rdoc_files: []
 files: 
 - lib/couch-shell/eval_context.rb
 - lib/couch-shell/response.rb
+- lib/couch-shell/commandline.rb
 - lib/couch-shell/ring_buffer.rb
 - lib/couch-shell/json_value.rb
 - lib/couch-shell/version.rb