couch-shell 0.0.5 → 0.0.6

data/lib/couch-shell/plugin_utils.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+
+require "couch-shell/exceptions"
+
+module CouchShell
+
+  # Requires an instance method named "shell" that returns a
+  # CouchShell::Shell compatible object.
+  module PluginUtils
+
+    class ShellError < ShellUserError
+    end
+
+    class VarNotSet < ShellError
+
+      attr_accessor :var
+
+      def message
+        "Variable @#{@var.plugin.plugin_name}.#{@var.name} not set."
+      end
+
+    end
+
+    # Get the first element of pathstack or raise an exception if pathstack is
+    # empty.
+    def dbname!
+      raise ShellError, "must cd into database" if shell.pathstack.empty?
+      shell.pathstack[0]
+    end
+
+    # Raise an exception unless pathstack size is 1.
+    def ensure_at_database
+      if shell.pathstack.size != 1
+        raise ShellError, "current directory must be database"
+      end
+    end
+
+    # Displays msg in the same style as the standard couch-shell prompt
+    # and raises ShellError unless the user hits ENTER and nothing else.
+    #
+    # Usage:
+    #   
+    #   # do some setup logic
+    #   continue?("Changes made: foo replaced by bar\n" +
+    #             "Press ENTER to save changes or CTRL+C to cancel")
+    #   # save changes
+    def continue?(msg)
+      shell.prompt_msg(msg, false)
+      unless shell.stdin.gets.chomp.empty?
+        raise ShellError, "cancelled"
+      end
+    end
+
+    # Like shell.request, but raises a ShellError ("required request failed")
+    # if response.ok? is false.
+    def request!(*args)
+      shell.request(*args).tap do |res|
+        raise ShellError, "required request failed" unless res.ok?
+      end
+    end
+
+    # Opens editor with the given file path and returns after the user closes
+    # the editor or raises a ShellError if the editor doesn't exit with an exit
+    # status of 0.
+    def editfile!(path)
+      unless system(shell.editor_bin!, path)
+        raise ShellError, "editing command failed with exit status #{$?.exitstatus}"
+      end
+    end
+
+    # Writes content to a temporary file, calls editfile! on it and returns the
+    # new file content on success after unlinking the temporary file.
+    def edittext!(content, tempfile_name_ext = ".js", tempfile_name_part = "cs")
+      t = Tempfile.new([tempfile_name_part, tempfile_name_ext])
+      t.write(content)
+      t.close
+      editfile! t.path
+      t.open.read
+    ensure
+      if t
+        t.close
+        t.unlink
+      end
+    end
+
+  end
+
+end

data/lib/couch-shell/response.rb

@@ -15,25 +15,30 @@ module CouchShell
     # response
     def initialize(response)
       @res = response
-      @json = nil
-      @computed_json = false
+      @json_value = nil
+      @computed_json_value = false
     end
 
-    # Response body parsed as json. nil if body is empty, false if
-    # parsing failed.
+    # Response body parsed as json, represented as a ruby data structure. nil
+    # if body is empty, false if parsing failed.
     def json
-      unless @computed_json
+      json_value ? json_value.unwrapped! : json_value
+    end
+
+    # Like json, but wrapped in a CouchShell::JsonValue.
+    def json_value
+      unless @computed_json_value
         if JSON_CONTENT_TYPES.include?(content_type) &&
             !body.nil? && !body.empty?
           begin
-            @json = JsonValue.wrap(JSON.parse(body))
+            @json_value = JsonValue.wrap(JSON.parse(body))
           rescue JSON::ParserError
-            @json = false
+            @json_value = false
           end
         end
-        @computed_json = true
+        @computed_json_value = true
       end
-      @json
+      @json_value
     end
 
     def code
@@ -61,11 +66,11 @@ module CouchShell
     def attr(name, altname = nil)
       name = name.to_sym
       altname = altname ? altname.to_sym : nil
-      if json
-        if json.respond_to?(name)
-          json.__send__ name
-        elsif altname && json.respond_to?(altname)
-          json.__send__ altname
+      if json_value
+        if json_value.respond_to?(name)
+          json_value.__send__ name
+        elsif altname && json_value.respond_to?(altname)
+          json_value.__send__ altname
         end
       end
     end

data/lib/couch-shell/shell.rb

@@ -3,15 +3,36 @@
 require "tempfile"
 require "uri"
 require "net/http"
+require "socket"
 require "httpclient"
 require "highline"
+require "couch-shell/exceptions"
 require "couch-shell/version"
 require "couch-shell/response"
 require "couch-shell/ring_buffer"
 require "couch-shell/eval_context"
+require "couch-shell/plugin"
 
 module CouchShell
 
+  JSON_DOC_START_RX = /\A[ \t\n\r]*[\(\{]/
+
+  class FileToUpload
+
+    attr_reader :filename, :content_type
+
+    def initialize(filename, content_type = nil)
+      @filename = filename
+      @content_type = content_type
+    end
+
+    def content_type!
+      # TODO: use mime-types and/or file to guess mime type
+      content_type || "application/octet-stream"
+    end
+
+  end
+
   # Starting a shell:
   #
   #   require "couch-shell/shell"
@@ -22,44 +43,27 @@ module CouchShell
   #
   class Shell
 
-    class Quit < Exception
-    end
+    class PluginLoadError < ShellUserError
 
-    class ShellUserError < Exception
-    end
-
-    class UndefinedVariable < ShellUserError
-
-      attr_reader :varname
-
-      def initialize(varname)
-        @varname = varname
-      end
-
-    end
-
-    class FileToUpload
-
-      attr_reader :filename, :content_type
-
-      def initialize(filename, content_type = nil)
-        @filename = filename
-        @content_type = content_type
+      def initialize(plugin_name, reason)
+        @plugin_name = plugin_name
+        @reason = reason
       end
 
-      def content_type!
-        # TODO: use mime-types and/or file to guess mime type
-        content_type || "application/octet-stream"
+      def message
+        "Failed to load plugin #@plugin_name: #@reason"
       end
 
     end
 
-    PREDEFINED_VARS = [
-      "uuid", "id", "rev", "idr",
-      "content-type", "server"
-    ].freeze
-
-    JSON_DOC_START_RX = /\A[ \t\n\r]*[\(\{]/
+    # A CouchShell::RingBuffer holding CouchShell::Response instances.
+    attr_reader :responses
+    attr_reader :server_url
+    attr_reader :stdout
+    attr_reader :stdin
+    attr_reader :pathstack
+    attr_accessor :username
+    attr_accessor :password
 
     def initialize(stdin, stdout, stderr)
       @stdin = stdin
@@ -70,10 +74,72 @@ module CouchShell
       @highline = HighLine.new(@stdin, @stdout)
       @responses = RingBuffer.new(10)
       @eval_context = EvalContext.new(self)
-      @viewtext = nil
-      @stdout.puts "couch-shell #{VERSION}"
       @username = nil
       @password = nil
+      @plugins = {}
+      @commands = {}
+      @variables = {}
+      @variable_prefixes = []
+      @stdout.puts "couch-shell #{VERSION}"
+    end
+
+    def plugin(plugin_name)
+      # load and instantiate
+      feature = "couch-shell-plugin/#{plugin_name}"
+      begin
+        require feature
+      rescue LoadError
+        raise PluginLoadError, "feature #{feature} not found"
+      end
+      pi = PluginInfo[plugin_name]
+      raise PluginLoadError, "plugin class not found" unless pi
+      plugin = pi.plugin_class.new(self)
+
+      # integrate plugin variables
+      ## enable qualified reference via @PLUGIN.VAR syntax
+      @eval_context._instance_variable_set(
+        :"@#{plugin_name}", plugin.variables_object)
+      ## enable unqualified reference
+      pi.variables.each { |vi|
+        if vi.name
+          existing = @variables[vi.name]
+          if existing
+            warn "When loading plugin #{plugin_name}: " +
+              "Variable #{vi.name} already defined by plugin " +
+              "#{existing.plugin.plugin_name}\n" +
+              "You can access it explicitely via @#{plugin_name}.#{vi.name}"
+          else
+            @variables[vi.name] = vi
+          end
+        end
+        if vi.prefix
+          existing = @variable_prefixes.find { |e| e.prefix == vi.prefix }
+          if existing
+            warn "When loading plugin #{plugin_name}: " +
+              "Variable prefix #{vi.prefix} already defined by plugin " +
+              "#{existing.plugin.plugin_name}\n" +
+              "You can access it explicitely via @#{plugin_name}.#{vi.prefix}*"
+          else
+            @variable_prefixes << vi
+          end
+        end
+      }
+
+      # integrate plugin commands
+      pi.commands.each_value { |ci|
+        existing = @commands[ci.name]
+        if existing
+          warn "When loading plugin #{plugin_name}: " +
+            "Command #{ci.name} already defined by plugin " +
+            "#{existing.plugin.plugin_name}\n" +
+            "You can access it explicitely via @#{plugin_name}.#{ci.name}"
+        else
+          @commands[ci.name] = ci
+        end
+      }
+
+      @plugins[plugin_name] = plugin
+      plugin.plugin_initialization
     end
 
     def normalize_server_url(url)
@@ -81,7 +147,7 @@ module CouchShell
       # remove trailing slash
       url = url.sub(%r{/\z}, '')
       # prepend http:// if scheme is omitted
-      if url =~ /\A\p{Alpha}(?:\p{Alpha}|\p{Digit}|\+|\-|\.)*:/
+      if url =~ /\A\p{Alpha}(?:\p{Alpha}|\p{Digit}|\+|\-|\.)*:\/\//
         url
       else
         "http://#{url}"
@@ -101,27 +167,44 @@ module CouchShell
 
     def cd(path, get = false)
       old_pathstack = @pathstack.dup
-      case path
-      when nil
+
+      if path
+        @pathstack = [] if path.start_with?("/")
+        path.split('/').each { |elem|
+          case elem
+          when ""
+            # do nothing
+          when "."
+            # do nothing
+          when ".."
+            if @pathstack.empty?
+              @pathstack = old_pathstack
+              raise ShellUserError, "Already at server root, can't go up"
+            end
+            @pathstack.pop
+          else
+            @pathstack << elem
+          end
+        }
+      else
         @pathstack = []
-      when ".."
-        if @pathstack.empty?
-          errmsg "Already at server root, can't go up."
-        else
-          @pathstack.pop
+      end
+
+      old_dbname = old_pathstack[0]
+      new_dbname = @pathstack[0]
+      getdb = false
+      if new_dbname && (new_dbname != old_dbname)
+        getdb = get && @pathstack.size == 1
+        res = request("GET", "/#{new_dbname}", nil, getdb)
+        unless res.ok? && (json = res.json_value) &&
+            json.object? && json["db_name"] &&
+            json["db_name"].unwrapped! == new_dbname
+          @pathstack = old_pathstack
+          raise ShellUserError, "not a database: #{new_dbname}"
         end
-      when %r{\A/\z}
-        @pathstack = []
-      when %r{\A/}
-        @pathstack = []
-        cd path[1..-1], false
-      when %r{/}
-        path.split("/").each { |elem| cd elem, false }
-      else
-        @pathstack << path
       end
-      if get
-        if request("GET", nil) != "200"
+      if get && !getdb
+        if request("GET", nil).code != "200"
           @pathstack = old_pathstack
         end
       end
@@ -140,13 +223,17 @@ module CouchShell
       @stderr.puts @highline.color(str, :red)
     end
 
+    def warn(str)
+      @stderr.print @highline.color("warning: ", :red)
+      @stderr.puts @highline.color(str, :blue)
+    end
 
     def print_response(res, label = "", show_body = true)
       @stdout.print @highline.color("#{res.code} #{res.message}", :cyan)
       msg " #{label}"
       if show_body
         if res.json
-          @stdout.puts res.json.format
+          @stdout.puts res.json_value.to_s(true)
         elsif res.body
           @stdout.puts res.body
         end
@@ -155,16 +242,16 @@ module CouchShell
       end
     end
 
+    # Returns CouchShell::Response or raises an exception.
     def request(method, path, body = nil, show_body = true)
       unless @server_url
-        errmsg "Server not set - can't perform request."
-        return
+        raise ShellUserError, "Server not set - can't perform request."
       end
       fpath = URI.encode(full_path(path))
       msg "#{method} #{fpath} ", false
       if @server_url.scheme != "http"
-        errmsg "Protocol #{@server_url.scheme} not supported, use http."
-        return
+        raise ShellUserError,
+          "Protocol #{@server_url.scheme} not supported, use http."
       end
       # HTTPClient and CouchDB don't work together with simple put/post
       # requests to due some Keep-alive mismatch.
@@ -180,7 +267,7 @@ module CouchShell
       vars = ["r#{@responses.index}"]
       vars << ["j#{@responses.index}"] if res.json
       print_response res, "  vars: #{vars.join(', ')}", show_body
-      res.code
+      res
     end
 
     def net_http_request(method, fpath, body)
@@ -218,9 +305,10 @@ 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 = {'upload' => file}
+        body = [{'Content-Type' => file_to_upload.content_type!,
+                 'Content-Transfer-Encoding' => 'binary',
+                 :content => file}]
+        #body = {'upload' => file}
       elsif body && body =~ JSON_DOC_START_RX
         headers['Content-Type'] = "application/json"
       end
@@ -267,19 +355,19 @@ module CouchShell
       end
     end
 
-    def continue?(msg)
-      prompt_msg(msg, false)
-      unless @stdin.gets.chomp.empty?
-        raise ShellUserError, "cancelled"
-      end
-    end
-
+    # Displays the standard couch-shell prompt and waits for the user to
+    # enter a command. Returns the user input as a string (which may be
+    # empty), or nil if the input stream is closed.
     def read
       lead = @pathstack.empty? ? ">>" : @pathstack.join("/") + " >>"
       begin
         @highline.ask(@highline.color(lead, :yellow) + " ") { |q|
           q.readline = true
         }
+      rescue Interrupt
+        @stdout.puts
+        errmsg "interrupted"
+        return ""
       rescue NoMethodError
         # this is BAD, but highline 1.6.1 reacts to CTRL+D with a NoMethodError
         return nil
@@ -287,7 +375,7 @@ module CouchShell
     end
 
     # When the user enters something, it is passed to this method for
-    # execution. You may call if programmatically to simulate user input.
+    # execution. You may call it 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
@@ -305,8 +393,14 @@ module CouchShell
         errmsg "Variable `" + e.varname + "' is not defined."
       rescue ShellUserError => e
         errmsg e.message
+      rescue Errno::ETIMEDOUT => e
+        errmsg "timeout: #{e.message}"
+      rescue SocketError, Errno::ENOENT => e
+        @stdout.puts
+        errmsg "#{e.class}: #{e.message}"
       rescue Exception => e
-        errmsg e.message
+        #p e.class.instance_methods - Object.instance_methods
+        errmsg "#{e.class}: #{e.message}"
         errmsg e.backtrace[0..5].join("\n")
       end
     end
@@ -319,13 +413,29 @@ module CouchShell
       when ""
         # do nothing
       else
-        command, argstr = input.split(/\s+/, 2)
-        command_message = :"command_#{command.downcase}"
-        if self.respond_to?(command_message)
-          send command_message, argstr
+        execute_command! *input.split(/\s+/, 2)
+      end
+    end
+
+    def execute_command!(commandref, argstr = nil)
+      if commandref.start_with?("@")
+        # qualified command
+        if commandref =~ /\A@([^\.]+)\.([^\.]+)\z/
+          plugin_name = $1
+          command_name = $2
+          plugin = @plugins[plugin_name]
+          raise NoSuchPluginRegistered.new(plugin_name) unless plugin
+          ci = plugin.plugin_info.commands[command_name]
+          raise NoSuchCommandInPlugin.new(plugin_name, command_name) unless ci
+          plugin.send ci.execute_message, argstr
         else
-          errmsg "unknown command `#{command}'"
+          raise ShellUserError, "invalid command syntax"
         end
+      else
+        # unqualified command
+        ci = @commands[commandref]
+        raise NoSuchCommand.new(commandref) unless ci
+        @plugins[ci.plugin.plugin_name].send ci.execute_message, argstr
       end
     end
 
@@ -363,7 +473,7 @@ module CouchShell
             end
           elsif c == ')'
             if expr
-              res << shell_eval(expr).to_s
+              res << eval_expr(expr).to_s
               expr = nil
             else
               res << c
@@ -380,84 +490,28 @@ module CouchShell
       }
     end
 
-    def shell_eval(expr)
+    # Evaluate the given expression.
+    def eval_expr(expr)
       @eval_context.instance_eval(expr)
     end
 
+    # Lookup unqualified variable name.
     def lookup_var(var)
-      case var
-      when "uuid"
-        command_uuids nil
-        if @responses.current(&:ok?)
-          json = @responses.current.json
-          if json && (uuids = json.couch_shell_ruby_value!["uuids"]) &&
-              uuids.kind_of?(Array) && uuids.size > 0
-            uuids[0]
-          else
-            raise ShellUserError,
-              "interpolation failed due to unkown json structure"
-          end
-        else
-          raise ShellUserError, "interpolation failed"
-        end
-      when "id"
-        @responses.current { |r| r.attr "id", "_id" } or
-          raise ShellUserError, "variable `id' not set"
-      when "rev"
-        @responses.current { |r| r.attr "rev", "_rev" } or
-          raise ShellUserError, "variable `rev' not set"
-      when "idr"
-        "#{lookup_var 'id'}?rev=#{lookup_var 'rev'}"
-      when "content-type"
-        @responses.current(&:content_type)
-      when "server"
-        if @server_url
-          u = @server_url
-          "#{u.scheme}://#{u.host}:#{u.port}#{u.path}"
-        else
-          raise ShellUserError, "variable `server' not set"
-        end
-      when /\Ar(\d)\z/
-        i = $1.to_i
-        if @responses.readable_index?(i)
-          @responses[i]
-        else
-          raise ShellUserError, "no response index #{i}"
-        end
-      when /\Aj(\d)\z/
-        i = $1.to_i
-        if @responses.readable_index?(i)
-          if @responses[i].json
-            @responses[i].json
-          else
-            raise ShellUserError, "no json in response #{i}"
-          end
-        else
-          raise ShellUserError, "no response index #{i}"
-        end
-      when "viewtext"
-        @viewtext or
-          raise ShellUserError, "viewtext not set"
-      else
-        raise UndefinedVariable.new(var)
-      end
-    end
-
-    def request_command_with_body(method, argstr)
-      if argstr =~ JSON_DOC_START_RX
-        url, bodyarg = nil, argstr
-      else
-        url, bodyarg= argstr.split(/\s+/, 2)
-      end
-      if bodyarg && bodyarg.start_with?("@")
-        filename, content_type = bodyarg[1..-1].split(/\s+/, 2)
-        body = FileToUpload.new(filename, content_type)
+      vi = @variables[var]
+      if vi
+        plugin = @plugins[vi.plugin.plugin_name]
+        plugin.send vi.lookup_message
       else
-        body = bodyarg
+        vi = @variable_prefixes.find { |v|
+          var.start_with?(v.prefix) && var.length > v.prefix.length
+        }
+        raise UndefinedVariable.new(var) unless vi
+        plugin = @plugins[vi.plugin.plugin_name]
+        plugin.send vi.lookup_message, var[vi.prefix.length]
       end
-      real_url = interpolate(url)
-      request method, real_url, body
-      real_url
+    rescue Plugin::VarNotSet => e
+      e.var = vi
+      raise e
     end
 
     def editor_bin!
@@ -465,273 +519,8 @@ module CouchShell
         raise ShellUserError, "EDITOR environment variable not set"
     end
 
-    def command_get(argstr)
-      request "GET", interpolate(argstr)
-    end
-
-    def command_put(argstr)
-      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
-
-    def command_delete(argstr)
-      request "DELETE", interpolate(argstr)
-    end
-
-    def command_cd(argstr)
-      cd interpolate(argstr), false
-    end
-
-    def command_cg(argstr)
-      cd interpolate(argstr), true
-    end
-
-    def command_exit(argstr)
-      raise Quit
-    end
-
-    def command_quit(argstr)
-      raise Quit
-    end
-
-    def command_uuids(argstr)
-      count = argstr ? argstr.to_i : 1
-      request "GET", "/_uuids?count=#{count}"
-    end
-
-    def command_echo(argstr)
-      if argstr
-        @stdout.puts interpolate(argstr)
-      end
-    end
-
-    def command_print(argstr)
-      unless argstr
-        errmsg "expression required"
-        return
-      end
-      @stdout.puts shell_eval(argstr)
-    end
-
-    def command_format(argstr)
-      unless argstr
-        errmsg "expression required"
-        return
-      end
-      val = shell_eval(argstr)
-      if val.respond_to?(:couch_shell_format_string)
-        @stdout.puts val.couch_shell_format_string
-      else
-        @stdout.puts val
-      end
-    end
-
-    def command_server(argstr)
-      self.server = argstr
-    end
-
-    def command_expand(argstr)
-      @stdout.puts expand(interpolate(argstr))
-    end
-
-    def command_sh(argstr)
-      unless argstr
-        errmsg "argument required"
-        return
-      end
-      unless system(argstr)
-        errmsg "command exited with status #{$?.exitstatus}"
-      end
-    end
-
-    def command_editview(argstr)
-      if @pathstack.size != 1
-        raise ShellUserError, "current directory must be database"
-      end
-      design_name, view_name = argstr.split(/\s+/, 2)
-      if design_name.nil? || view_name.nil?
-        raise ShellUserError, "design and view name required"
-      end
-      request "GET", "_design/#{design_name}", nil, false
-      return unless @responses.current(&:ok?)
-      design = @responses.current.json
-      view = nil
-      if design.respond_to?(:views) &&
-          design.views.respond_to?(view_name.to_sym)
-        view = design.views.__send__(view_name.to_sym)
-      end
-      mapval = view && view.respond_to?(:map) && view.map
-      reduceval = view && view.respond_to?(:reduce) && view.reduce
-      t = Tempfile.new(["view", ".js"])
-      t.puts("map")
-      if mapval
-        t.puts mapval
-      else
-        t.puts "function(doc) {\n  emit(doc._id, doc);\n}"
-      end
-      if reduceval || view.nil?
-        t.puts
-        t.puts("reduce")
-        if reduceval
-          t.puts reduceval
-        else
-          t.puts "function(keys, values, rereduce) {\n\n}"
-        end
-      end
-      t.close
-      continue?(
-        "Press ENTER to edit #{view ? 'existing' : 'new'} view, " +
-        "CTRL+C to cancel ")
-      unless system(editor_bin!, t.path)
-        raise ShellUserError, "editing command failed with exit status #{$?.exitstatus}"
-      end
-      text = t.open.read
-      @viewtext = text
-      t.close
-      mapf = nil
-      reducef = nil
-      inmap = false
-      inreduce = false
-      i = 0
-      text.each_line { |line|
-        i += 1
-        case line
-        when /^map\s*(.*)$/
-          unless $1.empty?
-            msg "recover view text with `print viewtext'"
-            raise ShellUserError, "invalid map line at line #{i}"
-          end
-          unless mapf.nil?
-            msg "recover view text with `print viewtext'"
-            raise ShellUserError, "duplicate map line at line #{i}"
-          end
-          inreduce = false
-          inmap = true
-          mapf = ""
-        when /^reduce\s*(.*)$/
-          unless $1.empty?
-            msg "recover view text with `print viewtext'"
-            raise ShellUserError, "invalid reduce line at line #{i}"
-          end
-          unless reducef.nil?
-            msg "recover view text with `print viewtext'"
-            raise ShellUserError, "duplicate reduce line at line #{i}"
-          end
-          inmap = false
-          inreduce = true
-          reducef = ""
-        else
-          if inmap
-            mapf << line
-          elsif inreduce
-            reducef << line
-          elsif line =~ /^\s*$/
-            # ignore
-          else
-            msg "recover view text with `print viewtext'"
-            raise ShellUserError, "unexpected content at line #{i}"
-          end
-        end
-      }
-      mapf.strip! if mapf
-      reducef.strip! if reducef
-      mapf = nil if mapf && mapf.empty?
-      reducef = nil if reducef && reducef.empty?
-      prompt_msg "View parsed, following actions would be taken:"
-      if mapf && mapval.nil?
-        prompt_msg " Add map function."
-      elsif mapf.nil? && mapval
-        prompt_msg " Remove map function."
-      elsif mapf && mapval && mapf != mapval
-        prompt_msg " Update map function."
-      end
-      if reducef && reduceval.nil?
-        prompt_msg " Add reduce function."
-      elsif reducef.nil? && reduceval
-        prompt_msg " Remove reduce function."
-      elsif reducef && reduceval && reducef != reduceval
-        prompt_msg " Update reduce function."
-      end
-      continue? "Press ENTER to submit, CTRL+C to cancel "
-      if !design.respond_to?(:views)
-        design.set_attr!("views", {})
-      end
-      if view.nil?
-        design.views.set_attr!(view_name, {})
-        view = design.views.__send__(view_name.to_sym)
-      end
-      if mapf.nil?
-        view.delete_attr!("map")
-      else
-        view.set_attr!("map", mapf)
-      end
-      if reducef.nil?
-        view.delete_attr!("reduce")
-      else
-        view.set_attr!("reduce", reducef)
-      end
-      request "PUT", "_design/#{design_name}", design.to_s
-      unless @responses.current(&:ok?)
-        msg "recover view text with `print viewtext'"
-      end
-    ensure
-      if t
-        t.close
-        t.unlink
-      end
-    end
-
-    def command_view(argstr)
-      if @pathstack.size != 1
-        raise ShellUserError, "current directory must be database"
-      end
-      design_name, view_name = argstr.split("/", 2)
-      if design_name.nil? || view_name.nil?
-        raise ShellUserError, "argument in the form DESIGN/VIEW required"
-      end
-      request "GET", "_design/#{design_name}/_view/#{view_name}"
-    end
-
-    def command_member(argstr)
-      id, rev = nil, nil
-      json = @responses.current(&:json)
-      unless json && (id = json.attr_or_nil!("_id")) &&
-          (rev = json.attr_or_nil!("_rev")) &&
-          (@pathstack.size > 0) &&
-          (@pathstack.last == id.to_s)
-        raise ShellUserError,
-          "`cg' the desired document first, e.g.: `cg /my_db/my_doc_id'"
-      end
-      # TODO: read json string as attribute name if argstr starts with double
-      # quote
-      attr_name, new_valstr = argstr.split(/\s+/, 2)
-      unless attr_name && new_valstr
-        raise ShellUserError,
-          "attribute name and new value argument required"
-      end
-      if new_valstr == "remove"
-        json.delete_attr!(attr_name)
-      else
-        new_val = JsonValue.parse(new_valstr)
-        json.set_attr!(attr_name, new_val)
-      end
-      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
+    def read_secret
+      @highline.ask(" ") { |q| q.echo = "*" }
     end
 
   end