couch-shell 0.0.5 → 0.0.6

data/lib/couch-shell.rb

@@ -42,6 +42,11 @@ module CouchShell
     end
 
     shell = Shell.new(STDIN, STDOUT, STDERR)
+    shell.plugin "core"
+    shell.plugin "core_edit"
+    shell.plugin "core_views"
+    shell.plugin "core_designs"
+    shell.plugin "core_lucene"
     shell.execute "user #{user}" if user
     shell.execute "server #{server}" if server
     shell.execute "cg #{path}" if path

data/lib/couch-shell/eval_context.rb

@@ -1,18 +1,41 @@
 # -*- encoding: utf-8 -*-
 
+require "couch-shell/exceptions"
+
 module CouchShell
 
   class EvalContext < BasicObject
 
+    # weird trickery ahead
+    # we want only instance_variable_set from kernel
+    include ::Kernel
+    alias_method :_instance_variable_set, :instance_variable_set
+    (::Kernel.instance_methods + ::Kernel.private_instance_methods).each { |m|
+      # Ruby 1.9.2p0 prints a warning when undefining object_id,
+      # although BasicObject doesn't define it anyway, making this
+      # warning obsolete IMHO.
+      if m == :object_id
+        oldv = $VERBOSE
+        begin
+          $VERBOSE = nil
+          undef_method m
+        ensure
+          $VERBOSE = oldv
+        end
+      else
+        undef_method m
+      end
+    }
+
     def initialize(vardict)
-      @vardict = vardict
+      @_vardict = vardict
     end
 
     def method_missing(msg, *args)
       if args.empty?
-        @vardict.lookup_var msg.to_s
+        @_vardict.lookup_var msg.to_s
       else
-        super
+        raise ShellUserError, "unexpected syntax at #{msg}"
       end
     end
 

data/lib/couch-shell/exceptions.rb

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+
+module CouchShell
+
+  class Quit < Exception
+  end
+
+  class ShellUserError < Exception
+  end
+
+  class UndefinedVariable < ShellUserError
+
+    attr_reader :varname
+
+    def initialize(varname)
+      @varname = varname
+    end
+
+  end
+
+  class NoSuchPluginRegistered < ShellUserError
+
+    attr_reader :plugin_name
+
+    def initialize(plugin_name)
+      @plugin_name = plugin_name
+    end
+
+    def message
+      "No such plugin registered: #@plugin_name"
+    end
+
+  end
+
+  class NoSuchCommandInPlugin < ShellUserError
+
+    attr_reader :plugin_name
+    attr_reader :command_name
+
+    def initialize(plugin_name, command_name)
+      @plugin_name = plugin_name
+      @command_name = command_name
+    end
+
+    def message
+      "Plugin #@plugin_name doesn't define a #@command_name command."
+    end
+
+  end
+
+  class NoSuchCommand < ShellUserError
+    
+    attr_reader :command_name
+
+    def initialize(command_name)
+      @command_name = command_name
+    end
+
+    def message
+      "No such command: #@command_name"
+    end
+
+  end
+
+end

data/lib/couch-shell/json_value.rb

@@ -4,12 +4,31 @@ require "json"
 
 module CouchShell
 
+  # Wraps a Ruby data structure that represents a json value. If the wrapped
+  # document is of type object, members can be accessed method call syntax. To
+  # avoid shadowing of object members, almost all JsonValue instance methods
+  # end in ! or ?.
+  #
+  #   j = JsonValue.wrap({"a" => 1})
+  #   j.a             # => #<JsonValue 1>
+  #   j.unwrapped!    # => {"a" => 1}
+  #
+  # Attributes can also be accessed via []
+  #
+  #   j["a"]          # => #<JsonValue 1>
+  #
+  # Arrays elements too
+  #
+  #   j = JsonValue.wrap(["a", "b"])
+  #   j[0]            # => #<JsonValue "a">
+  #
+  # The wrapped data structure mustn't be modified.
   class JsonValue < BasicObject
 
     def self.wrap(ruby_value)
       case ruby_value
       when ::Hash
-        h = ::Hash.new(ruby_value.size)
+        h = ::Hash.new
         ruby_value.each { |k, v|
           h[k] = wrap(v)
         }
@@ -36,6 +55,14 @@ module CouchShell
       end
     end
 
+    def self.rval(obj)
+      if obj.respond_to?(:couch_shell_ruby_value!)
+        obj.couch_shell_ruby_value!
+      else
+        obj
+      end
+    end
+
     def initialize(value, ruby_value)
       @value = value
       @ruby_value = ruby_value
@@ -59,9 +86,32 @@ module CouchShell
               end
     end
 
+    def object?
+      @type == :object
+    end
+
+    def array?
+      @type == :array
+    end
+
+    def string?
+      @type == :string
+    end
+
+    def number?
+      @type == :number
+    end
+
+    def boolean?
+      @type == :boolean
+    end
+
+    def null?
+      @type == :null
+    end
+
     def respond_to?(msg)
-      msg == :format || msg == :couch_shell_format_string ||
-        msg == :type || msg == :ruby_value || msg == :to_s ||
+      msg == :couch_shell_format_string! || msg == :to_s ||
         msg == :couch_shell_ruby_value! ||
         (@type == :object && @value.has_key?(msg.to_s))
     end
@@ -76,35 +126,47 @@ module CouchShell
       super
     end
 
+    # Access object member (i must be a string) or array element (i must be an
+    # integer). Returns a JsonValue or nil if the object member or array index
+    # doesn't exist.
     def [](i)
-      ::Kernel.raise ::TypeError unless @type == :array
-      @value[i]
-    end
-
-    def to_s
-      case @type
-      when :object, :array
-        ::JSON.generate(@ruby_value)
-      when :null
-        "null"
+      ri = JsonValue.rval(i)
+      case ri
+      when ::String
+        unless @type == :object
+          ::Kernel.raise ::TypeError,
+            "string indexing only allowed for objects"
+        end
+        @value[ri]
+      when ::Integer
+        unless @type == :array
+          ::Kernel.raise ::TypeError,
+            "integer indexing only allowed for arrays"
+        end
+        @value[ri]
       else
-        @ruby_value.to_s
+        ::Kernel.raise ::TypeError,
+          "index must be string or integer"
       end
     end
 
-    def format
+    def to_s(format = false)
       case @type
       when :object, :array
-        ::JSON.pretty_generate(@ruby_value)
+        if format
+          ::JSON.pretty_generate(@ruby_value)
+        else
+          ::JSON.generate(@ruby_value)
+        end
       when :null
         "null"
-      when
+      else
         @ruby_value.to_s
       end
     end
 
-    def couch_shell_format_string
-      format
+    def couch_shell_format_string!
+      to_s true
     end
 
     def delete_attr!(name)
@@ -124,6 +186,7 @@ module CouchShell
     def couch_shell_ruby_value!
       @ruby_value
     end
+    alias unwrapped! couch_shell_ruby_value!
 
     def nil?
       false
@@ -134,6 +197,15 @@ module CouchShell
       @value[name]
     end
 
+    def inspect
+      "#<JsonValue #{to_s}>"
+    end
+
+    def length
+      raise ::TypeError, "length of #@type" unless array?
+      @ruby_value.length
+    end
+
   end
 
 end

data/lib/couch-shell/plugin.rb

@@ -0,0 +1,251 @@
+# -*- encoding: utf-8 -*-
+
+require "unicode_utils/uppercase_char_q"
+require "unicode_utils/downcase"
+require "decorate"
+require "couch-shell/exceptions"
+require "couch-shell/plugin_utils"
+
+module CouchShell
+
+  class VariableInfo
+
+    attr_reader :name
+    attr_reader :prefix
+    attr_reader :tags
+    attr_reader :doc_line
+    attr_reader :doc_text
+    attr_reader :lookup_message
+    attr_reader :plugin
+
+    def initialize(opts)
+      @name = opts[:name]
+      @prefix = opts[:prefix]
+      raise "name or prefix required" unless @name || @prefix
+      raise "only name OR prefix allowed" if @name && @prefix
+      @tags = [@name || @prefix].concat(opts[:tags] || [])
+      @doc_line = opts[:doc_line] or raise "doc_line required"
+      @doc_text = opts[:doc_text]
+      @lookup_message = opts[:lookup_message] or raise "lookup_message required"
+      @plugin = opts[:plugin] or raise "plugin required"
+    end
+
+    def label
+      @name || "#@prefix*"
+    end
+
+  end
+
+  class CommandInfo
+
+    attr_reader :name
+    attr_reader :tags
+    attr_reader :synopsis
+    attr_reader :doc_line
+    attr_reader :doc_text
+    attr_reader :execute_message
+    attr_reader :plugin
+
+    def initialize(opts)
+      @name = opts[:name] or raise "name required"
+      @tags = [@name].concat(opts[:tags] || [])
+      @synopsis = opts[:synopsis]
+      @doc_line = opts[:doc_line] or raise "doc_line required"
+      @doc_text = opts[:doc_text]
+      @execute_message = opts[:execute_message] or raise "execute_message required"
+      @plugin = opts[:plugin] or raise "plugin required"
+    end
+
+  end
+
+  class PluginInfo
+
+    @by_class_map = {}
+    @by_name_map = {}
+
+    class << self
+
+      def class_name_to_plugin_name(class_name)
+        String.new.tap do |plugin_name|
+          was_uppercase = false
+          extract = class_name[/[^:]+\z/].sub(/Plugin\z/, '')
+          i = 0
+          lastcase = nil
+          while i < extract.length
+            c = extract[i]
+            if UnicodeUtils.uppercase_char? c
+              if lastcase != :upper
+                if i > 0 && plugin_name[-1] != "_"
+                  plugin_name << "_"
+                end
+                lastcase = :upper
+              end
+              plugin_name << UnicodeUtils.downcase(c, nil)
+            elsif UnicodeUtils.lowercase_char? c
+              if lastcase == :upper &&
+                   (plugin_name.length > 1 && plugin_name[-2] != "_")
+                plugin_name.insert(-2, "_")
+              end
+              lastcase = :lower
+              plugin_name << c
+            else
+              lastcase = nil
+              plugin_name << c
+            end
+            i = i + 1
+          end
+        end
+      end
+
+      def register(plugin_class)
+        plugin_name = class_name_to_plugin_name(plugin_class.name)
+        unless plugin_name =~ /\A\p{Alpha}(\p{Alpha}|\p{Digit}|_)*\z/
+          raise "invalid plugin name #{plugin_name}"
+        end
+        pi = PluginInfo.new(plugin_name, plugin_class)
+        @by_class_map[plugin_class] = pi
+        @by_name_map[plugin_name] = pi
+      end
+
+      def [](class_or_name)
+        @by_class_map[class_or_name] || @by_name_map[class_or_name]
+      end
+
+    end
+
+    attr_reader :plugin_class
+    attr_reader :plugin_name
+    # Enumerable of VariableInfo instances.
+    attr_reader :variables
+    # Map of name/CommandInfo instances.
+    attr_reader :commands
+
+    def initialize(plugin_name, plugin_class)
+      @plugin_class = plugin_class
+      @plugin_name = plugin_name
+      @variables = []
+      @commands = {}
+    end
+
+    def register_command(ci)
+      raise "command #{ci.name} already registered" if @commands[ci]
+      @commands[ci.name] = ci
+    end
+
+    def register_variable(variable_info)
+      @variables << variable_info
+    end
+
+  end
+
+  module PluginClass
+
+    def plugin_info
+      PluginInfo[self]
+    end
+
+    def var(doc_line, opts = {})
+      opts[:doc_line] = doc_line
+      Decorate.decorate { |klass, method_name|
+        unless opts[:name] || opts[:prefix]
+          if method_name =~ /\Alookup_prefix_(.+)\z/
+            opts[:prefix] = $1
+          elsif method_name =~ /\Alookup_(.+)\z/
+            opts[:name] = $1
+          end
+        end
+        opts[:lookup_message] = method_name
+        opts[:plugin] = plugin_info
+        plugin_info.register_variable VariableInfo.new(opts)
+      }
+    end
+
+    def cmd(doc_line, opts = {})
+      opts[:doc_line] = doc_line
+      Decorate.decorate { |klass, method_name|
+        if !opts[:name] && method_name =~ /\Aexecute_(.+)\z/
+          opts[:name] = $1
+        end
+        opts[:execute_message] = method_name
+        opts[:plugin] = plugin_info
+        plugin_info.register_command CommandInfo.new(opts)
+      }
+    end
+
+  end
+
+  class PluginVariablesObject < BasicObject
+
+    def initialize(plugin)
+      @plugin = plugin
+    end
+
+    def method_missing(msg, *args)
+      unless args.empty?
+        ::Kernel.raise ShellUserError,
+          "expected plugin variable lookup: #{msg}"
+      end
+      varname = msg.to_s
+      @plugin.plugin_info.variables.each { |vi|
+        begin
+          if vi.name && vi.name == varname
+            return @plugin.send vi.lookup_message
+          end
+          if vi.prefix && varname.start_with?(vi.prefix) &&
+              varname.length > vi.prefix.length
+            return @plugin.send vi.lookup_message, varname[vi.prefix.length]
+          end
+        rescue Plugin::VarNotSet => e
+          e.var = vi
+          ::Kernel.raise e
+        end
+      }
+      ::Kernel.raise ShellUserError,
+        "no variable #{varname} in plugin #{@plugin.plugin_name}"
+    end
+
+  end
+
+  class Plugin
+
+    include PluginUtils
+
+    def self.inherited(klass)
+      klass.extend PluginClass
+      PluginInfo.register(klass)
+    end
+
+    # Do not override this method, override plugin_initialization if you
+    # need custom initialization logic.
+    def initialize(shell)
+      @_couch_shell_shell = shell
+    end
+
+    def shell
+      @_couch_shell_shell
+    end
+
+    def plugin_info
+      self.class.plugin_info
+    end
+
+    def plugin_name
+      plugin_info.plugin_name
+    end
+
+    # Called by the shell after it instantiates the plugin. The shell
+    # attribute will be already set.
+    #
+    # Override this method if your plugin needs custom initialization
+    # logic or to alter the shell behaviour beyond adding variables and
+    # commands. The default implementation does nothing.
+    def plugin_initialization
+    end
+
+    def variables_object
+      PluginVariablesObject.new(self)
+    end
+
+  end
+
+end