svn_wc 0.0.2 → 0.0.3

data/ChangeLog

@@ -1,2 +1,13 @@
-version 0.0.1 
-* initial checkin
+version 0.0.3
+* add all possible arg options to 'add' (from client.rb)
+* enable propset (ignore) only
+* 'exposed the abstraction' introduced Delegation if we don't define a method pass it on to the ruby bindings.
+* (code refactoring/cleanup)
+ 
+version 0.0.2
+* changes for backwards compatibility to subversion-ruby bindings 1.4.2 
+  (tests failed for (Centos 5.4))
+* minor Readme update
+
+version 0.0.1
+* initial release

data/README.rdoc

@@ -5,7 +5,7 @@ Operate on the working copy of a (remote) Subversion (svn) repository.
 
 == VERSION:
 
-Version 0.0.2
+Version 0.0.3
 
 
 == SYNOPSIS:
@@ -265,7 +265,7 @@ See the ChangeLog file for details.
 Copyright 2009 David Wright (david_v_wright@yahoo.com), all rights reserved.
 
 
-SvnWc::RepoAccess 0.0.2 is released under the LGPL license.
+SvnWc::RepoAccess 0.0.3 is released under the LGPL license.
 
 
 == AUTHOR:

data/lib/svn_wc.rb

@@ -44,6 +44,8 @@ require 'svn/error'
 # * add
 # * revert
 # * delete
+# * log info
+# * propset (ignore only)
 # * svn+ssh is our primary connection use case, however can connect to, and operate on a (local) file:/// URI as well
 #
 # Is built on top of the SVN (SWIG) (Subversion) Ruby Bindings and requires that they be installed. 
@@ -99,41 +101,38 @@ require 'svn/error'
 # Author::      David V. Wright <david_v_wright@yahoo.com>
 # License::     LGPL License
 #
-#
 #--
 # TODO make sure args are what is expected for all methods
-# TODO props
+# TODO propset/propget, 
 #     look into:
 #     #wc_status = infos.assoc(@wc_path).last
 #     #assert(wc_status.text_normal?)
 #     #assert(wc_status.entry.dir?)
 #     #assert(wc_status.entry.normal?)
 #     #ctx.prop_set(Svn::Core::PROP_IGNORE, file2, dir_path)
+#
+# currently, propset IGNORE is enabled
+#
+# TODO/Think About Delegation: (do we want to do this?)
+#      Inherit from or mixin the svn bindings directly, so method calls
+#      not defined here explicitly can be run againt the bindings directly
+#      (i.e. begin ; send(svn ruby binding method signature) ; rescue)
 #++
-#module Svn
-#  class Error
-#    #WC_NOT_DIRECTORY  # 1.4.2
-#    class WcNotDirectory # 1.6.6
-#      raise StandardError.new(
-#    #WC_NOT_DIRECTORY  # 1.4.2
-#    end
-#    class AuthnNoProvider
-#      raise StandardError
-#    end
-#  end
-#end
-
 module SvnWc
 
   # (general) exception class raised on all errors 
   class RepoAccessError < RuntimeError ; end
 
+  #
+  # class that provides API to (common) svn operations (working copy of a repo)
+  # also exposes the svn ruby bindings directly
+  #
+  # It aims to provide (simple) client CLI type behavior,
+  # for working directory repository management.  in an API
+  #
   class RepoAccess
 
-    VERSION = '0.0.2'
-
-    DEFAULT_CONF_FILE  = File.join(File.dirname(File.dirname(\
-                               File.expand_path(__FILE__))), 'svn_wc_conf.yaml')
+    VERSION = '0.0.3'
 
     # initialization
     # three optional parameters
@@ -143,13 +142,24 @@ module SvnWc
     # 3. Force. Overwrite anything that may be preventing a checkout
 
     def initialize(conf=nil, checkout=false, force=false)
-      set_conf(conf)
+      set_conf(conf) if conf
       do_checkout(force) if checkout == true
 
       # instance var of out open repo session
       @ctx = svn_session
     end
 
+    #
+    # 'expose the abstraction'
+    # introduce Delegation, if we don't define the method pass it on to the
+    # ruby bindings. 
+    #
+    # (yup, this is probably asking for trouble)
+    #
+    def method_missing(sym, *args, &block)
+      @ctx.send sym, *args, &block
+    end
+
     #--
     # TODO revist these
     #++
@@ -157,19 +167,9 @@ module SvnWc
                   :svn_repo_working_copy, :cur_file
     attr_reader :ctx, :repos
 
-    def do_checkout(force=false)
-      if @svn_repo_working_copy.nil? 
-        raise RepoAccessError, 'conf file not loaded! - Fatal Error' 
-      end
-      ## do checkout if not exists at specified local path
-      if File.directory? @svn_repo_working_copy and not force
-        raise RepoAccessError, 'target local directory  ' << \
-        "[#{@svn_repo_working_copy}] exists, please remove" << \
-        'or specify another directory'
-      end
-      checkout
-    end
-
+    #
+    # set config file with abs path
+    #
     def set_conf(conf)
       begin
       conf = load_conf(conf)
@@ -184,6 +184,35 @@ module SvnWc
       end
     end
 
+
+    def do_checkout(force=false)
+      if @svn_repo_working_copy.nil? 
+        raise RepoAccessError, 'conf file not loaded! - Fatal Error' 
+      end
+      ## do checkout if not exists at specified local path
+
+      if force
+        begin
+          #FileUtils.rm_rf @svn_repo_working_copy
+          FileUtils.mkdir_p @svn_repo_working_copy, :force => true
+        rescue
+        end
+      else
+        if File.directory? @svn_repo_working_copy
+          raise RepoAccessError, 'target local directory  ' << \
+          "[#{@svn_repo_working_copy}] exists, please remove" << \
+          'or specify another directory'
+        end
+        begin
+          FileUtils.mkdir_p @svn_repo_working_copy
+        rescue Errno::EACCES => err
+          raise RepoAccessError, err.message
+        end
+      end
+
+      checkout
+    end
+
     # checkout
     #
     # create a local working copy of a remote svn repo (creates dir if not
@@ -192,23 +221,15 @@ module SvnWc
     #
 
     def checkout
-      if not File.directory? @svn_repo_working_copy
-          begin
-            FileUtils.mkdir_p @svn_repo_working_copy
-          rescue Errno::EACCES => e
-            raise RepoAccessError, e.message
-          end
-      end
-
       begin
-        svn_session() { |ctx| 
-           ctx.checkout(@svn_repo_master, @svn_repo_working_copy) 
-        }
+        svn_session() do |ctx|
+           ctx.checkout(@svn_repo_master, @svn_repo_working_copy)
+        end
       #rescue Svn::Error::RaLocalReposOpenFailed,
       #       Svn::Error::FsAlreadyExists,
-      #       Exception => e
-      rescue Exception => e
-        raise RepoAccessError, e.message
+      #rescue Errno::EACCES => e
+      rescue Exception => err
+        raise RepoAccessError, err.message
       end
     end
     alias_method :co, :checkout
@@ -216,8 +237,7 @@ module SvnWc
     #
     # load conf file (yaml)
     #
-    # takes a path to a yaml config file, loads values. uses default if
-    # nothing passed
+    # takes a path to a yaml config file, loads values.
     # raises RepoAccessError if something goes wrong
     #
     # private
@@ -226,7 +246,7 @@ module SvnWc
     def load_conf(cnf) # :nodoc:
 
       if cnf.nil? or cnf.empty? 
-        cnf = IO.read(DEFAULT_CONF_FILE)
+        raise RepoAccessError, 'No config file provided!'
       elsif cnf and cnf.class == String and File.exists? cnf
         cnf = IO.read(cnf)
       end
@@ -247,23 +267,29 @@ module SvnWc
     #
     # raises RepoAccessError if something goes wrong
     #
+    #--
+    # "svn/client.rb"  Svn::Client
+    #  def add(path, recurse=true, force=false, no_ignore=false)
+    #    Client.add3(path, recurse, force, no_ignore, self)
+    #  end
+    #++
 
-    def add(files=[])
+    def add(files=[], recurse=true, force=false, no_ignore=false)
 
       # TODO make sure args are what is expected for all methods
       raise ArgumentError, 'files is empty' unless files
 
       svn_session() do |svn|
         begin
-          files.each { |ef|
-             svn.add(ef, true)
-          }
+          files.each do |ef|
+             svn.add(ef, recurse, force, no_ignore)
+          end
         #rescue Svn::Error::ENTRY_EXISTS, 
         #       Svn::Error::AuthnNoProvider,
         #       #Svn::Error::WcNotDirectory,
         #       Svn::Error::SvnError => e
-        rescue Exception => e
-          raise RepoAccessError, "Add Failed: #{e.message}"
+        rescue Exception => excp
+          raise RepoAccessError, "Add Failed: #{excp.message}"
         end
       end
     end
@@ -277,7 +303,7 @@ module SvnWc
     # raises RepoAccessError if something goes wrong
     #
 
-    def delete(files=[], recurs=nil)
+    def delete(files=[], recurs=false)
       svn_session() do |svn|
         begin
           svn.delete(files)
@@ -285,8 +311,8 @@ module SvnWc
         #       #Svn::Error::WcNotDirectory,
         #       Svn::Error::ClientModified,
         #       Svn::Error::SvnError => e
-        rescue Exception => e
-          raise RepoAccessError, "Delete Failed: #{e.message}"
+        rescue Exception => err
+          raise RepoAccessError, "Delete Failed: #{err.message}"
         end
       end
     end
@@ -316,8 +342,8 @@ module SvnWc
         #       Svn::Error::IllegalTarget,
         #       #Svn::Error::EntryNotFound => e
         #       Exception => e
-        rescue Exception => e
-          raise RepoAccessError, "Commit Failed: #{e.message}"
+        rescue Exception => err
+          raise RepoAccessError, "Commit Failed: #{err.message}"
         end
       end
       rev
@@ -336,33 +362,17 @@ module SvnWc
     # raises RepoAccessError if something goes wrong
     #
     # alias up
-    #--
-    # XXX refactor this (too long)
-    #++
     def update(paths=[])
 
       if paths.empty? then paths = self.svn_repo_working_copy end
       #XXX update is a bummer, just returns the rev num, not affected files
       #(svn command line up, also returns altered/new files - mimic that)
-      # hence our inplace hack
+      # hence our inplace hack (_pre/_post update_entries)
       #
       # unfortunetly, we cant use 'Repos',  only works on local filesystem repo
       # (NOT remote)
       #p Svn::Repos.open(@svn_repo_master) # Svn::Repos.open('/tmp/svnrepo')
-
-      pre_up_entries = Array.new
-      modified_entries = Array.new
-      list_entries.each { |ent|
-        ##puts "#{ent[:status]} | #{ent[:repo_rev]} | #{ent[:entry_name]}"
-        pre_up_entries.push ent[:entry_name]
-        ## how does it handle deletes?
-        #if info()[:rev] != ent[:repo_rev]
-        #  puts "changed file: #{File.join(paths, ent[:entry_name])} | #{ent[:status]} "
-        #end
-        if ent[:status] == 'M'
-          modified_entries.push "#{ent[:status]}\t#{ent[:entry_name]}"
-        end
-      }
+      _pre_update_entries
 
       rev = String.new
       svn_session() do |svn|
@@ -374,30 +384,60 @@ module SvnWc
         #       #Svn::Error::WcNotDirectory,
         #       #Svn::Error::EntryNotFound => e
         #       Exception => e
-        rescue Exception => e
-          raise RepoAccessError, "Update Failed: #{e.message}"
+        rescue Exception => err
+          raise RepoAccessError, "Update Failed: #{err.message}"
         end
       end
 
+      _post_update_entries
+
+      return rev, @modified_entries
+
+    end
+    alias_method :up, :update
+
+    #
+    # get list of entries before doing an update
+    #
+    def _pre_update_entries #:nodoc:
+      @pre_up_entries = Array.new
+      @modified_entries = Array.new
+      list_entries.each do |ent|
+        ##puts "#{ent[:status]} | #{ent[:repo_rev]} | #{ent[:entry_name]}"
+        e_name = ent[:entry_name]
+        stat = ent[:status]
+        @pre_up_entries.push e_name
+        ## how does it handle deletes?
+        #if info()[:rev] != ent[:repo_rev]
+        #  puts "changed file: #{File.join(paths, ent[:entry_name])} | #{ent[:status]} "
+        #end
+        if stat == 'M' then @modified_entries.push "#{stat}\t#{e_name}" end
+      end
+    end
+    private :_pre_update_entries
+    
+    #
+    # get list of entries after doing an update
+    #
+    def _post_update_entries #:nodoc:
       post_up_entries = Array.new
       list_entries.each { |ent| post_up_entries.push ent[:entry_name] }
 
-      added = post_up_entries - pre_up_entries
-      removed = pre_up_entries - post_up_entries
+      added   = post_up_entries - @pre_up_entries
+      removed = @pre_up_entries - post_up_entries
 
-      if added.length > 0 ;
-          added.each {|e| modified_entries.push "A\t#{e}" }
+      if added.length > 0
+          added.each {|e_add| @modified_entries.push "A\t#{e_add}" }
       end
 
       if  removed.length > 0
-          removed.each {|e| modified_entries.push "D\t#{e}" }
+          removed.each {|e_rm| @modified_entries.push "D\t#{e_rm}" }
       end
 
-      return rev, modified_entries
-
     end
-    alias_method :up, :update
-     
+    private :_post_update_entries
+
+ 
     #
     # get status on dir/file path.
     #
@@ -469,21 +509,31 @@ module SvnWc
         end
       end
    
+      _file_list infos
+
+    end
+    private :do_status
+
+
+    #
+    # create and return list of anon hashes
+    # set hashes to contain :path and :status
+    #
+    def _file_list(info_list) # :nodoc:
       files = Array.new
-      infos.each {|r|
+      info_list.each {|r|
         #p r.inspect
         # file is not modified, we don't want to see it (this is 'status')
-        next if ' ' == status_codes(r[1].text_status)
+        txt_stat = r[1].text_status
+        next if ' ' == status_codes(txt_stat)
         f_rec = Hash.new
         f_rec[:path] = r[0]
-        f_rec[:status] = status_codes(r[1].text_status)
+        f_rec[:status] = status_codes(txt_stat)
         files.push f_rec
       }
-
       files
-
     end
-    private :do_status
+    private :_file_list
 
     #
     # list (ls)
@@ -562,24 +612,26 @@ module SvnWc
     #
 
     def list_entries(dir=self.svn_repo_working_copy, file=nil, verbose=false)
-      @entry_list = []
-      show = true
+      @entry_list, @show, @verbose = [], true, verbose
       Svn::Wc::AdmAccess.open(nil, dir, false, 5) do |adm|
+        @adm = adm
         if file.nil?
           #also see walk_entries (in svn bindings) has callback
           adm.read_entries.keys.sort.each { |ef|
             next unless ef.length >= 1 # why this check and not file.exists?
             f_path = File.join(dir, ef)
             if File.file? f_path
-              _collect_get_entry_info(f_path, adm, show, verbose)
+              _collect_get_entry_info(f_path)
             elsif File.directory? f_path
-              _walk_entries(f_path, adm, show, verbose)
+              _walk_entries(f_path)
             end
           }
         else
-          _collect_get_entry_info(file, adm, show, verbose)
+          _collect_get_entry_info(file)
         end
       end
+      #XXX do we want nil or empty on no entries, choosing empty for now
+      #@entry_list unless @entry_list.empty?
       @entry_list
     end
 
@@ -589,11 +641,11 @@ module SvnWc
     # given a dir, iterate each entry, getting detailed file entry info
     #
 
-    def _walk_entries(f_path, adm, show, verbose)#:nodoc:
+    def _walk_entries(f_path) #:nodoc:
       Dir.entries(f_path).each do |de|
         next if de == '..' or de == '.' or de == '.svn'
         fp_path  = File.join(f_path, de)
-        _collect_get_entry_info(fp_path, adm, show, verbose)
+        _collect_get_entry_info(fp_path)
       end
     end
     private :_walk_entries
@@ -608,10 +660,10 @@ module SvnWc
     # requested
     #
 
-    def _collect_get_entry_info(abs_path_file, adm, show, verbose=false)#:nodoc:
-      @status_info = {}
-      _get_entry_info(abs_path_file, adm, show, verbose)
-      @entry_list.push @status_info
+    def _collect_get_entry_info(abs_path_file) #:nodoc:
+      @status_info = Hash.new
+      _get_entry_info(abs_path_file)
+      @entry_list.push @status_info unless @status_info.empty?
     end
     private :_collect_get_entry_info
 
@@ -628,63 +680,65 @@ module SvnWc
     # TODO - document all the params available from this command
     #++
 
-    def _get_entry_info(abs_path_file, adm, show, verbose=false) # :nodoc:
+    def _get_entry_info(abs_path_file) # :nodoc:
       wc = self.svn_repo_working_copy
       entry_repo_location = abs_path_file[(wc.length+1)..-1]
 
-      entry = Svn::Wc::Entry.new(abs_path_file, adm, show)
-      @status_info[:entry_name] = entry_repo_location
+      entry = Svn::Wc::Entry.new(abs_path_file, @adm, @show)
+      #@status_info[:entry_name] = entry_repo_location
 
-      status = adm.status(abs_path_file)
+      status = @adm.status(abs_path_file)
       return if status.entry.nil?
 
-      @status_info[:status]   = status_codes(status.text_status)
-      @status_info[:repo_rev] = status.entry.revision
-      @status_info[:kind]     = status.entry.kind
+      @status_info[:entry_name] = entry_repo_location
+      @status_info[:status]     = status_codes(status.text_status)
+      @status_info[:repo_rev]   = status.entry.revision
+      @status_info[:kind]       = status.entry.kind
 
       if @status_info[:kind] == 2
         # remove the repo root abs path, give dirs relative to repo root
         @status_info[:dir_name] = entry_repo_location
         # XXX hmmm, this is a little like a goto, revisit this
-        _walk_entries(abs_path_file, adm, show, verbose)
+        _walk_entries(abs_path_file)
       end
-      return if verbose == false
+      return if @verbose == false
       # only on demand ; i.e. verbose = true
-      @status_info[:lock_creation_date] = status.entry.lock_creation_date
-      @status_info[:entry_conflict] = entry.conflicted?(abs_path_file)
-      @status_info[:present_props]  = status.entry.present_props
-      @status_info[:has_prop_mods]  = status.entry.has_prop_mods
-      @status_info[:copyfrom_url]   = status.entry.copyfrom_url
-      @status_info[:conflict_old]   = status.entry.conflict_old
-      @status_info[:conflict_new]   = status.entry.conflict_new
-      @status_info[:lock_comment]   = status.entry.lock_comment
-      @status_info[:copyfrom_rev]   = status.entry.copyfrom_rev
-      @status_info[:working_size]   = status.entry.working_size
-      @status_info[:conflict_wrk]   = status.entry.conflict_wrk
-      @status_info[:cmt_author]     = status.entry.cmt_author
-      @status_info[:changelist]     = status.entry.changelist
-      @status_info[:lock_token]     = status.entry.lock_token
-      @status_info[:keep_local]     = status.entry.keep_local
-      @status_info[:lock_owner]     = status.entry.lock_owner
-      @status_info[:prop_time]      = status.entry.prop_time
-      @status_info[:has_props]      = status.entry.has_props
-      @status_info[:schedule]       = status.entry.schedule
-      @status_info[:text_time]      = status.entry.text_time
-      @status_info[:revision]       = status.entry.revision
-      @status_info[:checksum]       = status.entry.checksum
-      @status_info[:cmt_date]       = status.entry.cmt_date
-      @status_info[:prejfile]       = status.entry.prejfile
-      @status_info[:is_file]        = status.entry.file?
-      @status_info[:normal?]        = status.entry.normal?
-      @status_info[:cmt_rev]        = status.entry.cmt_rev
-      @status_info[:deleted]        = status.entry.deleted
-      @status_info[:absent]         = status.entry.absent
-      @status_info[:is_add]         = status.entry.add?
-      @status_info[:is_dir]         = status.entry.dir?
-      @status_info[:repos]          = status.entry.repos
-      @status_info[:depth]          = status.entry.depth
-      @status_info[:uuid]           = status.entry.uuid
-      @status_info[:url]            = status.entry.url
+      s = status.entry
+      @status_info[:entry_conflict]     = entry.conflicted?(abs_path_file)
+      @status_info[:lock_creation_date] = s.lock_creation_date
+      @status_info[:present_props]  = s.present_props
+      @status_info[:has_prop_mods]  = s.has_prop_mods
+      @status_info[:copyfrom_url]   = s.copyfrom_url
+      @status_info[:conflict_old]   = s.conflict_old
+      @status_info[:conflict_new]   = s.conflict_new
+      @status_info[:lock_comment]   = s.lock_comment
+      @status_info[:copyfrom_rev]   = s.copyfrom_rev
+      @status_info[:working_size]   = s.working_size
+      @status_info[:conflict_wrk]   = s.conflict_wrk
+      @status_info[:cmt_author]     = s.cmt_author
+      @status_info[:changelist]     = s.changelist
+      @status_info[:lock_token]     = s.lock_token
+      @status_info[:keep_local]     = s.keep_local
+      @status_info[:lock_owner]     = s.lock_owner
+      @status_info[:prop_time]      = s.prop_time
+      @status_info[:has_props]      = s.has_props
+      @status_info[:schedule]       = s.schedule
+      @status_info[:text_time]      = s.text_time
+      @status_info[:revision]       = s.revision
+      @status_info[:checksum]       = s.checksum
+      @status_info[:cmt_date]       = s.cmt_date
+      @status_info[:prejfile]       = s.prejfile
+      @status_info[:is_file]        = s.file?
+      @status_info[:normal?]        = s.normal?
+      @status_info[:cmt_rev]        = s.cmt_rev
+      @status_info[:deleted]        = s.deleted
+      @status_info[:absent]         = s.absent
+      @status_info[:is_add]         = s.add?
+      @status_info[:is_dir]         = s.dir?
+      @status_info[:repos]          = s.repos
+      @status_info[:depth]          = s.depth
+      @status_info[:uuid]           = s.uuid
+      @status_info[:url]            = s.url
     end
     private :_get_entry_info
 
@@ -701,7 +755,7 @@ module SvnWc
         wc_path = self.svn_repo_working_copy
       end
 
-      r_info = {}
+      r_info = Hash.new
       begin
         @ctx.info(wc_path) do |path, type|
           r_info[:last_changed_author] = type.last_changed_author
@@ -718,20 +772,14 @@ module SvnWc
           r_info[:conflict_new]    = type.conflict_new
           r_info[:has_wc_info]     = type.has_wc_info
           r_info[:repos_UUID]      = type.repos_UUID
-          #r_info[:changelist]      = type.changelist
-          r_info[:prop_time]       = type.prop_time
-          r_info[:text_time]       = type.text_time
           r_info[:checksum]        = type.checksum
-          r_info[:prejfile]        = type.prejfile
-          r_info[:schedule]        = type.schedule
-          r_info[:taguri]          = type.taguri
-          #r_info[:depth]           = type.depth
-          r_info[:lock]            = type.lock
-          #r_info[:size]            = type.size
-          r_info[:url]             = type.url
-          r_info[:dup]             = type.dup
-          r_info[:URL]             = type.URL
-          r_info[:rev]             = type.rev
+          r_info[:prop_time], r_info[:text_time] = type.prop_time, type.text_time
+          r_info[:prejfile],  r_info[:schedule]  = type.prejfile, type.schedule
+          r_info[:taguri], r_info[:lock] = type.taguri, type.lock
+          r_info[:rev], r_info[:dup]     = type.rev, type.dup
+          r_info[:url], r_info[:URL]     = type.url, type.URL
+          #r_info[:changelist]  = type.changelist
+          #r_info[:depth], r_info[:size] = type.depth, type.size
         end
       #rescue Svn::Error::WcNotDirectory => e
       #       #Svn::Error::RaIllegalUrl,
@@ -814,6 +862,23 @@ module SvnWc
       out_file.readlines
     end
 
+    # currently supports type='ignore' only
+    #--
+    # TODO support other propset's ; also propget
+    #++
+    def propset(type, file, dir_path)
+      raise RepoAccessError, '"ignore" is only supported propset' \
+             unless type == 'ignore'
+
+      svn_session() do |svn|
+        begin
+          svn.propset(Svn::Core::PROP_IGNORE, file, dir_path)
+        rescue Exception => e #Svn::Error::EntryNotFound => e
+          raise RepoAccessError, "Propset (Ignore) Failed: #{e.message}"
+        end
+      end
+    end
+
     # svn session set up
     #--
     # from
@@ -858,14 +923,3 @@ module SvnWc
   end
 
 end
-
-if __FILE__ == $0
-
-  svn = SvnWc::RepoAccess.new
-  p svn
-  #n = '/tmp/NEW'
-  #svn.add n
-  #svn.commit n
-
-end
-

data/test/svn_wc_test.rb

@@ -11,9 +11,6 @@
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 # Lesser General Public License for more details.
-#$LOAD_PATH.unshift '..'
-#$LOAD_PATH.unshift File.join('..', 'lib')
-#$LOAD_PATH.unshift File.join('lib')
 
 require 'yaml'
 require File.join(File.dirname(__FILE__), "..", "lib", 'svn_wc')
@@ -34,6 +31,8 @@ require 'pp'
 # svn status
 # svn delete
 # svn diff
+# propset ignore
+# log
 
 # NOTE
 # svn+ssh is our primary use case, however
@@ -409,27 +408,33 @@ class TestSvnWc < Test::Unit::TestCase
     assert_equal Array.new, svn.diff(f)
   end
 
-  ## TODO
+  ## TODO not sure if we actually want this
   #def test_add_does_recursive_nested_dirs
-  #  svn = SvnWc::RepoAccess.new(nil, true)
-
-  #  # add 1 new file in nested heirerarcy
-  #  # TODO ability to add recursive nested dirs
-  #  FileUtils.mkdir_p @conf['svn_repo_working_copy'] + "/d1/d2/d3"
-  #  nested = @conf['svn_repo_working_copy'] +
-  #                    "/d1/d2/d3/test_#{Time.now.usec.to_s}.txt"
+  #  svn = SvnWc::RepoAccess.new(YAML::dump(@conf), true, true)
+  #  repo_wc = @conf['svn_repo_working_copy']
+  #  FileUtils.mkdir_p File.join(repo_wc, 'd1','d2','d3')
+  #  nested = File.join(repo_wc, 'd1','d2','d3',"test_#{Time.now.usec.to_s}.txt")
   #  FileUtils.touch nested
+  #  # TODO ability to add recursive nested dirs
   #  svn.add nested
-
-  #  svn.status.each { |ef|
-  #    next unless ef[:entry_name].match /test_.*/
-  #    assert_equal 'A', ef[:status]
-  #    assert_equal nested, File.join(@conf['svn_repo_working_copy'], ef[:entry_name])
-  #  }
-  #  svn.revert
-  #  assert_equal 1, svn.status.length
-  #  assert_equal File.basename(@conf['svn_repo_working_copy']),
-  #                     svn.status[0][:entry_name]
+ 
+  #  ## add 1 new file in nested heirerarcy
+  #  ## TODO ability to add recursive nested dirs
+  #  #FileUtils.mkdir_p @conf['svn_repo_working_copy'] + "/d1/d2/d3"
+  #  #nested = @conf['svn_repo_working_copy'] +
+  #  #                  "/d1/d2/d3/test_#{Time.now.usec.to_s}.txt"
+  #  #FileUtils.touch nested
+  #  #svn.add nested
+
+  #  #svn.status.each { |ef|
+  #  #  next unless ef[:entry_name].match /test_.*/
+  #  #  assert_equal 'A', ef[:status]
+  #  #  assert_equal nested, File.join(@conf['svn_repo_working_copy'], ef[:entry_name])
+  #  #}
+  #  #svn.revert
+  #  #assert_equal 1, svn.status.length
+  #  #assert_equal File.basename(@conf['svn_repo_working_copy']),
+  #  #                   svn.status[0][:entry_name]
   #end
 
   def test_update_acts_on_whole_repo_by_default_knows_a_m_d
@@ -474,25 +479,20 @@ class TestSvnWc < Test::Unit::TestCase
 
   end
 
-  #def test_update_reports_collision
-  #  svn = SvnWc::RepoAccess.new(YAML::dump(@conf), true, true)
-
-  #  assert_equal '', svn.update
+  def test_add_exception_on_already_added_file
+    svn = SvnWc::RepoAccess.new(YAML::dump(@conf), true, true)
+    this_wc_rev = 0
+    assert_equal [this_wc_rev, []], svn.update
 
-  #  rev, f_name = check_out_new_working_copy_add_and_commit_new_entries
+    rev, f_name = check_out_new_working_copy_add_and_commit_new_entries
 
-  #  assert_equal " #{f_name}", svn.update
+    assert_equal [rev, ["A\t#{File.basename(f_name.to_s)}"]], svn.update
 
-  #  f = new_unique_file_at_path
-  #  modify_file_and_commit_into_another_working_repo(f)
-  #  File.open(f, 'a') {|fl| fl.write('adding text to file.')}
-  #  # XXX no update done, so this file should clash with
-  #  # what is already in the repo
-  #  start_rev = svn.commit f
-  #  #p svn.status(f)
-  #  #assert_equal 'M', svn.status(f)[0][:status]
-  #  #assert_equal start_rev, svn.info(f)[:rev] 
-  #end
+    (rev, f) = modify_file_and_commit_into_another_working_repo
+    File.open(f, 'w') {|fl| fl.write('adding text to file.')}
+    #already under version control
+    assert_raise(SvnWc::RepoAccessError) { svn.add f }
+  end
 
   def test_list_recursive
     FileUtils.rm_rf @conf['svn_repo_working_copy']
@@ -603,19 +603,125 @@ class TestSvnWc < Test::Unit::TestCase
     assert fails
   end
 
-  #def test_update
-  # svn = SvnWc::RepoAccess.new(YAML::dump(@conf), true)
-  #for this one, we will have to create another working copy, modify a file
-  # and commit from there, then to an update in this working copy
-  #end
+  def test_list_entries_verbose
+    svn = SvnWc::RepoAccess.new(YAML::dump(@conf), true, true)
 
-  #def test_update_a_locally_modified_file_raises_exception
-  #for this one, we will have to create another working copy, modify a file
-  # and commit from there, then to an update in this working copy
-  #end
+    repo_wc = @conf['svn_repo_working_copy']
+
+    dir_ent = Dir.mktmpdir('P', repo_wc)
+    file = 'file.txt'
+    file = File.join dir_ent, file
+    File.open(file, "w") {|f| f.print('contents.')}
+    file2 = new_unique_file_at_path dir_ent
+
+    svn.add dir_ent, recurse=true, force=true
+    rev = svn.commit repo_wc
+
+    entries =  svn.list_entries
+
+    assert_equal File.basename(entries[0][:entry_name]), 
+                 File.basename(file)
+    assert_equal File.basename(entries[1][:entry_name]), 
+                 File.basename(file2)
+    assert_equal entries.size, 2
+    assert_nil entries[2]
+    # verbose info from list_entries
+    #p svn.list_entries(repo_wc, file, verbose=true)
+    f_entry = File.join(File.basename(dir_ent), File.basename(file))
+    svn.list_entries(repo_wc, file, verbose=true).each do |info|
+      # bools
+      assert ! info[:absent]
+      assert ! info[:entry_conflict]
+      assert ! info[:is_add]
+      assert ! info[:is_dir]
+      assert ! info[:has_props]
+      assert ! info[:deleted]
+      assert ! info[:keep_local]
+      assert ! info[:has_prop_mods]
+      assert   info[:normal?]
+      assert   info[:is_file]
+
+      assert_nil info[:copyfrom_url]
+      assert_nil info[:conflict_old]
+      assert_nil info[:conflict_new]
+      assert_nil info[:conflict_wrk]
+      assert_nil info[:lock_comment]
+      assert_nil info[:lock_owner]
+      assert_nil info[:present_props]
+      assert_nil info[:lock_token]
+      assert_nil info[:changelist]
+      assert_nil info[:prejfile]
+
+      #assert_equal info[:cmt_author], `id`
+      assert_equal info[:revision], rev
+      assert_equal info[:repo_rev], rev
+      assert_equal info[:cmt_rev] , rev
+      #assert_equal info[:cmt_date] , rev
+      #:checksum=>"bb9c00f6fc03c2213ac1f0278853dc32", :working_size=>9,
+      assert_equal info[:working_size] , 9
+      assert_equal info[:schedule], 0
+      assert_equal info[:lock_creation_date], 0
+      assert_equal info[:copyfrom_rev], -1
+      assert_equal info[:prop_time], 0
+      assert_equal info[:kind], 1  # i.e. is file
+      assert_equal info[:depth], 3
+      assert_equal info[:status]   , ' '
+      assert_equal info[:entry_name], f_entry
+      assert_equal info[:url], "#{File.join(@conf['svn_repo_master'],f_entry)}"
+      assert_equal info[:repos], @conf['svn_repo_master']
+    end
+
+  end
+
+  def test_propset_ignore_file
+    svn = SvnWc::RepoAccess.new(YAML::dump(@conf), true, true)
+
+    repo_wc = @conf['svn_repo_working_copy']
+
+    dir_ent = Dir.mktmpdir('P', repo_wc)
+    file = 'file_to_ignore.txt'
+ 
+    svn.add dir_ent, recurse=false
+    svn.propset('ignore', file, dir_ent)
+    svn.commit repo_wc
+
+    file = File.join dir_ent, file
+    # create file we have already ignored, above
+    File.open(file, "w") {|f| f.print('testing propset ignore file.')}
+
+    file2 = new_unique_file_at_path dir_ent
+
+    svn.add dir_ent, recurse=true, force=true
+    svn.commit repo_wc
+
+    assert_raise(SvnWc::RepoAccessError) { svn.info file }
+    assert_equal File.basename(svn.list_entries[0][:entry_name]), 
+                 File.basename(file2)
+    assert_equal svn.list_entries.size, 1
+    assert_nil svn.list_entries[1]
+
+  end
+
+  # TODO
+  # from client.rb
+  #def log(paths, start_rev, end_rev, limit,
+  #        discover_changed_paths, strict_node_history,
+  #        peg_rev=nil)
+  def test_commit_with_message
+    log_mess = 'added new file'
+
+    svn = SvnWc::RepoAccess.new(YAML::dump(@conf), true, true)
+    file = new_unique_file_at_path
+    svn.add file
+    o_rev = svn.commit file, log_mess
+    assert o_rev >= 1
+    args = [file, 0, "HEAD", 0, true, nil]
+    svn.log(*args) do |changed_paths, rev, author, date, message|
+      assert_equal rev, o_rev
+      assert_equal message, log_mess
+    end
+  end
 
-  #def test_delete
-  #end
 
   #
   # methods used by the tests below here
@@ -662,14 +768,14 @@ class TestSvnWc < Test::Unit::TestCase
     return rev, ff
   end
 
-  def modify_file_and_commit_into_another_working_repo(f)
-    raise ArgumentError, "path arg is empty" unless f and not f.empty?
+  def modify_file_and_commit_into_another_working_repo
     svn = _working_copy_repo_at_path
-    File.open(f, 'a') {|fl| fl.write('adding this to file.')}
+    f = new_unique_file_at_path(svn.svn_repo_working_copy)
+    File.open(f, 'w') {|fl| fl.write('this is the original content of file.')}
+    svn.add f
     rev = svn.commit f
-    raise 'cant get status' unless ' ' == svn.status(f)[0][:status]
     raise 'cant get revision' unless rev == svn.info(f)[:rev]
-    rev
+    return rev, f
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: svn_wc
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - David Wright
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-17 00:00:00 -08:00
+date: 2010-02-20 00:00:00 -08:00
 default_executable: 
 dependencies: []