hallettj-cloudrcs 0.0.1

data/lib/cloud_rcs/patch_types/move.rb

@@ -0,0 +1,89 @@
+module CloudRCS
+
+  # A primitive patch type that represents that a file has been moved
+  # or renamed.
+  class Move < PrimitivePatch
+    validates_presence_of :path, :original_path
+
+    def after_initialize
+      verify_path_prefix
+      verify_original_path_prefix
+    end
+
+    def to_s
+      "move #{self.class.escape_path(original_path)} #{self.class.escape_path(path)}"
+    end
+
+    # The inverse patch moves the file back to its original location.
+    def inverse
+      Move.new(:original_path => path, :path => original_path)
+    end
+
+    def commute(patch)
+      if patch.is_a? Move
+        if patch.original_path == self.new_path
+          raise CommuteException(true, "Conflict: cannot commute move patches that affect the same file.")
+        elsif patch.new_path == self.original_path
+          raise CommuteException(true, "Conflict: commuting these move patches would result in two files with the same name.")
+          
+        elsif patch.new_path == self.new_path
+          raise CommuteException(true, "Conflict: cannot commute move patches that affect the same files.")
+
+        else
+          patch1 = Move.new(:path => patch.path, :original_path => patch.original_path)
+          patch2 = Move.new(:path => self.path, :original_path => self.original_path)
+        end
+
+      elsif patch.is_a? Addfile and patch.path == self.original_path
+        raise CommuteException(true, "Conflict: move and addfile are order-dependent in this case.")
+
+      elsif patch.is_a? Rmfile and patch.path == self.new_path
+        raise CommuteException(true, "Conflict: move and rmfile are order-dependent in this case.")
+
+      # If the other patch is something like a Hunk or a Binary, and
+      # it operates on the file path that this patch moves a file to,
+      # then the commuted version of that patch should have a file
+      # path that matches the original_path of this patch.
+      elsif patch.path == self.new_path
+        patch1 = patch.clone
+        patch1.path = self.original_path
+        patch2 = self.clone
+
+      else
+        patch1 = patch.clone
+        patch2 = self.clone
+      end
+
+      return patch1, patch2
+    end
+
+    def apply_to(file)
+      if file.path == original_path
+        file.path = new_path
+      end
+      return file
+    end
+
+    class << self
+
+      def generate(orig_file, changed_file)
+        return if orig_file.nil? or changed_file.nil?
+        if orig_file.path != changed_file.path
+          return Move.new(:original_path => orig_file.path, :path => changed_file.path)
+        end
+      end
+
+      def parse(contents)
+        unless contents =~ /^move\s+(\S+)\s+(\S+)\s*$/
+          raise "Failed to parse move patch: \"#{contents}\""
+        end
+        Move.new(:original_path => unescape_path($1), :path => unescape_path($2))
+      end
+
+    end
+
+  end
+
+  PATCH_TYPES << Move
+
+end

data/lib/cloud_rcs/patch_types/rmfile.rb

@@ -0,0 +1,63 @@
+module CloudRCS
+
+  # A primitive patch type that represents the deletion of a file.
+  class Rmfile < PrimitivePatch
+    validates_presence_of :path
+    
+    def after_initialize
+      verify_path_prefix
+    end
+    
+    def to_s
+      "rmfile #{self.class.escape_path(path)}"
+    end
+
+    def inverse
+      Addfile.new(:path => path)
+    end
+
+    def commute(patch)
+      if patch.is_a? Rmfile and patch.path == self.path
+        raise CommuteException(true, "Conflict: cannot remove the same file twice.")
+      elsif patch.is_a? Addfile and patch.path == self.path
+        raise CommuteException(true, "Conflict: commuting rmfile and addfile yields two files with the same name.")
+      elsif patch.is_a? Move and patch.path == self.path
+        raise CommuteException(true, "Conflict: commuting rmfile and move yields two files with the same name.")
+      else
+        patch1 = patch.clone
+        patch2 = self.clone
+      end
+      return patch1, patch2
+    end
+
+    def apply_to(file)
+      return file unless file and file.path == path
+      return nil  # Returning nil simulates deletion.
+    end
+
+    class << self
+
+      def priority
+        90
+      end
+
+      def generate(orig_file, changed_file)
+        if changed_file.nil? and not orig_file.nil?
+          return Rmfile.new(:path => orig_file.path)
+        end
+      end
+
+      def parse(contents)
+        unless contents =~ /^rmfile\s+(\S+)\s*$/
+          raise "Failed to parse rmfile patch: #{contents}"
+        end
+        Rmfile.new(:path => unescape_path($1))
+      end
+
+    end
+
+  end
+
+  PATCH_TYPES << Rmfile
+
+end

data/lib/cloud_rcs/primitive_patch.rb

@@ -0,0 +1,147 @@
+module CloudRCS
+
+  # PrimitivePatch acts as an intermediary between Patch and the
+  # primitive patch types. It allows primitive patches to inherit
+  # methods from Patch, and to use the same table. But it also allows
+  # for defining behavior that differs from Patch but that is
+  # automatically inherited by all primitive patch types.
+
+  class PrimitivePatch < ActiveRecord::Base
+    PATH_PREFIX = "./"
+
+    # Primitive patches belong to a named patch and a file. They also
+    # use the acts_as_list plugin to maintain a specific order within
+    # the named patch.
+    belongs_to :patch
+#    belongs_to :file, :polymorphic => true
+    
+    #  validates_presence_of :patch_id
+    #  validates_presence_of :file_id
+    
+    acts_as_list :column => :rank, :scope => :patch_id
+
+    def apply!
+      target_file = locate_file(original_path || path)
+      old_target = target_file
+      target_file = apply_to(target_file)
+      if target_file.nil?
+        old_target.destroy
+      else
+        target_file.save
+      end
+#      update_attribute(:file, target_file)
+      return target_file
+    end
+
+    def named_patch?; false; end
+    def primitive_patch?; true; end
+
+#    def locate_file(path)
+#      raise "You must override the locate_file method for PrimitivePatch."
+#      self.class.file_class.locate(path)
+#    end
+
+    def apply_to(file)
+      override "apply_to(file)"
+    end
+
+    def inverse
+      override "inverse"
+    end
+
+    def commute(patch)
+      override "commute(patch)"
+    end
+
+    def to_s
+      override "to_s"
+    end
+
+    def to_a
+      [self]
+    end
+
+    def new_path; path; end
+
+    protected
+
+    # Most primitive patches contain a file path. The darcs patch format
+    # may require a different path prefix than CloudFiles do; so this
+    # method makes the conversion if required.
+    def verify_path_prefix
+      unless path =~ /^#{PATH_PREFIX}/
+          path = PATH_PREFIX + path unless path.blank?
+      end
+    end
+    def verify_original_path_prefix
+      unless original_path =~ /^#{PATH_PREFIX}/
+          original_path = PATH_PREFIX + original_path unless original_path.blank?
+      end
+    end
+
+    private
+
+    def override(method)
+      raise "Method '#{method}' should be overridden by each patch type."
+    end
+
+    class << self
+
+      # Patch type priority represents the relative likelihood that a
+      # patch type will cause conflicts if it is applied before other
+      # patch types. Patch types with a high priority value are likely
+      # to cause conflicts if they are applied early, and so should be
+      # deferred until after other patch types have done their thing.
+      #
+      # Default priority is 50.
+      def priority
+        return 50
+      end
+
+      def generate(orig_file, changed_file)
+        override "generate"
+      end
+
+      def parse(contents)
+        override "parse"
+      end
+
+      def merge(patch_a, patch_b)
+        patch_b_prime = commute(patch_a.inverse, patch_b).first
+        return patch_a, patch_b_prime
+      end
+      
+      # Returns class of :file association. Won't work with polymorphism.
+#      def file_class
+#        reflect_on_association(:file).class_name.constantize
+#      end
+
+      # Replace special charecters in file paths with ASCII codes
+      # bounded by backslashes.
+      def escape_path(path)
+        # The backslash will be re-interpolated by the regular
+        # expression; so four backslashes in the string definition are
+        # necessary instead of two.
+        special_chars = ['\\\\',' ']
+        path.gsub(/#{special_chars.join('|')}/) { |match| "\\#{match[0]}\\" }
+      end
+      
+      # Replace escaped characters with the original versions. Escaped
+      # characters are of the format, /\\(\d{2,3})\\/; where the digits
+      # enclosed in backslashes represent the ASCII code of the original
+      # character.
+      def unescape_path(path)
+        path.gsub(/\\(\d{2,3})\\/) { $1.to_i.chr }
+      end
+      
+      private
+      
+      def override(method)
+        raise "Class method '#{method}' should be overridden by each patch type."
+      end
+
+    end
+
+  end
+
+end

data/lib/cloudrcs.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+gem 'activerecord', '>= 2.0'
+gem 'diff-lcs', '>= 1.1'
+
+require 'activerecord'
+require 'diff/lcs'
+
+require 'acts_as_list'
+require 'digest/sha1'
+require 'cloud_rcs'

data/lib/cloudrcs/version.rb

@@ -0,0 +1,9 @@
+module Cloudrcs #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/cloudrcs.rb'}"
+puts "Loading cloudrcs gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+GEM_NAME = 'cloudrcs' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'cloudrcs'
+
+require 'rubygems'
+begin
+  require 'newgem'
+  require 'rubyforge'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + "/../lib/#{GEM_NAME}/version.rb"
+
+version  = Cloudrcs::VERSION::STRING
+download = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+def rubyforge_project_id
+  RubyForge.new.autoconfig["group_ids"][RUBYFORGE_PROJECT]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)