svn 0.1.0

data/lib/svn/revisions.rb

@@ -0,0 +1,133 @@
+require 'time'
+require 'rubygems'
+require 'ffi'
+
+module Svn #:nodoc:
+
+  LOG_PROP_NAME = 'svn:log'
+  AUTHOR_PROP_NAME = 'svn:author'
+  TIMESTAMP_PROP_NAME = 'svn:date'
+
+  class Revision < Root
+
+    include Comparable
+
+    attr_reader :num
+    attr_reader :repo
+
+    def initialize( ptr, repo, pool )
+      super( ptr )
+      @repo = repo
+      @pool = pool
+      @num = revnum
+    end
+
+    def to_i
+      @num
+    end
+
+    def <=>( other )
+      to_i <=> other.to_i
+    end
+
+    module C
+      extend FFI::Library
+      ffi_lib 'libsvn_fs-1.so.1'
+
+      typedef :pointer, :out_pointer
+      typedef Pool, :pool
+      typedef CError.by_ref, :error
+      typedef Root, :root
+      typedef :long, :revnum
+      typedef :string, :name
+      typedef Repo::FileSystem, :fs
+      typedef CountedString, :counted_string
+
+      attach_function :revnum,
+          :svn_fs_revision_root_revision,
+          [ :root ],
+          :revnum
+
+      attach_function :prop,
+          :svn_fs_revision_prop,
+          [ :out_pointer, :fs, :revnum, :name, :pool ],
+          :error
+
+      attach_function :proplist,
+          :svn_fs_revision_proplist,
+          [ :out_pointer, :fs, :revnum, :pool ],
+          :error
+    end
+
+    # use the C module for all bound methods
+    bind_to C
+
+    # gets the numeric identifier for this revision
+    bind :revnum
+    private :revnum
+
+    # returns the revision property +name+
+    bind( :prop,
+        :returning => CountedString,
+        :before_return => :to_s,
+        :validate => Error.return_check
+      ) { |out, this, name| [ out, repo.fs, num, name, pool ] }
+
+    # returns a hash of revision properties
+    bind( :props, :to => :proplist,
+        :returning => AprHash.factory( :string, [:pointer, :string] ),
+        :before_return => :to_h,
+        :validate => Error.return_check
+      ) { |out, this| [ out, repo.fs, num, pool ] }
+
+    def message
+      prop( LOG_PROP_NAME )
+    end
+    alias_method :log, :message
+
+    def author
+      prop( AUTHOR_PROP_NAME )
+    end
+
+    def timestamp
+      Time.parse( prop( TIMESTAMP_PROP_NAME ) )
+    end
+
+    # diffs +path+ with another revision. if no revision is specified, the
+    # previous revision is used.
+    def diff( path, options={} )
+      raise Svn::Error, "cannot diff directory #{path}@#{to_s}" if dir? path
+
+      other = options[:with] if options[:with].is_a? Root
+      other = repo.revision(options[:with]) if options[:with].is_a? Numeric
+      other ||= repo.revision(to_i - 1)
+
+      return other.diff( path, :with => self ) if other < self
+
+      content = ""
+      begin
+        content = file_content_stream( path ).to_counted_string
+      rescue Svn::Error => err
+        raise if options[:raise_errors]
+      end
+
+      other_content = ""
+      begin
+        other_content= other.file_content_stream( path ).to_counted_string
+      rescue Svn::Error => err
+        raise if options[:raise_errors]
+      end
+
+      Diff.string_diff( content, other_content ).unified(
+          :original_header => "#{path}@#{to_s}",
+          :modified_header => "#{path}@#{other}"
+        )
+    end
+
+    def to_s
+      "r#{to_i}"
+    end
+
+  end
+
+end

data/lib/svn/roots.rb

@@ -0,0 +1,161 @@
+require 'rubygems'
+require 'ffi'
+
+module Svn #:nodoc:
+
+  class Root < FFI::AutoPointer
+
+    class << self
+      def release( ptr )
+        C.close_root( ptr )
+      end
+    end
+
+    module C
+      extend FFI::Library
+      ffi_lib 'libsvn_fs-1.so.1'
+
+      typedef :pointer, :out_pointer
+      typedef Pool, :pool
+      typedef CError.by_ref, :error
+      typedef Root, :root
+      typedef :string, :path
+      typedef :string, :name
+
+      # lifecycle functions
+      attach_function :close_root,
+          :svn_fs_close_root,
+          [ :root ],
+          :void
+
+      # node metadata
+      attach_function :is_dir,
+          :svn_fs_is_dir,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+      attach_function :is_file,
+          :svn_fs_is_file,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+      attach_function :created_rev,
+          :svn_fs_node_created_rev,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+      attach_function :created_path,
+          :svn_fs_node_created_path,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+
+      # props
+      attach_function :node_prop,
+          :svn_fs_node_prop,
+          [ :out_pointer, :root, :path, :name, :pool ],
+          :error
+      attach_function :node_proplist,
+          :svn_fs_node_proplist,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+
+      # files
+      attach_function :file_size,
+          :svn_fs_file_length,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+      attach_function :file_content,
+          :svn_fs_file_contents,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+
+      # dirs
+      attach_function :dir_content,
+          :svn_fs_dir_entries,
+          [ :out_pointer, :root, :path, :pool ],
+          :error
+
+      # changes
+      attach_function :changes,
+          :svn_fs_paths_changed2,
+          [ :out_pointer, :root, :pool ],
+          :error
+    end
+
+    def pool
+      @pool ||= RootPool
+    end
+
+    # helper procs for method binding
+    test_c_true = Proc.new { |i| i == 1 }
+    add_pool = Proc.new { |out, this, *args| [ out, this, *args, pool ] }
+
+    # use the above C module for the source of bound functions
+    bind_to C
+
+    # bound method definitions
+    bind :dir?, :to => :is_dir,
+        :returning => :int,
+        :before_return => test_c_true,
+        :validate => Error.return_check,
+        &add_pool
+
+    bind :dir_content,
+        :returning => AprHash.factory( :string, :pointer ),
+        :before_return => Proc.new { |h| h.to_h.keys },
+        :validate => Error.return_check,
+        &add_pool
+
+    bind :file?, :to => :is_file,
+        :returning => :int,
+        :before_return => test_c_true,
+        :validate => Error.return_check,
+        &add_pool
+
+    bind :file_size,
+        :returning => :int64,
+        :validate => Error.return_check,
+        &add_pool
+
+    bind :file_content,
+        :returning => Stream,
+        :before_return => :to_string_io,
+        :validate => Error.return_check,
+        &add_pool
+
+    bind :file_content_stream, :to => :file_content,
+        :returning => Stream,
+        :validate => Error.return_check,
+        &add_pool
+
+    bind :created_rev,
+        :returning => :long,
+        :validate => Error.return_check,
+        &add_pool
+
+    bind :created_path,
+        :returning => :string,
+        :validate => Error.return_check,
+        &add_pool
+
+    # returns the +path+'s property value for +name+
+    bind :prop_for, :to => :node_prop,
+        :returning => CountedString,
+        :before_return => :to_s,
+        :validate => Error.return_check,
+        &add_pool
+
+    # returns a hash of name to property values for +path+
+    bind :props_for, :to => :node_proplist,
+        :returning => AprHash.factory( :string, [:pointer, :string] ),
+        :before_return => :to_h,
+        :validate => Error.return_check,
+        &add_pool
+
+    # return the changes in this revision or transaction
+    bind :changes,
+        :returning => AprHash.factory( :string, ChangedPath ),
+        :before_return => :to_h,
+        :validate => Error.return_check,
+        &add_pool
+
+  end
+
+end

data/lib/svn/streams.rb

@@ -0,0 +1,149 @@
+require 'stringio'
+require 'rubygems'
+require 'ffi'
+
+module Svn
+  
+  class Stream < FFI::AutoPointer
+
+    class << self
+      # Wraps an IO object to be used as a subversion stream
+      def wrap_io( io, pool=RootPool )
+        stream = new( C.create( Svn::Utils.wrap(io), pool ) )
+        C.set_write( stream, C::WriteToIO )
+        C.set_read( stream, C::ReadFromIO )
+        return stream
+      end
+
+      def release( ptr )
+        Error.check_and_raise(
+            C.close( ptr )
+          )
+      end
+    end
+
+    module C
+      extend FFI::Library
+      ffi_lib 'libsvn_subr-1.so.1'
+
+      typedef :pointer, :in_out_len
+      typedef CError.by_ref, :error
+      typedef Pool, :pool
+      typedef Stream, :stream
+      typedef :size_t, :apr_size
+
+      callback :read_function, [:pointer, :pointer, :pointer], :error
+      callback :write_function, [:pointer, :string, :pointer], :error
+
+      # lifecycle functions
+      attach_function :create,
+          :svn_stream_create,
+          [:pointer, :pool], :pointer
+      attach_function :set_read,
+          :svn_stream_set_read,
+          [:stream, :read_function], :void
+      attach_function :set_write,
+          :svn_stream_set_write,
+          [:stream, :write_function], :void
+      attach_function :close,
+          :svn_stream_close,
+          [:stream], :error
+
+      # note: the SVN docs say that short reads indicate the end of the stream
+      # and short writes indicate an error.  this means that we cannot use
+      # read_nonblock and write_nonblock, since they do not guarantee anything
+      # will happen.
+
+      ReadFromIO = FFI::Function.new(
+          :pointer, [:pointer, :pointer, :pointer]
+        ) do |io_ptr, out_buffer, in_out_len|
+
+        # read the number of bytes requested and unwrap the io object
+        bytes_to_read = in_out_len.read_int
+        io = Svn::Utils.unwrap(io_ptr)
+
+        # read the bytes from IO and write them to the pointer object
+        bytes_read = io.read( bytes_to_read )
+        out_buffer.write_string( bytes_read )
+
+        # write the number of bytes read from io
+        in_out_len.write_int( bytes_read.length )
+
+        nil # return no error
+      end
+
+      WriteToIO = FFI::Function.new(
+          :pointer, [:pointer, :string, :pointer]
+        ) do |io_ptr, in_string, in_out_len|
+
+        # read the size of in_string and unwrap the io object
+        bytes_to_write = in_out_len.read_int
+        io = Svn::Utils.unwrap(io_ptr)
+
+        # should we check that in_string isn't longer than in_out_len?
+        bytes_written = io.write( in_string )
+
+        # write the actual number of bytes written to io
+        in_out_len.write_int( bytes_written )
+
+        nil # return no error
+      end
+
+      # accessor functions
+      attach_function :read,
+          :svn_stream_read,
+          [ :stream, :buffer_out, :in_out_len ],
+          :error
+    end
+
+    def read( size=8192 )
+      # setup the pointers
+      @in_out_len ||= FFI::MemoryPointer.new( :size_t )
+      @in_out_len.write_ulong( size )
+
+      # make sure a buffer for reading exists and save it for reuse
+      if @read_buf.nil? or @read_buf.size < size
+        @read_buf = FFI::Buffer.alloc_out( size )
+      end
+
+      # call read to fill the buffer
+      Error.check_and_raise(
+          C.read( self, @read_buf, @in_out_len )
+        )
+
+      @read_buf.read_bytes( @in_out_len.read_ulong )
+    end
+
+    # reads the stream contents into a String object
+    def read_all
+      content = String.new
+      while bytes = read and !bytes.empty?
+        content << bytes
+      end
+      content
+    end
+    alias_method :to_s, :read_all
+
+    # reads the entire stream and creates a CountedString from the contents
+    #
+    # Note that this function copies the entire stream into Ruby memory and
+    # then copies it again into C memory. There is probably a more efficient
+    # way to do this, by allocating a big string and re-allocing when the size
+    # required overruns that memory
+    def to_counted_string
+      CountedString.from_string( read_all )
+    end
+
+    # reads the stream contents into a StringIO object
+    def to_string_io
+      content = StringIO.new
+      while bytes = read and !bytes.empty?
+        content.write( bytes )
+      end
+      content.rewind
+      content
+    end
+
+  end
+
+end

data/lib/svn/transactions.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'ffi'
+
+module Svn #:nodoc:
+
+  class Transaction < Root
+
+    def initialize( txn_ptr, pool )
+      # using the transaction object, get it's root
+      out_ptr = FFI::MemoryPointer.new(:pointer)
+      Error.check_and_raise(
+          C.root( out_ptr, txn_ptr, pool )
+        )
+
+      # call super with the root pointer, rather than the transaction pointer.
+      # this is so Transactions can be used as Roots in external calls:
+      super( out_ptr.read_pointer )
+
+      # save off the others
+      @txn_ptr = txn_ptr
+      @pool = pool
+    end
+
+    class << self
+      def release
+      end
+    end
+
+    module C
+      extend FFI::Library
+      ffi_lib 'libsvn_fs-1.so.1'
+
+      typedef :pointer, :out_pointer
+      typedef Pool, :pool
+      typedef CError.by_ref, :error
+      typedef :pointer, :transaction
+      typedef :long, :revnum
+
+      attach_function :cancel_transaction,
+          :svn_fs_abort_txn,
+          [ :transaction, :pool ],
+          :error
+      attach_function :root,
+          :svn_fs_txn_root,
+          [ :out_pointer, :pointer, :pool ],
+          :error
+    end
+
+  end
+
+end