svnx 2.0.6 → 2.1.0

data/lib/svnx/base/command.rb

@@ -2,68 +2,75 @@
 # -*- ruby -*-
 
 require 'logue/loggable'
-require 'system/command/caching'
+require 'cmdline/caching'
 require 'svnx/base/cmdline'
+require 'svnx/util/classutil'
+require 'svnx/base/command_factory'
 
-class Svnx::Base::Command
-  include Logue::Loggable
-  
-  class << self
-    def caching
-      define_method :caching? do
-        true
+module Svnx::Base
+  class Command
+    include Logue::Loggable
+    
+    class << self
+      def caching
+        define_method :caching? do
+          true
+        end
       end
-    end
 
-    def noncaching
-      define_method :caching? do
-        false
+      def noncaching
+        define_method :caching? do
+          false
+        end
       end
     end
-  end
-
-  attr_reader :output
-  attr_reader :error
-  attr_reader :status
-  
-  def initialize options, cls: Svnx::Base::CommandLine, exec: nil, xml: false, caching: caching?
-    melements = module_elements
-    modl = find_module melements    
-    opts = modl::Options.new options
-    cmdargs = opts.to_args
-    subcommand = melements[-1].downcase
-    
-    @cmdline = exec || cls.new(subcommand: subcommand, xml: xml, caching: caching, args: cmdargs)
-    
-    @output = @cmdline.execute
-    @error = @cmdline.error
-    @status = @cmdline.status
-  end
 
-  def module_elements
-    mods = self.class.name.split "::"
-    mods[0 .. -2]
-  end
+    attr_reader :output
+    attr_reader :error
+    attr_reader :status
 
-  def find_module elements = module_elements
-    mod = elements * "::"
-    Kernel.const_get mod
+    attr_reader :options
+    
+    def initialize options, cls: nil, optcls: nil, exec: nil, xml: false, caching: caching?
+      factory = CommandFactory.new
+      params = factory.create self.class, cmdlinecls: cls, optcls: optcls
+      
+      optcls ||= params[:options_class]
+      
+      @options = optcls.new options
+      cmdargs = @options.to_args
+      subcommand = params[:subcommand]
+      
+      cls ||= params[:command_line_class]
+      
+      @cmdline = exec || cls.new(subcommand: subcommand, xml: xml, caching: caching, args: cmdargs)
+      debug "@cmdline: #{@cmdline}"
+      
+      @output = @cmdline.execute
+      debug "@output: #{@output}"
+      
+      @error = @cmdline.error
+      debug "@error: #{@error}"
+      
+      @status = @cmdline.status
+      debug "@status: #{@status}"
+    end
   end
-end
 
-class Svnx::Base::EntriesCommand < Svnx::Base::Command
-  attr_reader :entries
-  
-  def initialize options, cls: Svnx::Base::CommandLine, exec: nil, caching: caching?, xml: true, entries_class: nil
-    super options, cls: cls, exec: exec, xml: xml, caching: caching
+  class EntriesCommand < Command
+    attr_reader :entries
     
-    if not @output.empty?
-      entries_class ||= begin
-                          modl = find_module
-                          modl::Entries
-                        end
+    def initialize options, cls: CommandLine, exec: nil, caching: caching?, xml: true, entries_class: nil
+      super options, cls: cls, exec: exec, xml: xml, caching: caching
       
-      @entries = entries_class.new lines: @output
+      if not @output.empty?
+        entries_class ||= begin
+                            modl = ClassUtil::Util.find_module self.class
+                            modl::Entries
+                          end
+        
+        @entries = entries_class.new lines: @output
+      end
     end
   end
 end

data/lib/svnx/base/command_factory.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'svnx/base/cmdline'
+require 'svnx/util/classutil'
+
+module Svnx::Base
+  class CommandFactory
+    include Logue::Loggable
+    
+    def create cmdcls, cmdlinecls: nil, optcls: nil
+      melements = ClassUtil::Util.module_elements cmdcls
+      
+      optcls ||= begin
+                   modl = ClassUtil::Util.find_module cmdcls
+                   modl::Options
+                 end
+
+      cmdlinecls ||= CommandLine
+
+      { options_class: optcls, subcommand: melements[-1].downcase, command_line_class: cmdlinecls }
+    end
+  end
+end

data/lib/svnx/base/entries.rb

@@ -12,58 +12,60 @@ end
 # this is a parse/process on-demand list of entries, acting like an
 # Enumerable.
 
-class Svnx::Base::Entries
-  include Logue::Loggable, Enumerable
+module Svnx::Base
+  class Entries
+    include Logue::Loggable, Enumerable
 
-  attr_reader :size
+    attr_reader :size
 
-  def initialize xmllines: nil, lines: nil
-    # it's a hash, but indexed with integers, for non-sequential access:
-    @entries = Hash.new
+    def initialize xmllines: nil, lines: nil
+      # it's a hash, but indexed with integers, for non-sequential access:
+      @entries = Hash.new
 
-    lines ||= xmllines
+      lines ||= xmllines
 
-    if lines.kind_of? Array
-      lines = lines.join ''
-    end
-
-    doc = REXML::Document.new lines
-    
-    @elements = get_elements doc
-    @size = @elements.size
-  end
+      if lines.kind_of? Array
+        lines = lines.join ''
+      end
 
-  def get_elements doc
-    raise "get_elements must be implemented for: #{self.class}"
-  end
+      doc = REXML::Document.new lines
+      
+      @elements = get_elements doc
+      @size = @elements.size
+    end
 
-  def create_entry xmlelement
-    raise "create_entry must be implemented for: #{self.class}"
-  end
+    def get_elements doc
+      raise "get_elements must be implemented for: #{self.class}"
+    end
 
-  # this doesn't handle negative indices
-  def [] idx
-    if entry = @entries[idx]
-      return entry
+    def create_entry xmlelement
+      raise "create_entry must be implemented for: #{self.class}"
     end
-    if idx < 0 || idx >= size
-      raise "error: index #{idx} is not in range(0 .. #{size})"
+
+    # this doesn't handle negative indices
+    def [] idx
+      if entry = @entries[idx]
+        return entry
+      end
+      if idx < 0 || idx >= size
+        raise "error: index #{idx} is not in range(0 .. #{size})"
+      end
+      @entries[idx] = create_entry @elements[idx + 1]
     end
-    @entries[idx] = create_entry @elements[idx + 1]
-  end
 
-  def each(&blk)
-    # all elements must be processed before each can run:
-    if @elements
-      # a little confusing here: REXML does each_with_index with idx
-      # zero-based, but elements[0] is invalid.
-      @elements.each_with_index do |element, idx|
-        @entries[idx] ||= create_entry(element)
+    def each(&blk)
+      # all elements must be processed before each can run:
+      if @elements
+        # a little confusing here: REXML does each_with_index with idx
+        # zero-based, but elements[0] is invalid.
+        @elements.each_with_index do |element, idx|
+          @entries[idx] ||= create_entry(element)
+        end
+
+        @elements = nil
       end
 
-      @elements = nil
+      @entries.keys.sort.collect { |idx| @entries[idx] }.each(&blk)
     end
-
-    @entries.keys.sort.collect { |idx| @entries[idx] }.each(&blk)
   end
 end

data/lib/svnx/base/entry.rb

@@ -9,62 +9,64 @@ module Svnx
   end
 end
 
-class Svnx::Base::Entry
-  include Logue::Loggable
+module Svnx::Base
+  class Entry
+    include Logue::Loggable
 
-  def initialize xmllines: nil, xmlelement: nil
-    if xmllines
-      if xmllines.kind_of? Array
-        xmllines = xmllines.join ''
+    def initialize xmllines: nil, xmlelement: nil
+      if xmllines
+        if xmllines.kind_of? Array
+          xmllines = xmllines.join ''
+        end
+        doc = REXML::Document.new xmllines
+        set_from_xml doc
+      elsif xmlelement
+        set_from_element xmlelement
+      else
+        raise "must be initialized with xmllines (received: #{xmllines.inspect}) or xmlelement (received: #{xmlelement.inspect})"
       end
-      doc = REXML::Document.new xmllines
-      set_from_xml doc
-    elsif xmlelement
-      set_from_element xmlelement
-    else
-      raise "must be initialized with xmllines (received: #{xmllines.inspect}) or xmlelement (received: #{xmlelement.inspect})"
     end
-  end
 
-  def set_from_xml xmldoc
-    raise "must be implemented"
-  end
+    def set_from_xml xmldoc
+      raise "must be implemented"
+    end
 
-  def set_from_element elmt
-    raise "must be implemented"
-  end
+    def set_from_element elmt
+      raise "must be implemented"
+    end
 
-  def set_attr_var xmlelement, varname
-    set_var varname, attribute_value(xmlelement, varname)
-  end
+    def set_attr_var xmlelement, varname
+      set_var varname, attribute_value(xmlelement, varname)
+    end
 
-  def set_attr_vars xmlelement, *varnames
-    varnames.each do |varname|
-      set_attr_var xmlelement, varname
+    def set_attr_vars xmlelement, *varnames
+      varnames.each do |varname|
+        set_attr_var xmlelement, varname
+      end
     end
-  end
 
-  def set_elmt_var xmlelement, varname
-    set_var varname, element_text(xmlelement, varname)
-  end
+    def set_elmt_var xmlelement, varname
+      set_var varname, element_text(xmlelement, varname)
+    end
 
-  def set_elmt_vars xmlelement, *varnames
-    varnames.each do |varname|
-      set_elmt_var xmlelement, varname
+    def set_elmt_vars xmlelement, *varnames
+      varnames.each do |varname|
+        set_elmt_var xmlelement, varname
+      end
     end
-  end
 
-  def set_var varname, value
-    instance_variable_set '@' + varname.to_s, value
-  end
+    def set_var varname, value
+      instance_variable_set '@' + varname.to_s, value
+    end
 
-  def attribute_value xmlelement, attrname
-    xmlelement.attributes[attrname.to_s]
-  end
+    def attribute_value xmlelement, attrname
+      xmlelement.attributes[attrname.to_s]
+    end
 
-  def element_text xmlelement, elmtname
-    elmt = xmlelement.elements[elmtname.to_s]
-    # some elements don't have text:
-    (elmt && elmt.text) || ""
-  end  
+    def element_text xmlelement, elmtname
+      elmt = xmlelement.elements[elmtname.to_s]
+      # some elements don't have text:
+      (elmt && elmt.text) || ""
+    end  
+  end
 end

data/lib/svnx/base/env.rb

@@ -4,23 +4,22 @@
 require 'singleton'
 
 module Svnx
-end
-
-class Svnx::Env
-  include Singleton
+  class Env
+    include Singleton
 
-  # the directory into which to put cached files
-  attr_accessor :cache_dir_name
+    # the directory into which to put cached files
+    attr_accessor :cache_dir_name
 
-  # the environment variable, naming the cache directory
-  attr_accessor :cache_dir_env_varname
-  
-  def initialize
-    @cache_dir_name = "/tmp/svnx"
-    @cache_dir_env_varname = "SVNX_TMP_DIR"
-  end
+    # the environment variable, naming the cache directory
+    attr_accessor :cache_dir_env_varname
+    
+    def initialize
+      @cache_dir_name = "/tmp/svnx"
+      @cache_dir_env_varname = "SVNX_TMP_DIR"
+    end
 
-  def cache_dir
-    ENV[@cache_dir_env_varname] || @cache_dir_name
+    def cache_dir
+      ENV[@cache_dir_env_varname] || @cache_dir_name
+    end
   end
 end

data/lib/svnx/base/options.rb

@@ -8,16 +8,28 @@ module Svnx
   end
 end
 
-class Svnx::Base::Options
-  include Svnx::ObjectUtil
-  
-  def to_args
-    Array.new.tap do |args|
-      options_to_args.each do |opt|
-        optname = opt[0]
-        values = opt[1]
-        if send optname
-          args.concat [ values ].flatten
+module Svnx::Base
+  class Options
+    include Svnx::ObjectUtil
+
+    def check args, valid = Array.new
+      invalid = args.keys.reject do |field|
+        valid.include? field
+      end
+
+      unless invalid.empty?
+        raise "invalid fields for #{self.class}: #{invalid.join(' ')}"
+      end
+    end
+    
+    def to_args
+      Array.new.tap do |args|
+        options_to_args.each do |opt|
+          optname = opt[0]
+          values = opt[1]
+          if send optname
+            args.concat [ values ].flatten
+          end
         end
       end
     end

data/lib/svnx/cat/command.rb

@@ -4,6 +4,8 @@
 require 'svnx/cat/options'
 require 'svnx/base/command'
 
-class Svnx::Cat::Command < Svnx::Base::Command
-  caching
+module Svnx::Cat
+  class Command < Svnx::Base::Command
+    caching
+  end
 end