jm81-dm-svn 0.1.0

data/.gitignore

@@ -0,0 +1,22 @@
+.DS_Store
+log/*
+tmp/*
+TAGS
+*~
+.#*
+schema/schema.rb
+schema/*_structure.sql
+schema/*.sqlite3
+schema/*.sqlite
+schema/*.db
+*.sqlite
+*.sqlite3
+*.db
+src/*
+.hgignore
+.hg/*
+.svn/*
+.project
+.loadpath
+lib/wistle/tmp/*
+config/recaptcha.yml

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "dm-svn"
+    gem.summary = %Q{Sync content from a Subversion repository to a DataMapper model}
+    gem.email = "jmorgan@morgancreative.net"
+    gem.homepage = "http://github.com/jm81/dm-svn"
+    gem.authors = ["Jared Morgan"]
+    gem.add_dependency('dm-core')
+    gem.add_dependency('dm-aggregates')
+    gem.add_dependency('dm-validations')
+    gem.add_dependency('jm81-svn-fixture', '>= 0.1.1')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "dm-svn #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/dm-svn/config.rb

@@ -0,0 +1,38 @@
+module DmSvn
+  class Config
+    OPTS = [:uri, :username, :password,
+            :body_property, :property_prefix, :extension]
+    
+    attr_accessor *OPTS
+    attr_accessor :path_from_root # Used by Sync.
+    
+    def initialize
+      # Set defaults
+      @body_property = 'body'
+      @property_prefix = 'ws:'
+      @extension = 'txt'
+
+      # Try to set variables from database.yml.
+      # The location of database.yml should, I suppose, be configurable.
+      # Oh, well.
+      if Object.const_defined?("RAILS_ROOT")
+        f = "#{RAILS_ROOT}/config/database.yml"
+        env = Kernel.const_defined?("RAILS_ENV") ? RAILS_ENV : "development"
+      elsif Object.const_defined?("Merb")
+        f = "#{Merb.root}/config/database.yml"
+        env = Merb.env.to_sym || :development
+      end
+      
+      if f
+        config = YAML.load(IO.read(f))[env]
+        OPTS.each do |field|
+          config_field = config["svn_#{field}"] || config["svn_#{field}".to_sym]
+          if config_field
+            instance_variable_set("@#{field}", config_field)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/dm-svn/model.rb

@@ -0,0 +1,12 @@
+module DmSvn
+  class Model
+    include DataMapper::Resource
+  
+    property :id, Integer, :serial => true
+    property :name, String
+    property :revision, Integer
+    
+    # DmSvn::Config object
+    attr_accessor :config
+  end
+end

data/lib/dm-svn/svn/categorized.rb

@@ -0,0 +1,113 @@
+module DmSvn
+  module Svn
+    
+    module ClassMethods
+      
+      # Override belongs_to to add a :dm-svn option if :dm-svn => true, include
+      # Categorized and set up @svn_category and @svn_category_model instance
+      # methods.
+      def belongs_to(what, options = {})
+        svn = options.delete(:svn)
+        if svn
+          @svn_category = what
+          @svn_category_model = options[:class_name] || what.to_s.camel_case
+          include(DmSvn::Svn::Categorized)
+        end
+        
+        super
+      end
+      
+      # Method name for accessing the parent instance.
+      def svn_category
+        @svn_category
+      end
+      
+      # Name of the parent model class (as a String)
+      def svn_category_model
+        @svn_category_model
+      end
+      
+    end
+    
+    # This module is including when belongs_to is called with :dm-svn => true.
+    # It overrides #path and #path= to take into account categories (folders in 
+    # the Subversion repository). It also overrides .get to accept get_parent
+    # argument.
+    module Categorized
+      class << self
+        def included(klass)
+          klass.extend(ClassMethods)
+        end
+      end
+      
+      # The path from the svn root for the model. Includes any folders.
+      def path
+        cat = self.send(self.class.svn_category)
+        
+        if cat && !cat.path.blank?
+          return cat.path + "/" + @svn_name
+        end
+        
+        return @svn_name
+      end
+    
+      # Set the path. This is responsible for moving the record to a different
+      # parent, etc.
+      def path=(value)
+        value = value[1..-1] while value[0..0] == "/"
+        ary = value.split("/")
+        immediate = ary.pop
+        parent = ary.join("/")
+        
+        if parent.blank?
+          self.send("#{self.class.svn_category}=", nil)
+        else
+          category_model = Object.const_get(self.class.svn_category_model)
+          category = category_model.get_or_create(parent)
+          self.send("#{self.class.svn_category}=", category)
+        end
+        
+        attribute_set(:svn_name, immediate)
+      end
+      
+      module ClassMethods
+        
+        # Get by path, which gets parent (possibly recursively) first.
+        def get_by_path(value)
+          value = value[1..-1] while value[0..0] == "/"
+          ary = value.split("/")
+          immediate = ary.pop
+          parent = ary.join("/")
+          
+          if parent.blank?
+            first(:svn_name => immediate, "#{self.svn_category}_id".to_sym => nil)
+          else
+            category_model = Object.const_get(self.svn_category_model)
+            category = category_model.get_by_path(parent)
+            return nil if category.nil?
+            first(:svn_name => immediate, "#{self.svn_category}_id".to_sym => category.id)
+          end
+        end
+        
+        # Add get_parent argument. If true and a path is not found for the 
+        # model, try to find path in parent model (if any).
+        def get(path_or_id, get_parent = false)
+          if path_or_id.is_a?(String)
+            i = get_by_path(path_or_id)
+            if i || !get_parent
+              return i 
+            else # if get_parent
+              category_model = Object.const_get(@svn_category_model)
+              return nil if category_model == self.class
+              category_model.get_by_path(path_or_id)
+            end
+          else
+            super(path_or_id)
+          end
+        end
+        
+      end
+    
+    end
+  end
+end

data/lib/dm-svn/svn/changeset.rb

@@ -0,0 +1,119 @@
+module DmSvn
+  module Svn
+
+    # Store information about a particular changeset, and runs the actual
+    # updates for that changeset. Aside from handling the
+    # list of changes, it can be passed to methods that need the revision,
+    # date and author.
+    class Changeset
+      include Comparable
+      
+      attr_reader :changes, :revision, :date, :author, :repos, :config
+      
+      def initialize(changes, revision, author, date, sync)
+        @changes, @revision, @author, @date = changes, revision, author, date
+        @model, @config, @repos, @sync = sync.model, sync.config, sync.repos, sync
+      end
+      
+      # Changesets are sorted by revision number, ascending.
+      def <=>(other)
+        self.revision <=> other.revision
+      end
+      
+      # Process this changeset.
+      # This doesn't account for possible move/replace conflicts (A node is moved,
+      # then the old node is replaced by a new one). I assume those are rare
+      # enough that I won't code around them, for now.
+      def process
+        return if changes.nil?
+        
+        modified, deleted, copied = [], [], []
+        
+        changes.each_pair do |path, change|
+          next if short_path(path).blank? || !path_in_root?(path)
+          
+          case change.action
+          when "M", "A", "R" # Modified, Added or Replaced
+            modified << path
+          when "D"
+            deleted << path
+          end
+          copied << [path, change.copyfrom_path] if change.copyfrom_path
+        end
+              
+        # Perform moves
+        copied.each do |copy|
+          del = deleted.find { |d| d == copy[1] }
+          if del
+            # Change the path. No need to perform other updates, as this is an
+            # "A" or "R" and thus is in the +modified+ Array.
+            record = get(del)
+            record.move_to(short_path(copy[0])) if record
+          end
+        end
+        
+        # Perform deletes
+        deleted.each do |path|
+          record = get(path)
+          record.destroy if record # May have been moved or refer to a directory
+        end
+        
+        # Perform modifies and adds
+        modified.each do |path|
+          node = Node.new(self, path)
+          
+          if @config.extension && 
+              node.file? &&
+              path !~ /\.#{@config.extension}\Z/ 
+            if path =~ /\.yml\Z/ && @model.svn_category_model
+              # Update parent directory, if applicable
+              path = path.split("/")[0..-2].join("/")
+              node = Node.new(self, path)
+            else
+              next
+            end
+          end
+          
+          record = get(path) || new_record(node)
+  
+          # update record
+          record.update_from_svn(node)
+        end
+      end
+    
+      # Get the relative path from config.uri
+      def short_path(path)
+        path = fs_path(path)
+        path = path.sub(/\.#{@config.extension}\Z/, '') if @config.extension
+        path
+      end
+      
+      # Path used to communicate with svn repos.
+      def fs_path(path)
+        path = path[@config.path_from_root.length..-1].to_s
+        path = path[1..-1] if path[0] == ?/
+        path
+      end
+          
+      private
+      
+      def path_in_root?(path)
+        return true if @config.path_from_root.blank?
+        path[0..@config.path_from_root.length - 1].to_s == @config.path_from_root
+      end
+      
+      # Get an object of the @model, by path.
+      def get(path)
+        @model.get(short_path(path), true)
+      end
+      
+      # Create a new object of the @model
+      def new_record(node)
+        node.file? ?
+          @model.new :
+          Object.const_get(@model.svn_category_model).new
+      end
+      
+    end
+  end
+end

data/lib/dm-svn/svn/node.rb

@@ -0,0 +1,128 @@
+module DmSvn
+  module Svn
+
+    # A Node (file or directory) at a path and revision [Changeset].
+    # In particular, this class exists to determine the type (file or directory)
+    # of the node and retrieve the body of a node (for files),
+    # and other properties, either stored in yaml or a Subversion properties
+    class Node
+      
+      attr_reader :path
+      
+      def initialize(changeset, path)
+        @changeset, @path = changeset, path
+      end
+      
+      # Shortened path (from Changeset#short_path)
+      def short_path
+        @changeset.short_path(@path)
+      end
+      
+      # Shortened path (from Changeset#fs_path)
+      def fs_path
+        @changeset.fs_path(@path)
+      end
+      
+      # Body of the node (nil for a directory)
+      def body
+        return nil unless file?
+        has_yaml_props? ?
+          yaml_split[1] :
+          data[0]
+      end
+      
+      # Properties of the node. The properties are accessed from three sources,
+      # listed by order of precedence:
+      # 1. YAML properties, either in meta.yml (directories), or at the
+      #    beginning of a file, between "---" and "..." lines.
+      # 2. Properties stored in subversion's property mechanism.
+      # 3. svn_updated_[rev|at|by] as determined by revision properties.
+      def properties
+        rev_properties.merge(svn_properties).merge(yaml_properties)
+      end
+      
+      # Is the Node a file?
+      def file?
+        repos.stat(fs_path, revision).file?
+      end
+    
+      # Is the Node a directory?
+      def directory?
+        repos.stat(fs_path, revision).directory?
+      end
+      
+      # Methods derived from Changeset instance variables.
+      %w{revision author repos date config}.each do |f|
+        define_method(f) do
+          @changeset.__send__(f)
+        end
+      end
+    
+      private
+      
+      # Get data as array of body, properties
+      def data
+        @data ||= file? ?
+          repos.file(fs_path, revision) :
+          repos.dir(fs_path, revision)
+      end
+      
+      # Properties based on the revision information: svn_updated_[rev|at|by]
+      # as a hash
+      def rev_properties
+        {
+          'svn_updated_at' => @changeset.date,
+          'svn_updated_by' => @changeset.author,
+          'svn_updated_rev' => @changeset.revision
+        }
+      end
+    
+      # Get properties stored as subversion properties, that begin with the
+      # Config#property_prefix.
+      def svn_properties
+        props = {}
+        data[1].each do |name, val|
+          if name =~ /\A#{config.property_prefix}(.*)/
+            props[$1] = val
+          end
+        end
+        props
+      end
+    
+      # Get YAML properties. For a directory, these are stored in meta.yml,
+      # for a file, they are stored at the beginning of the file: the first line
+      # will be "---" and the YAML will end before a line containing "..."
+      def yaml_properties
+        if directory?
+          fs_yaml_path = fs_path.blank? ? 'meta.yml' : File.join(fs_path, 'meta.yml')
+          yaml_path = File.join(@path, 'meta.yml')
+          repos.stat(fs_yaml_path, revision) ?
+            YAML.load(self.class.new(@changeset, yaml_path).body) :
+            {}
+        else
+          has_yaml_props? ?
+            YAML.load(yaml_split[0]) :
+            {}
+        end
+      end
+      
+      # Determine if file has yaml properties, by checking if the file starts
+      # with three leading dashes
+      def has_yaml_props?
+        file? && data[0][0..2] == "---"
+      end
+      
+      # Split a file between properties and body at a line with three dots.
+      # Left trim the body and there may have been blank lines added for
+      # clarity.
+      def yaml_split
+        data[0].gsub!("\r", "")
+        ary = data[0].split("\n...\n")
+        ary[1] = ary[1].lstrip
+        ary
+      end
+
+    end
+  end
+end
+   

data/lib/dm-svn/svn/sync.rb

@@ -0,0 +1,85 @@
+module DmSvn
+  module Svn
+    class Sync
+      
+      attr_reader :model, :config, :repos
+
+      def initialize(model_row)
+        @model_row = model_row
+        @model = Object.const_get(@model_row.name)
+        @config = @model_row.config
+      end
+      
+      # Get changesets
+      def changesets
+        sets = []
+        
+        @repos.log('', @model_row.revision, @repos.latest_revnum, 0, true, false
+            ) do |changes, rev, author, date, msg|
+          sets << Changeset.new(changes, rev, author, date, self)
+        end
+        
+        sets.sort
+      end
+      
+      # There is the possibility for uneccessary updates, as a database row may be
+      # modified several times (if modified in multiple revisions) in a single
+      # call. This is inefficient, but--for now--not enough to justify more
+      # complex code.
+      def run
+        connect(@config.uri)
+        return false if @repos.latest_revnum <= @model_row.revision
+        
+        changesets.each do |c| # Sorted by revision, ascending
+          c.process
+          # Update model_row.revision
+          row_update = @model_row.class.get(@model_row.id)
+          row_update.update_attributes(:revision => c.revision)
+        end
+        
+        # Ensure that @model_row.revision is now set to the latest (even if there
+        # weren't applicable changes in the latest revision).
+        row_update = @model_row.class.get(@model_row.id)
+        row_update.update_attributes(:revision => @repos.latest_revnum)
+        return true
+      end
+      
+      private
+      
+      def connect(uri)
+        @ctx = context(uri)
+       
+        # This will raise some error if connection fails for whatever reason.
+        # I don't currently see a reason to handle connection errors here, as I
+        # assume the best handling would be to raise another error.
+        @repos = ::Svn::Ra::Session.open(uri, {}, callbacks)
+        @config.path_from_root = @config.uri[(@repos.repos_root.length)..-1]
+        return true
+      end
+  
+      def context(uri)
+        # Client::Context, which paticularly holds an auth_baton.
+        ctx = ::Svn::Client::Context.new
+        if @config.username && @config.password
+          # TODO: What if another provider type is needed? Is this plausible?
+          ctx.add_simple_prompt_provider(0) do |cred, realm, username, may_save|
+            cred.username = @config.username
+            cred.password = @config.password
+          end
+        elsif URI.parse(uri).scheme == "file" 
+          ctx.add_username_prompt_provider(0) do |cred, realm, username, may_save|
+            cred.username = @config.username || "ANON"
+          end
+        else
+          ctx.auth_baton = ::Svn::Core::AuthBaton.new()
+        end
+        ctx
+      end
+    
+      # callbacks for Svn::Ra::Session.open. This includes the client +context+.
+      def callbacks
+        ::Svn::Ra::Callbacks.new(@ctx.auth_baton)
+      end
+    end
+  end
+end