svn 0.1.0

data/lib/svn/errors.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'ffi'
+
+module Svn
+
+  class Error < RuntimeError
+
+    class << self
+
+      # checks error and raises an exception for error if necessary
+      def check_and_raise( err )
+        return if err.null?
+        raise Error.new( err )
+      end
+
+      # returns a proc that calls check_and_raise
+      def return_check
+        @@return_check ||= Proc.new { |ptr| Error.check_and_raise( ptr ) }
+      end
+
+    end
+
+    attr_reader :c_error
+
+    def initialize( message_or_c_error )
+      if message_or_c_error.is_a? CError
+        super( message_or_c_error.best_message )
+        @c_error = message_or_c_error
+      else
+        super( message_or_c_error )
+      end
+    end
+
+  end
+
+  class CError < FFI::ManagedStruct
+    layout(
+        :apr_error, :int,
+        :message, :string,
+        :child, :pointer,
+        :pool, :pointer,
+        :filename, :string,
+        :line, :long
+      )
+
+    class << self
+      def release( ptr )
+        C.clear( ptr )
+      end
+    end
+
+    # returns the most accurate message for an error
+    def best_message
+      # create a buffer, which may be used to hold the best message
+      buf = FFI::MemoryPointer.new( 1024 )
+      msg = C.best_message( self, buf, 1024 )
+
+      # return a duplicate of msg, since it may be stored in the buffer
+      # allocated above
+      msg.dup
+    end
+
+    module C
+      extend FFI::Library
+      ffi_lib 'libsvn_subr-1.so.1'
+
+      typedef CError.by_ref, :error
+      typedef :int, :size
+
+      attach_function :best_message,
+          :svn_err_best_message,
+          [ :error, :buffer_inout, :size ],
+          :string
+
+      attach_function :clear,
+          :svn_error_clear,
+          [ :error ],
+          :void
+    end
+
+  end
+
+end

data/lib/svn/logs.rb

@@ -0,0 +1,120 @@
+require 'time'
+require 'rubygems'
+require 'ffi'
+
+module Svn #:nodoc:
+
+  module Log
+
+    # description of a changed path
+    class ChangedPathStruct < FFI::Struct
+      layout(
+          :action, :char, # 'A'dd, 'D'elete, 'R'eplace, 'M'odify
+          :copyfrom_path, :string,
+          :copyfrom_rev, :long,
+          :node_kind, NodeKind
+        )
+
+      # returns a character that represents the type of the change: :added,
+      # :deleted, :replaced, :modified
+      def action
+        Actions[ self[:action] ]
+      end
+
+      # returns the path's node type (:none, :file, :dir, :unknown)
+      def kind
+        self[:node_kind]
+      end
+
+      # returns whether the "copied from" values are known
+      def copyfrom_known?
+        ( self[:copyfrom_rev] >= 0 )
+      end
+
+      # if the node was copied from another path/rev, returns the [path, rev]
+      # pair or nil otherwise
+      def copied_from
+        [ self[:copyfrom_path], self[:copyfrom_rev] ] if copyfrom_known?
+      end
+
+      def to_h
+        h = { :action => action, :kind => kind }
+        h[:copied_from] = copied_from if copyfrom_known?
+        h
+      end
+    end
+
+    # create a mapped type for use elsewhere
+    ChangedPath = ChangedPathStruct.by_ref
+
+    # A subversion log entry
+    class EntryStruct < FFI::Struct
+      layout(
+          :old_changed_paths, AprHash.factory( :string, :pointer ),
+          :rev, :long,
+          :rev_props, AprHash.factory( :string, [:pointer, :string] ),
+          :has_children, :int,
+          :changed_paths, AprHash.factory( :string, ChangedPath )
+        )
+
+      # returns the revision number
+      def rev
+        self[:rev]
+      end
+      alias_method :num, :rev
+
+      # returns whether this revision has children
+      def has_children?
+        ( self[:has_children] == 1 )
+      end
+
+      # returns a Hash of the revision's changed paths
+      def changed_paths
+        @changed_paths ||= ( self[:changed_paths].null? ? nil :
+            self[:changed_paths].to_h.tap { |by_path|
+                by_path.each_key { |k| by_path[k] = by_path[k].to_h }
+              }
+          )
+      end
+
+      # returns a Hash of the revision's properties
+      def props
+        @props ||= ( self[:rev_props].null? ? nil : self[:rev_props].to_h )
+      end
+
+      # return the revision's log message
+      def message
+        props[ LOG_PROP_NAME ] if props
+      end
+      alias_method :log, :message
+
+      # return the revision's author
+      def author
+        props[ AUTHOR_PROP_NAME ] if props
+      end
+
+      # return the Time that this revision was committed
+      def timestamp
+        Time.parse( props[ TIMESTAMP_PROP_NAME ] ) if props
+      end
+
+      # get the contents of this log entry as a multi-level hash
+      def to_h
+        h = {
+            :rev => rev,
+            :log => message,
+            :author => author,
+            :timestamp => timestamp,
+            :has_children? => has_children?,
+          }
+        h[:changed_paths] = changed_paths if changed_paths
+        h
+      end
+    end
+
+    # create a mapped type for use elsewhere
+    Entry = EntryStruct.by_ref
+
+  end
+
+end

data/lib/svn/misc.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'ffi'
+
+module Svn #:nodoc:
+
+  extend FFI::Library
+
+  NodeKind = enum( :none, :file, :dir, :unknown )
+
+  Actions = enum(
+      :added, 65,
+      :deleted, 68,
+      :replaced, 82,
+      :modified, 77
+    )
+
+  PathChangeKind = enum( :modified, :added, :deleted, :replaced, :reset )
+
+  class ChangedPathStruct < FFI::Struct
+    layout(
+        :id, :pointer,
+        :change_kind, PathChangeKind,
+        :text_mods, :int,
+        :prop_mods, :int,
+        :node_kind, NodeKind,
+        :copyfrom_known, :int,
+        :copyfrom_rev, :long,
+        :copyfrom_path, :string
+      )
+
+    def change_kind
+      self[ :change_kind ]
+    end
+
+    def node_kind
+      self[ :node_kind ]
+    end
+
+    def text_mods?
+      ( self[ :text_mods ] == 1 )
+    end
+
+    def prop_mods?
+      ( self[ :prop_mods ] == 1 )
+    end
+
+    def copyfrom_known?
+      ( self[ :copyfrom_known ] == 1 )
+    end
+
+    def copied_from
+      [ self[:copyfrom_path], self[:copyfrom_rev] ] unless copyfrom_known?
+    end
+
+    def to_h
+      h = {
+          :change_kind => change_kind,
+          :node_kind => node_kind,
+          :text_mods? => text_mods?,
+          :prop_mods? => prop_mods?,
+        }
+      h[:copied_from] = copied_from if copyfrom_known?
+      h
+    end
+  end
+  ChangedPath = ChangedPathStruct.by_ref
+
+end

data/lib/svn/pools.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'ffi'
+
+module Svn #:nodoc:
+
+  # APR memory pool
+  class Pool < FFI::AutoPointer
+
+    class << self
+      # create a new pool in +parent+.  if +parent+ is nil, the allocate a root pool.
+      def create( parent=nil )
+        out = FFI::MemoryPointer.new( :pointer )
+        C.create( out, parent, C::RaiseOutOfMemory, nil )
+        return new( out.read_pointer )
+      end
+
+      # free and release a pool
+      def release( ptr )
+        C.destroy( ptr )
+      end
+    end
+
+    module C
+      extend FFI::Library
+      ffi_lib 'libapr-1.so.0'
+
+      typedef :int, :apr_status
+      typedef Pool, :pool
+
+      callback :abort_function, [:apr_status], :int
+
+      # life-cycle methods
+      attach_function :initialize, :apr_initialize, [], :apr_status
+
+      attach_function :create,
+          :apr_pool_create_ex,
+          [:pointer, :pool, :abort_function, :pointer],
+          :apr_status
+
+      attach_function :clear, :apr_pool_clear, [:pool], :void
+
+      attach_function :destroy, :apr_pool_destroy, [:pool], :void
+
+      # instance methods
+      # apr_pool_cleanup_register
+      # apr_pool_userdata_set
+      # apr_pool_userdata_get
+
+      RaiseOutOfMemory = FFI::Function.new( :int, [:int] ) do |status|
+        raise NoMemoryError.new('Could not allocate new pool')
+      end
+
+      initialize
+    end
+
+    # use the C module for all bound methods
+    bind_to C
+
+    # clear all allocated memory in the pool so it can be reused
+    bind :clear
+
+  end
+
+  # create the root pool that will be the default pool
+  RootPool = Pool.create
+
+end

data/lib/svn/repos.rb

@@ -0,0 +1,333 @@
+require 'rubygems'
+require 'ffi'
+
+module Svn #:nodoc:
+
+  INVALID_REVNUM = -1
+
+  # A subverion repository object
+  #
+  # This represents both the repository and the filesystem
+  class Repo < FFI::AutoPointer
+
+    attr_reader :pool
+
+    def initialize( ptr, pool )
+      super( ptr )
+      @pool = pool
+    end
+
+    class << self
+      #--
+      # several methods remove trailing separators; this is to avoid triggering
+      # assertions in SVN libs
+      #++
+      def open( path, parent=RootPool )
+        # get a new pool for all interactions with this repository
+        pool = Pool.create( parent )
+
+        # TODO: we may need to call find_root_path for this, if C.open expects
+        # an exact repository root path
+        out = FFI::MemoryPointer.new( :pointer )
+
+        Error.check_and_raise(
+            C.open( out, path.chomp(File::SEPARATOR), pool )
+          )
+
+        new( out.read_pointer, pool )
+      end
+
+      def create( path, parent=RootPool )
+        # get a new pool for all interactions with this repository
+        pool = Pool.create( parent )
+
+        out = FFI::MemoryPointer.new( :pointer )
+
+        Error.check_and_raise(
+            C.create(
+                out, # an out pointer to the newly created repository
+                path.chomp(File::SEPARATOR), # path on disk
+                nil, nil, # unused
+                nil, nil, # configs are not implemeted
+                pool # the pool to use for any allocations
+              )
+          )
+
+        new( out.read_pointer, pool )
+      end
+
+      def delete( path, pool=RootPool )
+        Error.check_and_raise(
+            C.delete( path.chomp(File::SEPARATOR), pool )
+          )
+      end
+
+      # this release method does nothing because the repo will be released when
+      # its pool is destroyed
+      def release( ptr )
+      end
+    end
+
+    # A filesystem object.  Repositories completely encapsulate the filesystem,
+    # so it is unnecessary to use it directly.
+    class FileSystem < FFI::AutoPointer
+      class << self
+        # this release method does nothing because the filesystem will be
+        # released with its pool, which is associated with the repo that owns
+        # the filesystem
+        def release( ptr )
+        end
+      end
+    end
+
+    # returns the repository's filesystem
+    #
+    # this is for internal use because Repo objects should handle all fs
+    # functionality
+    def filesystem
+      @fs ||= C.filesystem( self )
+    end
+    alias_method :fs, :filesystem
+
+    module C
+      extend FFI::Library
+      ffi_lib 'libsvn_repos-1.so.1'
+
+      # convenience pointers
+      typedef :pointer, :out_pointer
+      typedef :string, :path
+      typedef :long, :revnum
+      typedef :int, :bool
+
+      # data types
+      typedef Pool, :pool
+      typedef AprHash, :hash
+      typedef AprArray, :array
+      typedef CError.by_ref, :error
+      typedef FileSystem, :filesystem
+      typedef Log::Entry, :log_entry
+      typedef Root, :root
+      typedef Revision, :revision
+      #typedef Transaction, :transaction
+      typedef Repo, :repo
+
+      callback :history_function,
+          [ :pointer, :path, :revnum, :pool ],
+          :error
+
+      CollectChanges = FFI::Function.new(
+          :pointer, [ :pointer, :string, :long, :pointer ]
+        ) do |data_ptr, path, rev, pool|
+        arr = Utils.unwrap( data_ptr )
+        arr << [ path, rev ]
+        nil # no error
+      end
+
+      callback :authz_function,
+          [ :out_pointer, :root, :path, :pointer, :pool ],
+          :error
+
+      callback :log_entry_function,
+          [ :pointer, :log_entry, :pool ],
+          :error
+
+      CollectHistory = FFI::Function.new(
+          :pointer, [ :pointer, :pointer, :pointer ]
+        ) do |data_ptr, log_entry_ptr, pool|
+        arr = Utils.unwrap( data_ptr )
+        # the struct passed here is shared for all calls and the data is freed
+        # and overwritten, so the data from each Log::Entry struct needs to be
+        # copied out using :to_h
+        arr << Utils.content_for( log_entry_ptr, Log::Entry ).to_h
+        nil # no error
+      end
+
+      # misc functions
+      attach_function :find,
+          :svn_repos_find_root_path,
+          [ :path, :pool ],
+          :string
+
+      # repository functions
+      attach_function :open,
+          :svn_repos_open,
+          [ :out_pointer, :path, :pool ],
+          :error
+      attach_function :create,
+          :svn_repos_create,
+          [ :out_pointer, :path,
+            :pointer, :pointer, # both unused
+            :hash, :hash,       # config, fs-config
+            :pool ],
+          :error
+      attach_function :delete,
+          :svn_repos_delete,
+          [ :path, :pool ],
+          :error
+
+      # filesystem accessor
+      attach_function :filesystem,
+          :svn_repos_fs,
+          [ :repo ],
+          :filesystem
+
+      # repository-level inspection
+      attach_function :history,
+          :svn_repos_history2,
+          [ :filesystem, :path,
+            :history_function, :pointer,  # history callback and data
+            :authz_function, :pointer,    # authz callback and data
+            :revnum, :revnum,             # start rev and end rev
+            :bool, :pool ],               # cross copies?
+          :error
+
+      attach_function :logs,
+          :svn_repos_get_logs4,
+          [ :repo,
+            :array, # file paths
+            :revnum, :revnum, :int, # start rev, end rev, and limit
+            :bool,                  # discover changed paths?
+            :bool,                  # strict history? strict = no cross copies
+            :bool,                  # include merged revisions?
+            :array,                 # rev-prop names to get; NULL=all, []=none
+            :authz_function, :pointer,      # authz callback and data
+            :log_entry_function, :pointer,  # receiver callback and data
+            :pool
+            ],
+          :error
+
+      # transaction (root) accessor, creation, and manipulation
+      #attach_function :create_transaction,
+      #    :svn_repos_fs_begin_txn_for_commit2,
+      #    [ :out_pointer, :repo, :revnum, :hash, :pool ],
+      #    :error
+      #attach_function :commit_transaction,
+      #    :svn_repos_fs_commit_txn,
+      #    [ :out_pointer, :repo, :out_pointer, :transaction ],
+      #    :error
+
+      ffi_lib 'libsvn_fs-1.so.1'
+
+      # youngest revision number accessor
+      attach_function :youngest,
+          :svn_fs_youngest_rev,
+          [ :out_pointer, :filesystem, :pool ],
+          :error
+
+      # revision (root) accessor
+      attach_function :revision,
+          :svn_fs_revision_root,
+          [ :out_pointer, :filesystem, :revnum, :pool ],
+          :error
+
+      #attach_function :open_transaction,
+      #    :svn_fs_begin_txn2,
+      #    [ :out_pointer, :filesystem, :string, :pool ],
+      #    :error
+    end
+
+    use_fs_and_add_pool = Proc.new { |out, this, *args|
+        [ out, fs, *args, pool ]
+      }
+
+    # use the above C module for the source of bound functions
+    bind_to C
+
+    # returns the number of the youngest revision in the repository
+    bind :youngest,
+        :returning => :long,
+        :before_return => Proc.new { |rev| revision(rev) },
+        :validate => Error.return_check,
+        &use_fs_and_add_pool
+
+    alias_method :latest, :youngest
+
+    # returns a Revision for rev +num+ or raises Svn::Error if the revision
+    # does not exist
+    bind :revision,
+        :returning => :pointer,
+        :before_return => Proc.new { |ptr|
+            Revision.new( ptr, self, pool ) unless ptr.null?
+          },
+        :validate => Error.return_check,
+        &use_fs_and_add_pool
+
+    # returns an array of "interesting" [path, rev] pairs for path
+    #
+    # for more detailed information, use +history+
+    #
+    # if a block is given, each pair will be yielded
+    #
+    # options:
+    # +start_rev+ :: restricts revisions to newer than :start_rev
+    # +end_rev+ :: restricts revisions to older than :end_rev
+    # +cross_copies+ :: continue history at filesystem copies?
+    def changes( path, options={}, &block )
+      # ensure the options can be passed to C successfully
+      start_rev = (options[:start_rev] || 0).to_i
+      end_rev = (options[:end_rev] || youngest).to_i
+      cross_copies = ( options[:cross_copies] ? 1 : 0 )
+
+      # collect the change [path, rev] pairs
+      changes = []
+      Error.check_and_raise( C.history(
+          fs, path,
+          C::CollectChanges, Utils.wrap( changes ),
+          nil, nil, start_rev, end_rev, cross_copies, pool
+        ) )
+
+      # if the caller supplied a block, use it
+      changes.each( &block ) if block_given?
+
+      changes
+    end
+
+    # returns an array of log entry hashes for relevant revisions, containing:
+    # * revision number (+rev+), +log+, +author+, and +timestamp+
+    #
+    # if a block is given, each log entry hash will be yielded
+    #
+    # options:
+    # +start_rev+ :: restricts revisions to newer than :start_rev
+    # +end_rev+ :: restricts revisions to older than :end_rev
+    # +cross_copies+ :: continue history at filesystem copies?
+    # +include_merged+ :: include merged history?
+    # +include_changes+ :: include change info in +:changed_paths+?
+    #
+    # starting and ending revisions can be switched to reverse the final order
+    def history( paths=nil, options={}, &block )
+      # if no paths were passed, but options were, then paths will be a hash
+      if paths.is_a? Hash
+        options = paths
+        paths = nil
+      end
+
+      # ensure the options can be passed to C successfully
+      paths_c_arr = AprArray.create_from( Array( paths ), :string )
+      start_rev = (options[:start_rev] || 0).to_i
+      end_rev = (options[:end_rev] || youngest).to_i
+      limit = (options[:limit] || 0).to_i # 0 => all entries
+      discover_changed_paths = ( options[:include_changes] ? 1 : 0 )
+      strict_history = ( options[:cross_copies] ? 0 : 1 )
+      include_merged = ( options[:include_merged] ? 1 : 0 )
+
+      # collect the history entries
+      history = []
+      Error.check_and_raise( C.logs(
+          self, paths_c_arr,
+          start_rev, end_rev, limit,
+          discover_changed_paths, strict_history, include_merged,
+          nil, nil, nil,
+          C::CollectHistory, Utils.wrap( history ),
+          pool
+        ) )
+
+      # if the caller supplied a block, use it
+      history.each( &block ) if block_given?
+
+      history
+    end
+
+  end
+
+end