elasticshell 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Dhruv Bansal
+
+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/README.rdoc

@@ -0,0 +1,207 @@
+= Elasticshell
+
+Elasticsearch[http://www.elasticsearch.org] is a wonderful database
+for performing full-text on rich documents at terabyte-scale.
+
+It's already pretty easy to talk to Elasticsearch.  You can
+
+- use the HTTP-based, {REST
+  API}[http://www.elasticsearch.org/guide/reference/api/] via
+  commmand-line tools like curl[http://en.wikipedia.org/wiki/CURL], your favorite HTTP library, or even
+  your browser's URL bar
+
+- use the interface built on Apache Thrift
+
+- use the native {Java classes}[http://www.elasticsearch.org/guide/reference/java-api/]
+
+What's missing was a command-line shell that let you directly inspect
+Elasticsearch's "filesystem" or "database schema", run queries, and in
+general muck about.  I got sick of writing things like
+
+  $ curl -s -X GET "http://localhost:9200/_status" | ruby -rjson -e 'puts JSON.parse($stdin.read)["indices"]["my_index"]["docs"]["num_docs"]'
+
+How about
+
+  $ es /_status --only=indices.my_index.docs.num_docs
+
+== Installation
+
+Installing Elasticshell should be as simple as installing the gem:
+
+  $ sudo gem install elasticshell
+
+This should install a binary program 'es' that you can run from the
+command line to start Elasticshell.  Try
+
+  $ es --help
+
+right now to see that everything is properly installed.  You'll also
+see a brief survey of Elasticshell's startup options.
+
+== Usage
+
+To start an Elasticshell session, just run
+
+  $ es
+
+Elasticshell will automatically try to connect to a local
+Elasticsearch database running on the default port.  You can modify
+this with the startup options.  Type +help+ at any time to get some
+contextual help from Elasticshell.
+
+Within Elasticshell, there are three variables whose values affect
+behavior.  These variables are reflected in the default prompt, for
+example:
+
+  GET /my_index/my_type >
+
+This prompt tells us three things:
+
+1. The default HTTP verb we're using for requests is +GET+.
+
+2. The default API "scope" we're in is <tt>/my_index/my_type</tt>.
+
+3. Elasticshell will print raw responses from the database -- this is the <tt>></tt> at the end of the prompt.  If we were in pretty-print mode, this would become a <tt>$</tt>.
+
+=== Changing Scope
+
+Use the +cd+ built-in to move between scopes:
+
+  GET /my_index/my_type > cd /other_index/other_type
+  GET /other_index/other_type > cd ..
+  GET /other_index > cd
+  GET / >
+
+Tab-complete within a scope after typing +cd+ to see what other scopes
+live under this one.
+
+=== Changing HTTP Verb
+
+You can change Elasticsearch's default HTTP verb by giving it one.
+Here's the same thing in two steps:
+
+  GET / > PUT
+  PUT / > /my_new_index
+
+Non-ambiguous shortcuts for HTTP verbs will also work, e.g. - +pu+ in
+this case for +PUT+.
+
+=== Changing Prettiness
+
+Typing +pretty+ at any time will toggle Elasticsearch's
+pretty-printing format on or off.
+
+  GET / > pretty
+  GET / $
+
+The <tt>$</tt>-sign means it's pretty...
+
+=== Running Commands
+
+There are a lot of different ways of telling Elasticsearch what you
+want done.
+
+==== Named commands
+
+Each scope has different commands, as per the {Elasticsearch API
+documentation}[http://www.elasticsearch.org/guide/reference/api/].
+Within a scope, tab-complete on the first word to see a list of
+possible commands.  Hit enter after a command to see output from
+Elasticsearch.
+
+Here's a command to get the status for the cluster:
+
+  GET / > _status
+
+Here's a command to get the health of the cluster:
+
+  GET / > cd _cluster
+  GET /_cluster > health
+
+==== Commands with query strings  
+
+Commands will also accept a query string, as in this example of a
+search through +my_index+:
+
+  GET /my_index > _search?q=foo+AND+bar
+  
+==== Commands with query bodies  
+
+In this example the query <tt>foo AND bar</tt> was passed via the
+query string part of a URL.  Passing a more complex query requires we
+put the query in the body of the request.  If you're willing to forego
+using spaces you can do this right on the same line:
+
+  GET /my_index > _search {"query":{"query_string":{"query":"foo"}}}
+
+But if you want more expressiveness you can either name a file (with
+tab-completion) that contains the body you want:
+
+  # in /tmp/query.json
+  {
+    "query": {
+      "query_string: {
+        "query": "foo AND bar"
+      }
+    }
+  }
+	  
+followed by
+
+  GET /my_index > _search /tmp/query.json
+
+Or you can do +cat+-style, pasting the query into the shell, by using
+the <tt>-</tt> character:
+
+  GET /my_index > _search -
+  {
+    "query": {
+      "query_string: {
+        "query": "foo AND bar"
+      }
+    }
+  }  
+
+Don't forget to use <tt>Ctrl-D</tt> to send an +EOF+ to flush the
+input of the query.
+
+==== Arbitrary commands
+
+You can send an arbitrary HTTP request to Elasticsearch, just spell
+the command with a leading slash:
+
+  GET / > /my_index/_search?q=foo+AND+bar
+
+You can specify a different HTTP verb by prefixing it before the path
+you send the request to.  Here's how to create an index using a +PUT+
+request:
+
+  GET / > PUT /my_new_index
+
+You can also change Elasticsearch's default HTTP verb by giving it
+one.  Here's the same thing in two steps:
+
+  GET / > PUT
+  PUT / > /my_new_index
+
+Non-ambiguous shortcuts for HTTP verbs will also work, e.g. - +pu+ in
+this case for +PUT+.
+
+=== Running just a single command
+
+Instead of running Elasticshell interactively, you can exit after
+running only a single command by using the <tt>--only</tt> option on
+startup.  For example,
+
+  $ es --only /_cluster/health
+
+will output the cluster health and exit immediately.  This can be
+combined with the <tt>--pretty</tt> option for readability.
+
+The <tt>--only</tt> option can also be passed a <tt>.</tt>-separated
+hierarchical list of keys to slice into the resulting object.  This is
+useful when trying to drill into a large amount of data returned by
+Elasticsearch.  The example from the start of this file is relevant
+again here:
+
+  $ es /_status --only=indices.my_index.docs.num_docs

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/es

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__) unless $:.include?($: << File.expand_path('../../lib', __FILE__))
+require 'elasticshell'
+
+Elasticshell.start if __FILE__ == $0

data/lib/elasticshell/client.rb

@@ -0,0 +1,45 @@
+require 'rubberband'
+require 'elasticshell/error'
+require 'elasticshell/log'
+
+module Elasticshell
+
+  class Client
+
+    DEFAULT_SERVERS = ['http://localhost:9200']
+
+    def initialize options={}
+      @client ||= ::ElasticSearch::Client.new(options[:servers] || DEFAULT_SERVERS)
+    end
+
+    def request verb, params={}, options={}, body=''
+      safe        = options.delete(:safely)
+      safe_return = options.delete(:return)
+      # log_request(verb, params, options)
+      begin
+        @client.execute(:standard_request, verb, params, options, body)
+      rescue ElasticSearch::RequestError, ArgumentError => e
+        if safe
+          safe_return
+        else
+          raise ClientError.new(e.message)
+        end
+      end
+    end
+
+    def log_request verb, params, options={}
+      # FIXME digging way too deep into rubberband here...is it really
+      # necessary?
+      uri   = @client.instance_variable_get('@connection').send(:generate_uri, params)
+      query = @client.instance_variable_get('@connection').send(:generate_query_string, options)
+      path  = [uri, query].reject { |s| s.nil? || s.strip.empty? }.join("?")
+      Elasticshell.log("#{verb.to_s.upcase} #{path}")
+    end
+
+    def safely verb, params={}, options={}, body=''
+      request(verb, params, options.merge(:safely => true))
+    end
+  
+  end
+
+end

data/lib/elasticshell/command.rb

@@ -0,0 +1,191 @@
+require 'elasticshell/error'
+require 'uri'
+
+module Elasticshell
+
+  class Command
+
+    HTTP_VERB_RE = "(?:G(?:ET?)?|PO(?:ST?)?|PUT?|D(?:E(?:L(?:E(?:TE?)?)?)?)?)"
+
+    attr_accessor :shell, :input
+
+    def initialize shell, input
+      self.shell = shell
+      self.input = input
+    end
+
+    def evaluate!
+      case
+      when setting_scope?          then set_scope!
+      when setting_http_verb?      then set_http_verb!
+      when making_explicit_req?    then make_explicit_req!
+      when pretty?                 then pretty!
+      when help?                   then help!
+      when ls?                     then ls!
+      when blank?                  then nil
+      when scope_command?          then run_scope_command!        
+      else
+        raise ArgumentError.new("Unknown command '#{input}' for scope '#{shell.scope.path}'.  Try typing 'help' for a list of available commands.")
+      end
+    end
+
+    def setting_scope?
+      input =~ /^cd/
+    end
+
+    def set_scope!
+      if input =~ /^cd$/
+        shell.scope = Scopes.global(:client => shell.client)
+        return
+      end
+      
+      return unless input =~ /^cd\s+(.+)$/
+      scope = $1
+      if scope =~ %r!^/!
+        shell.scope = Scopes.from_path(scope, :client => shell.client)
+      else
+        shell.scope = Scopes.from_path(File.expand_path(File.join(shell.scope.path, scope)), :client => shell.client)
+      end
+    end
+
+    def setting_http_verb?
+      input =~ Regexp.new("^" + HTTP_VERB_RE + "$", true)
+    end
+
+    def canonicalize_http_verb v
+      case v
+      when /^G/i  then "GET"
+      when /^PO/i then "POST"
+      when /^PU/i then "PUT"
+      when /^D/i  then "DELETE"
+      end
+    end
+
+    def set_http_verb!
+      shell.verb = canonicalize_http_verb(input)
+    end
+
+    def scope_command?
+      shell.scope.command?(input)
+    end
+
+    def run_scope_command!
+      shell.scope.execute(input, shell)
+    end
+
+    def blank?
+      input.empty?
+    end
+
+    def help?
+      input =~ /^help/i
+    end
+
+    def help!
+      shell.scope.refresh
+      shell.print <<HELP
+
+Globally available commands:
+
+  cd [PATH]
+    Change scope to the given path.  Current path is reflected in the
+    prompt (it's '#{shell.scope.path}' right now).
+
+    Ex:
+      GET / > cd /my_index
+      GET /my_index > cd /other_index/some_type
+      GET /other_index/some_type
+
+  [get|post|put|delete]
+    Set the default HTTP verb (can use a non-ambiguous shortcut like 'g'
+    for 'GET' or 'pu' for 'PUT').  Current default HTTP verb is '#{shell.verb}'.
+
+  ls
+    Show what indices or mappings are within the current scope.
+
+  help
+    Show contextual help.
+
+  [VERB] PATH
+    Send an HTTP request with the given VERB to the given PATH
+    (including query string if given).  If no verb is given, use the
+    default.
+
+    Ex: Simple search
+      GET / > /my_index/_search?q=query+string
+      {...}
+
+    Ex: Create an index
+      GET / > PUT /my_new_index
+      {...}
+
+      or
+
+      GET / > put
+      PUT / > /my_new_index
+      {...}
+
+#{shell.scope.help}
+HELP
+    end
+
+    def ls?
+      input =~ /^l(s|l|a)?$/i
+    end
+
+    def ls!
+      shell.scope.refresh!
+      case
+      when input =~ /ll/
+        shell.print shell.scope.contents.join("\n")
+      else
+        shell.print shell.scope.contents.join(' ')
+      end
+    end
+
+    def pretty?
+      input =~ /pretty/i
+    end
+
+    def pretty!
+      if shell.pretty?
+        shell.not_pretty!
+      else
+        shell.pretty!
+      end
+    end
+
+    def making_explicit_req?
+      input =~ Regexp.new("^(" + HTTP_VERB_RE + "\s+)?/", true)
+    end
+
+    def make_explicit_req!
+      if input =~ Regexp.new("^(" + HTTP_VERB_RE + ")\s+(.+)$", true)
+        verb, path_and_query = canonicalize_http_verb($1), $2
+      else
+        verb, path_and_query = shell.verb, input
+      end
+      path, query = path_and_query.split('?')
+      
+      params = {}
+      keys  = [:index, :type, :id, :op]
+      parts = path.gsub(%r!^/!,'').gsub(%r!/$!,'').split('/')
+      while parts.size > 0
+        part = parts.shift
+        key  = (keys.shift or ArgumentError.new("The input '#{path}' has too many path components."))
+        params[key] = part
+      end
+
+      options = {}
+      URI.decode_www_form(query || '').each do |key, value|
+        options[key] = value
+      end
+      
+      shell.print(shell.client.request(verb.downcase.to_sym, params, options))
+    end
+    
+    
+  end
+  
+end
+

data/lib/elasticshell/error.rb

@@ -0,0 +1,8 @@
+module Elasticshell
+
+  Error               = Class.new(StandardError)
+  ArgumentError       = Class.new(Error)
+  NotImplementedError = Class.new(Error)
+  ClientError         = Class.new(Error)
+
+end

data/lib/elasticshell/log.rb

@@ -0,0 +1,9 @@
+module Elasticshell
+
+  def self.log msg
+    $stderr.puts("\n" + msg + "\n")
+  end
+  
+end
+
+  

data/lib/elasticshell/scopes/cluster.rb

@@ -0,0 +1,38 @@
+require 'elasticshell/scopes'
+
+module Elasticshell
+
+  module Scopes
+
+    class Cluster < Scope
+
+      def initialize options={}
+        super("/_cluster", options)
+      end
+
+      def commands
+        {
+          'health'  => "Retreive the health of the cluster.",
+          'state'   => "Retreive the state of the cluster.",
+          'settings'=> "Retreive the settings for the cluster.",
+        }
+      end
+
+      def exists?
+        true
+      end
+
+      def execute command, shell
+        case
+        when command?(command)
+          shell.request(:get, :index => '_cluster')
+        else
+          super(command, shell)
+        end
+      end
+      
+    end
+  end
+end
+
+  

data/lib/elasticshell/scopes/global.rb

@@ -0,0 +1,54 @@
+require 'elasticshell/scopes'
+
+module Elasticshell
+
+  module Scopes
+
+    class Global < Scope
+
+      def initialize options={}
+        super("/", options)
+      end
+
+      def commands
+        {
+          '_status'  => "Retreive the status of all indices in the cluster."
+        }
+      end
+
+      def initial_contents
+        ['_cluster', '_nodes']
+      end
+
+      def fetch_contents
+        self.contents += client.safely(:get, {:index => '_status'}, :return => {"indices" => {}})["indices"].keys
+      end
+
+      def index name, options={}
+        Scopes.index(name, options, :client => client)
+      end
+
+      def exists?
+        true
+      end
+
+      def execute command, shell
+        case
+        when command =~ /^_cluster/
+          shell.scope = Scopes.cluster(:client => client)
+        when command =~ /^_nodes/
+          shell.scope = Scopes.nodes(:client => client)
+        when command?(command)
+          shell.request(:get)
+        when index_names.include?(command)
+          shell.scope = index(command)
+        else
+          super(command, shell)
+        end
+      end
+      
+    end
+  end
+end
+
+  

data/lib/elasticshell/scopes/index.rb

@@ -0,0 +1,61 @@
+require 'elasticshell/scopes'
+
+module Elasticshell
+
+  module Scopes
+
+    class Index < Scope
+
+      VALID_INDEX_NAME_RE = %r![^/]!
+
+      def initialize name, options={}
+        self.name = name
+        super("/#{self.name}", options)
+      end
+
+      attr_reader :name
+      def name= name
+        raise ArgumentError.new("Invalid index name: '#{name}'") unless name =~ VALID_INDEX_NAME_RE
+        @name = name
+      end
+
+      def commands
+        {
+          "_aliases" => "Find the aliases for this index.",
+          "_status"  => "Retrieve the status of this index.",
+          "_stats"   => "Retrieve usage stats for this index.",
+          "_search"  => "Search records within this index.",
+        }
+      end
+
+      def global
+        @global ||= Scopes.global(:client => client)
+      end
+
+      def exists?
+        global.refresh
+        global.contents.include?(name)
+      end
+
+      def fetch_contents
+        @contents = (client.safely(:get, {:index => name, :op => '_mapping'}, :return => { name => {}})[name] || {}).keys
+      end
+
+      def mapping mapping_name, options={}
+        Scopes.mapping(self.name, mapping_name, options.merge(:client => client))
+      end
+
+      def execute command, shell
+        case
+        when command?(command)
+          shell.request(:get, :index => name)
+        when mapping_names.include?(command)
+          shell.scope = mapping(command)
+        else
+          super(command, shell)
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticshell/scopes/mapping.rb

@@ -0,0 +1,55 @@
+require 'elasticshell/scopes'
+
+module Elasticshell
+
+  module Scopes
+
+    class Mapping < Scope
+
+      VALID_MAPPING_NAME_RE = %r![^/]!
+
+      attr_accessor :index
+
+      def initialize index, name, options={}
+        self.index = index
+        self.name  = name
+        super("/#{index.name}/#{self.name}", options)
+      end
+
+      attr_reader :name
+      def name= name
+        raise ArgumentError.new("Invalid mapping name: '#{name}'") unless name =~ VALID_MAPPING_NAME_RE
+        @name = name
+      end
+
+      def commands
+        {
+          "_search"  => "Search records within this mapping.",
+          "_mapping" => "Retrieve the mapping settings for this mapping.",
+        }
+      end
+
+      def exists?
+        index.refresh
+        index.contents.include?(name)
+      end
+
+      def command? command
+        true
+      end
+
+      def execute command, shell
+        case
+        when command?(command)
+          shell.request(:get, :index => index.name, :type => name)
+        else
+          record = shell.request(:get, :index => index.name, :type => name)
+          shell.print(record) if record
+        end
+      end
+      
+    end
+  end
+end
+
+  

data/lib/elasticshell/scopes/nodes.rb

@@ -0,0 +1,37 @@
+require 'elasticshell/scopes'
+
+module Elasticshell
+
+  module Scopes
+
+    class Nodes < Scope
+
+      def initialize options={}
+        super("/_nodes", options)
+      end
+
+      def commands
+        {
+          'info'  => "Retreive info about the cluster's ndoes.",
+          'stats' => "Retreive stats for the cluter's nodes.",
+        }
+      end
+
+      def exists?
+        true
+      end
+
+      def execute command, shell
+        case
+        when command?(command)
+          shell.request(:get, :index => '_nodes')
+        else
+          super(command, shell)
+        end
+      end
+      
+    end
+  end
+end
+
+  

data/lib/elasticshell/scopes.rb

@@ -0,0 +1,155 @@
+require 'elasticshell/error'
+require 'uri'
+
+module Elasticshell
+  
+  module Scopes
+
+    autoload :Global,  'elasticshell/scopes/global'
+    autoload :Cluster, 'elasticshell/scopes/cluster'
+    autoload :Nodes,   'elasticshell/scopes/nodes'
+    autoload :Index,   'elasticshell/scopes/index'
+    autoload :Mapping, 'elasticshell/scopes/mapping'
+
+    def self.global options={}
+      Global.new(options)
+    end
+
+    def self.cluster options={}
+      Cluster.new(options)
+    end
+
+    def self.nodes options={}
+      Nodes.new(options)
+    end
+
+    def self.index name, options={}
+      Index.new(name, options)
+    end
+
+    def self.mapping index_name, mapping_name, options={}
+      Mapping.new(index(index_name, options), mapping_name, options)
+    end
+
+    def self.from_path path, options={}
+      segments = path.to_s.strip.gsub(%r!^/!,'').gsub(%r!/$!,'').split('/')
+      case
+      when segments.length == 0
+        global(options)
+      when segments.length == 1 && segments.first == '_cluster'
+        cluster(options)
+      when segments.length == 1 && segments.first == '_nodes'
+        nodes(options)
+      when segments.length == 1
+        index(segments.first, options)
+      when segments.length == 2
+        mapping(segments[0], segments[1], options)
+      else
+        raise ArgumentError.new("'#{path}' does not define a valid path for a scope.")
+      end
+    end
+  end
+
+  class Scope
+
+    attr_accessor :path, :client, :last_refresh_at, :contents
+
+    def initialize path, options
+      self.path     = path
+      self.client   = options[:client]
+      self.contents = initial_contents
+    end
+
+    def to_s
+      self.path
+    end
+
+    def completion_proc
+      Proc.new do |prefix|
+        refresh
+        case
+        when Readline.line_buffer =~ /^\s*cd\s+\S*$/
+          contents.find_all do |content|
+            content[0...prefix.length] == prefix
+          end
+        when Readline.line_buffer =~ /^\s*\S*$/
+          command_names.find_all do |command_name|
+            command_name[0...prefix.length] == prefix
+          end
+        else
+          Dir[prefix + '*']
+        end
+      end
+    end
+
+    def command_names
+      refresh
+      commands.keys.sort
+    end
+
+    def commands
+      {}
+    end
+
+    def refresh
+      refresh! unless refreshed?
+    end
+
+    def refresh!
+      reset!
+      fetch_contents
+      self.last_refresh_at = Time.now
+      true
+    end
+
+    def fetch_contents
+    end
+
+    def initial_contents
+      []
+    end
+
+    def reset!
+      self.contents = initial_contents
+      true
+    end
+
+    def refreshed?
+      self.last_refresh_at
+    end
+
+    def exists?
+      false
+    end
+
+    def command? command
+      command_names.any? do |command_name|
+        command[0...command_name.length] == command_name
+      end
+    end
+
+    def execute command, shell
+      if command_names.include?(command)
+        raise NotImplementedError.new("Have not yet implemented '#{command}' for scope '#{path}'.")
+      else
+        raise ArgumentError.new("No such command '#{command}' in scope '#{path}'.")
+      end
+    end
+
+    def help
+      [].tap do |msg|
+        msg << "Commands specific to the scope '#{path}':"
+        msg << ''
+        commands.each_pair do |command_name, description|
+          msg << '  ' + command_name
+          msg << ('    ' + description)
+          msg << ''
+        end
+      end.join("\n")
+    end
+
+  end
+  
+end
+
+  

data/lib/elasticshell/shell.rb

@@ -0,0 +1,189 @@
+require 'readline'
+require 'uri'
+
+require 'elasticshell/command'
+require 'elasticshell/scopes'
+require 'elasticshell/client'
+
+module Elasticshell
+
+  class Shell
+
+    VERBS = %w[GET POST PUT DELETE]
+    
+    attr_accessor :client, :input, :command, :state, :only
+
+    attr_reader :verb
+    def verb= v
+      raise ArgumentError.new("'#{v}' is not a valid HTTP verb.  Must be one of: #{VERBS.join(', ')}") unless VERBS.include?(v.upcase)
+      @verb = v.upcase
+    end
+
+    attr_reader :scope
+    def scope= scope
+      @scope = scope
+      proc = scope.completion_proc
+      Readline.completion_proc = Proc.new do |prefix|
+        self.state = :completion
+        proc.call(prefix)
+      end
+    end
+
+    def initialize options={}
+      self.state  = :init
+      self.client = Client.new(options)
+      self.verb   = (options[:verb] || 'GET')
+      self.scope  = Scopes.from_path((options[:scope] || '/'), :client => self.client)
+      self.only   = options[:only]
+      pretty! if options[:pretty]
+    end
+
+    def prompt
+      "\e[1m#{prompt_verb_color}#{verb} #{prompt_scope_color}#{scope.path} #{prompt_prettiness_indicator} \e[0m"
+    end
+
+    def prompt_scope_color
+      scope.exists? ? "\e[32m" : "\e[33m"
+    end
+
+    def prompt_verb_color
+      verb == "GET" ? "\e[34m" : "\e[31m"
+    end
+
+    def prompt_prettiness_indicator
+      pretty? ? '$' : '>'
+    end
+  
+    def pretty?
+      @pretty
+    end
+
+    def pretty!
+      @pretty = true
+    end
+
+    def not_pretty!
+      @pretty = false
+    end
+
+    def setup
+      trap("INT") do
+        int
+      end
+
+      Readline.completer_word_break_characters = " \t\n\"\\'`$><=|&{("
+      
+      puts <<EOF
+Elasticshell v. #{Elasticshell.version}
+Type "help" for contextual help.
+EOF
+    end
+
+    def run
+      setup
+      loop
+    end
+
+    def loop
+      self.state = :read
+      while line = Readline.readline(prompt, true)
+        eval_line(line)
+      end
+    end
+
+    def eval_line line
+      begin
+        self.input   = line.strip
+        self.command = Command.new(self, input)
+        self.state = :eval
+        self.command.evaluate!
+      rescue ::Elasticshell::Error => e
+        $stderr.puts e.message
+      end
+      self.state = :read
+    end
+
+    def print obj, ignore_only=false
+      if self.only && !ignore_only
+        if self.only == true
+          print(obj, true)
+        else
+          only_parts = self.only.to_s.split('.')
+          obj_to_print = obj
+          while obj_to_print && only_parts.size > 0
+            this_only = only_parts.shift
+            obj_to_print = (obj_to_print || {})[this_only]
+          end
+          print(obj_to_print, true)
+        end
+      else
+        case obj
+        when nil
+        when String, Fixnum
+          puts obj
+        else
+          if pretty?
+            puts JSON.pretty_generate(obj)
+          else
+            puts obj.to_json
+          end
+        end
+      end
+    end
+
+    def int
+      case self.state
+      when :read
+        $stdout.write("^C\n#{prompt}")
+      else
+        $stdout.write("^C...aborted\n#{prompt}")
+      end
+    end
+
+    def clear_line
+      while Readline.point > 0
+        $stdin.write("\b \b")
+      end
+    end
+
+    def die
+      puts "C-d"
+      print("C-d...quitting")
+      exit()
+    end
+
+    def command_and_query_and_body command
+      parts = command.split
+      
+      c_and_q = parts[0]
+      c, q = c_and_q.split('?')
+      o = {}
+      URI.decode_www_form(q || '').each do |k, v|
+        o[k] = v
+      end
+
+      path = parts[1]
+      case
+      when path && File.exist?(path) && File.readable?(path)
+        b = File.read(path)
+      when path && path == '-'
+        b = $stdin.gets(nil)
+      when path
+        b = path
+      else
+        b = (command.split(' ', 2).last || '')
+      end
+      
+      [c, o, b]
+    end
+    
+    def request verb, params={}
+      c, o, b = command_and_query_and_body(input)
+      body    = (params.delete(:body) || b || '')
+      print(client.request(verb, params.merge(:op => c), o, b))
+    end
+
+  end
+  
+end
+

data/lib/elasticshell.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'json'
+require 'configliere'
+
+require 'elasticshell/shell'
+require 'elasticshell/scopes'
+require 'elasticshell/client'
+
+Settings.use(:commandline)
+
+Settings.define(:servers, :description => "A comma-separated list of Elasticsearch servers to connect to.", :type => Array, :default => Elasticshell::Client::DEFAULT_SERVERS)
+Settings.define(:only,    :description => "A dot-separated hierarchical key to extract from the output scope.")
+Settings.define(:pretty,  :description => "Pretty-print all output. ", :default => false, :type => :boolean)
+Settings.define(:verb,    :description => "Set the default HTTP verb. ", :default => "GET")
+Settings.define(:version, :description => "Print Elasticshell version and exit. ", :default => false, :type => :boolean)
+Settings.description = <<-DESC
+Elasticshell is a command-line shell for interacting with an
+Elasticsearch database.  It has the following start-up options.
+DESC
+
+def Settings.usage
+  "usage: #{File.basename($0)} [OPTIONS] [SCOPE]"
+end
+Settings.resolve!
+
+module Elasticshell
+
+  def self.version
+    @version ||= begin
+      File.read(File.expand_path('../../VERSION', __FILE__)).chomp
+    rescue => e
+      'unknown'
+    end
+  end
+  
+  def self.start *args
+    if Settings[:version]
+      puts version
+      exit()
+    end
+    
+    es = Shell.new(Settings)
+    if Settings[:only]
+      if Settings.rest.length == 0
+        $stderr.puts "Starting with the --only option requires the first argument to name an API path (like `/_cluster/health')"
+        exit(1)
+      else
+        es.eval_line(Settings.rest.first)
+        exit()
+      end
+    else
+      if Settings.rest.length > 0
+        es.scope = Scopes.from_path(Settings.rest.first, :client => es.client)
+      end
+      es.run
+    end
+  end
+  
+end

data/spec/elasticshell/command_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Command do
+  
+end
+

data/spec/elasticshell/scopes_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Scopes do
+
+  it "should be able to recognize the global scope" do
+    Scopes::Global.should_receive(:new).with(kind_of(Hash))
+    Scopes.from_path("/")
+  end
+
+  it "should be able to recognize an index scope" do
+    Scopes::Index.should_receive(:new).with('foobar', kind_of(Hash))
+    Scopes.from_path("/foobar")
+  end
+
+  it "should be able to recognize a mapping scope" do
+    index = mock("Index /foobar")
+    Scopes::Index.should_receive(:new).with('foobar', kind_of(Hash)).and_return(index)
+    Scopes::Mapping.should_receive(:new).with(index, 'baz', kind_of(Hash))
+    Scopes.from_path("/foobar/baz")
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+
+ELASTICSHELL_ROOT = File.expand_path(__FILE__, '../../lib')
+$: << ELASTICSHELL_ROOT unless $:.include?(ELASTICSHELL_ROOT)
+require 'elasticshell'
+include Elasticshell
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |path| require path }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: elasticshell
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dhruv Bansal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: configliere
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubberband
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Elasticshell provides a command-line shell 'es' for connecting to and
+  querying an Elasticsearch database.  The shell will tab-complete Elasticsearch API
+  commands and index/mapping names.
+email:
+- dhruv@infochimps.com
+executables:
+- es
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/es
+- lib/elasticshell/scopes/cluster.rb
+- lib/elasticshell/scopes/mapping.rb
+- lib/elasticshell/scopes/global.rb
+- lib/elasticshell/scopes/index.rb
+- lib/elasticshell/scopes/nodes.rb
+- lib/elasticshell/command.rb
+- lib/elasticshell/log.rb
+- lib/elasticshell/shell.rb
+- lib/elasticshell/client.rb
+- lib/elasticshell/error.rb
+- lib/elasticshell/scopes.rb
+- lib/elasticshell.rb
+- spec/elasticshell/scopes_spec.rb
+- spec/elasticshell/command_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- README.rdoc
+- VERSION
+homepage: http://github.com/dhruvbansal/elasticshell
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A command-line shell for Elasticsearch
+test_files: []
+has_rdoc: