jro_apps/redmine Commit - r570:ba1b857197ab

Added Darcs basic support....

Jean-Philippe Lang -

r570:ba1b857197ab

parent child

Context file:

r570:ba1b857197ab

Collapse all files

app/models/repository/darcs.rb created 644 +90 0

@@ -0,0 +1,90
	1	# redMine - project management software
	2	# Copyright (C) 2006-2007 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require 'redmine/scm/adapters/darcs_adapter'
	19
	20	class Repository::Darcs < Repository
	21	validates_presence_of :url
	22
	23	def scm_adapter
	24	Redmine::Scm::Adapters::DarcsAdapter
	25	end
	26
	27	def self.scm_name
	28	'Darcs'
	29	end
	30
	31	def entries(path=nil, identifier=nil)
	32	entries=scm.entries(path, identifier)
	33	if entries
	34	entries.each do \|entry\|
	35	# Search the DB for the entry's last change
	36	changeset = changesets.find_by_scmid(entry.lastrev.scmid) if entry.lastrev && !entry.lastrev.scmid.blank?
	37	if changeset
	38	entry.lastrev.identifier = changeset.revision
	39	entry.lastrev.name = changeset.revision
	40	entry.lastrev.time = changeset.committed_on
	41	entry.lastrev.author = changeset.committer
	42	end
	43	end
	44	end
	45	entries
	46	end
	47
	48	def diff(path, rev, rev_to, type)
	49	patch_from = changesets.find_by_revision(rev)
	50	patch_to = changesets.find_by_revision(rev_to) if rev_to
	51	if path.blank?
	52	path = patch_from.changes.collect{\|change\| change.path}.join(' ')
	53	end
	54	scm.diff(path, patch_from.scmid, patch_to.scmid, type)
	55	end
	56
	57	def fetch_changesets
	58	scm_info = scm.info
	59	if scm_info
	60	db_last_id = latest_changeset ? latest_changeset.scmid : nil
	61	next_rev = latest_changeset ? latest_changeset.revision + 1 : 1
	62	# latest revision in the repository
	63	scm_revision = scm_info.lastrev.scmid
	64	unless changesets.find_by_scmid(scm_revision)
	65	revisions = scm.revisions('', db_last_id, nil, :with_path => true)
	66	transaction do
	67	revisions.reverse_each do \|revision\|
	68	changeset = Changeset.create(:repository => self,
	69	:revision => next_rev,
	70	:scmid => revision.scmid,
	71	:committer => revision.author,
	72	:committed_on => revision.time,
	73	:comments => revision.message)
	74
	75	next if changeset.new_record?
	76
	77	revision.paths.each do \|change\|
	78	Change.create(:changeset => changeset,
	79	:action => change[:action],
	80	:path => change[:path],
	81	:from_path => change[:from_path],
	82	:from_revision => change[:from_revision])
	83	end
	84	next_rev += 1
	85	end if revisions
	86	end
	87	end
	88	end
	89	end
	90	end

lib/redmine/scm/adapters/darcs_adapter.rb created 644 +163 0

@@ -0,0 +1,163
	1	# redMine - project management software
	2	# Copyright (C) 2006-2007 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require 'redmine/scm/adapters/abstract_adapter'
	19	require 'rexml/document'
	20
	21	module Redmine
	22	module Scm
	23	module Adapters
	24	class DarcsAdapter < AbstractAdapter
	25	# Darcs executable name
	26	DARCS_BIN = "darcs"
	27
	28	def initialize(url, root_url=nil, login=nil, password=nil)
	29	@url = url
	30	@root_url = url
	31	end
	32
	33	def supports_cat?
	34	false
	35	end
	36
	37	# Get info about the svn repository
	38	def info
	39	rev = revisions(nil,nil,nil,{:limit => 1})
	40	rev ? Info.new({:root_url => @url, :lastrev => rev.last}) : nil
	41	end
	42
	43	# Returns the entry identified by path and revision identifier
	44	# or nil if entry doesn't exist in the repository
	45	def entry(path=nil, identifier=nil)
	46	e = entries(path, identifier)
	47	e ? e.first : nil
	48	end
	49
	50	# Returns an Entries collection
	51	# or nil if the given path doesn't exist in the repository
	52	def entries(path=nil, identifier=nil)
	53	path_prefix = (path.blank? ? '' : "#{path}/")
	54	path = '.' if path.blank?
	55	entries = Entries.new
	56	cmd = "#{DARCS_BIN} annotate --repodir #{@url} --xml-output #{path}"
	57	shellout(cmd) do \|io\|
	58	begin
	59	doc = REXML::Document.new(io)
	60	if doc.root.name == 'directory'
	61	doc.elements.each('directory/*') do \|element\|
	62	next unless ['file', 'directory'].include? element.name
	63	entries << entry_from_xml(element, path_prefix)
	64	end
	65	elsif doc.root.name == 'file'
	66	entries << entry_from_xml(doc.root, path_prefix)
	67	end
	68	rescue
	69	end
	70	end
	71	return nil if $? && $?.exitstatus != 0
	72	entries.sort_by_name
	73	rescue Errno::ENOENT => e
	74	raise CommandFailed
	75	end
	76
	77	def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
	78	path = '.' if path.blank?
	79	revisions = Revisions.new
	80	cmd = "#{DARCS_BIN} changes --repodir #{@url} --xml-output"
	81	cmd << " --from-match \"hash #{identifier_from}\"" if identifier_from
	82	cmd << " --last #{options[:limit].to_i}" if options[:limit]
	83	shellout(cmd) do \|io\|
	84	begin
	85	doc = REXML::Document.new(io)
	86	doc.elements.each("changelog/patch") do \|patch\|
	87	message = patch.elements['name'].text
	88	message << "\n" + patch.elements['comment'].text.gsub(/\\\END OF DESCRIPTION\\\.*\z/m, '') if patch.elements['comment']
	89	revisions << Revision.new({:identifier => nil,
	90	:author => patch.attributes['author'],
	91	:scmid => patch.attributes['hash'],
	92	:time => Time.parse(patch.attributes['local_date']),
	93	:message => message,
	94	:paths => (options[:with_path] ? get_paths_for_patch(patch.attributes['hash']) : nil)
	95	})
	96	end
	97	rescue
	98	end
	99	end
	100	return nil if $? && $?.exitstatus != 0
	101	revisions
	102	rescue Errno::ENOENT => e
	103	raise CommandFailed
	104	end
	105
	106	def diff(path, identifier_from, identifier_to=nil, type="inline")
	107	path = '*' if path.blank?
	108	cmd = "#{DARCS_BIN} diff --repodir #{@url}"
	109	cmd << " --to-match \"hash #{identifier_from}\""
	110	cmd << " --from-match \"hash #{identifier_to}\"" if identifier_to
	111	cmd << " -u #{path}"
	112	diff = []
	113	shellout(cmd) do \|io\|
	114	io.each_line do \|line\|
	115	diff << line
	116	end
	117	end
	118	return nil if $? && $?.exitstatus != 0
	119	DiffTableList.new diff, type
	120	rescue Errno::ENOENT => e
	121	raise CommandFailed
	122	end
	123
	124	private
	125
	126	def entry_from_xml(element, path_prefix)
	127	Entry.new({:name => element.attributes['name'],
	128	:path => path_prefix + element.attributes['name'],
	129	:kind => element.name == 'file' ? 'file' : 'dir',
	130	:size => nil,
	131	:lastrev => Revision.new({
	132	:identifier => nil,
	133	:scmid => element.elements['modified'].elements['patch'].attributes['hash']
	134	})
	135	})
	136	end
	137
	138	# Retrieve changed paths for a single patch
	139	def get_paths_for_patch(hash)
	140	cmd = "#{DARCS_BIN} annotate --repodir #{@url} --summary --xml-output"
	141	cmd << " --match \"hash #{hash}\" "
	142	paths = []
	143	shellout(cmd) do \|io\|
	144	begin
	145	# Darcs xml output has multiple root elements in this case (tested with darcs 1.0.7)
	146	# A root element is added so that REXML doesn't raise an error
	147	doc = REXML::Document.new("<fake_root>" + io.read + "</fake_root>")
	148	doc.elements.each('fake_root/summary/*') do \|modif\|
	149	paths << {:action => modif.name[0,1].upcase,
	150	:path => "/" + modif.text.chomp.gsub(/^\s*/, '')
	151	}
	152	end
	153	rescue
	154	end
	155	end
	156	paths
	157	rescue Errno::ENOENT => e
	158	paths
	159	end
	160	end
	161	end
	162	end
	163	end

app/helpers/repositories_helper.rb +4 0

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module RepositoriesHelper
               def repository_field_tags(form, repository)
                 method = repository.class.name.demodulize.underscore + "_field_tags"
                 send(method, form, repository) if repository.is_a?(Repository) && respond_to?(method)
               end
               def scm_select_tag
                 container = [[]]
                 REDMINE_SUPPORTED_SCM.each {|scm| container << ["Repository::#{scm}".constantize.scm_name, scm]}
                 select_tag('repository_scm',
                            options_for_select(container, @project.repository.class.name.demodulize),
                            :disabled => (@project.repository && !@project.repository.new_record?),
                            :onchange => remote_function(:update => "repository_fields", :url => { :controller => 'repositories', :action => 'update_form', :id => @project }, :with => "Form.serialize(this.form)")
                            )
               end
               def with_leading_slash(path)
                 path ||= ''
                 path.starts_with?("/") ? "/#{path}" : path
               end
               def subversion_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)) +
                                    '<br />(http://, https://, svn://, file:///)') +
                   content_tag('p', form.text_field(:login, :size => 30)) +
                   content_tag('p', form.password_field(:password, :size => 30))
               end
+              def darcs_field_tags(form, repository)
+                  content_tag('p', form.text_field(:url, :label => 'Root directory', :size => 60, :required => true, :disabled => (repository && !repository.new_record?)))
+              end
               def mercurial_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :label => 'Root directory', :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)))
               end
               def cvs_field_tags(form, repository)
                   content_tag('p', form.text_field(:root_url, :label => 'CVSROOT', :size => 60, :required => true, :disabled => !repository.new_record?)) +
                   content_tag('p', form.text_field(:url, :label => 'Module', :size => 30, :required => true, :disabled => !repository.new_record?))
               end
             end

app/models/changeset.rb +1 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Changeset < ActiveRecord::Base
               belongs_to :repository
               has_many :changes, :dependent => :delete_all
               has_and_belongs_to_many :issues
               validates_presence_of :repository_id, :revision, :committed_on, :commit_date
               validates_numericality_of :revision, :only_integer => true
               validates_uniqueness_of :revision, :scope => :repository_id
+              validates_uniqueness_of :scmid, :scope => :repository_id, :allow_nil => true
               def committed_on=(date)
                 self.commit_date = date
                 super
               end
               def after_create
                 scan_comment_for_issue_ids
               end
               def scan_comment_for_issue_ids
                 return if comments.blank?
                 # keywords used to reference issues
                 ref_keywords = Setting.commit_ref_keywords.downcase.split(",")
                 # keywords used to fix issues
                 fix_keywords = Setting.commit_fix_keywords.downcase.split(",")
                 # status applied
                 fix_status = IssueStatus.find_by_id(Setting.commit_fix_status_id)
                 kw_regexp = (ref_keywords + fix_keywords).collect{|kw| Regexp.escape(kw.strip)}.join("|")
                 return if kw_regexp.blank?
                 # remove any associated issues
                 self.issues.clear
                 comments.scan(Regexp.new("(#{kw_regexp})[\s:]+(([\s,;&]*#?\\d+)+)", Regexp::IGNORECASE)).each do |match|
                   action = match[0]
                   target_issue_ids = match[1].scan(/\d+/)
                   target_issues = repository.project.issues.find_all_by_id(target_issue_ids)
                   if fix_status && fix_keywords.include?(action.downcase)
                     # update status of issues
                     logger.debug "Issues fixed by changeset #{self.revision}: #{issue_ids.join(', ')}." if logger && logger.debug?
                     target_issues.each do |issue|
                       # don't change the status is the issue is already closed
                       next if issue.status.is_closed?
                       issue.status = fix_status
                       issue.save
                     end
                   end
                   self.issues << target_issues
                 end
               end
             end

app/models/repository.rb +4 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Repository < ActiveRecord::Base
               belongs_to :project
               has_many :changesets, :dependent => :destroy, :order => "#{Changeset.table_name}.revision DESC"
               has_many :changes, :through => :changesets
               def scm
                 @scm ||= self.scm_adapter.new url, root_url, login, password
                 update_attribute(:root_url, @scm.root_url) if root_url.blank?
                 @scm
               end
               def scm_name
                 self.class.scm_name
               end
+              def supports_cat?
+                scm.supports_cat?
+              end
               def entries(path=nil, identifier=nil)
                 scm.entries(path, identifier)
               end
               def diff(path, rev, rev_to, type)
                 scm.diff(path, rev, rev_to, type)
               end
               def latest_changeset
                 @latest_changeset ||= changesets.find(:first)
               end
               def scan_changesets_for_issue_ids
                 self.changesets.each(&:scan_comment_for_issue_ids)
               end
               # fetch new changesets for all repositories
               # can be called periodically by an external script
               # eg. ruby script/runner "Repository.fetch_changesets"
               def self.fetch_changesets
                 find(:all).each(&:fetch_changesets)
               end
               # scan changeset comments to find related and fixed issues for all repositories
               def self.scan_changesets_for_issue_ids
                 find(:all).each(&:scan_changesets_for_issue_ids)
               end
               def self.scm_name
                 'Abstract'
               end
               def self.available_scm
                 subclasses.collect {|klass| [klass.scm_name, klass.name]}
               end
               def self.factory(klass_name, *args)
                 klass = "Repository::#{klass_name}".constantize
                 klass.new(*args)
               rescue
                 nil
               end
             end

app/views/repositories/changes.rhtml +2 0

             <h2><%= render :partial => 'navigation', :locals => { :path => @path, :kind => (@entry ? @entry.kind : nil), :revision => @rev } %></h2>
             <h3><%=h @entry.name %></h3>
+            <% if @repository.supports_cat? %>
             <p>
             <% if @entry.is_text? %>
             <%= link_to l(:button_view), {:action => 'entry', :id => @project, :path => @path, :rev => @rev } %> |
             <% end %>
             <%= link_to l(:button_download), {:action => 'entry', :id => @project, :path => @path, :rev => @rev, :format => 'raw' } %>
             <%= "(#{number_to_human_size(@entry.size)})" if @entry.size %>
             </p>
+            <% end %>
             <%= render :partial => 'revisions', :locals => {:project => @project, :path => @path, :revisions => @changes, :entry => @entry }%>

lib/redmine.rb +1 -1

             require 'redmine/version'
             require 'redmine/mime_type'
             require 'redmine/acts_as_watchable/init'
-            REDMINE_SUPPORTED_SCM = %w( Subversion Mercurial Cvs )
+            REDMINE_SUPPORTED_SCM = %w( Subversion Darcs Mercurial Cvs )

lib/redmine/scm/adapters/abstract_adapter.rb +6 -2

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'cgi'
             module Redmine
               module Scm
                 module Adapters
                   class CommandFailed < StandardError #:nodoc:
                   end
                   class AbstractAdapter #:nodoc:
                     def initialize(url, root_url=nil, login=nil, password=nil)
                       @url = url
                       @login = login if login && !login.empty?
                       @password = (password || "") if @login
                       @root_url = root_url.blank? ? retrieve_root_url : root_url
                     end
                     def adapter_name
                       'Abstract'
                     end
+                    def supports_cat?
+                      true
+                    end
                     def root_url
                       @root_url
                     end
                     def url
                       @url
                     end
                     # get info about the svn repository
                     def info
                       return nil
                     end
                     # Returns the entry identified by path and revision identifier
                     # or nil if entry doesn't exist in the repository
                     def entry(path=nil, identifier=nil)
                       e = entries(path, identifier)
                       e ? e.first : nil
                     end
                     # Returns an Entries collection
                     # or nil if the given path doesn't exist in the repository
                     def entries(path=nil, identifier=nil)
                       return nil
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       return nil
                     end
                     def diff(path, identifier_from, identifier_to=nil, type="inline")
                       return nil
                     end
                     def cat(path, identifier=nil)
                       return nil
                     end
                     def with_leading_slash(path)
                       path ||= ''
                       (path[0,1]!="/") ? "/#{path}" : path
                     end
                   private
                     def retrieve_root_url
                       info = self.info
                       info ? info.root_url : nil
                     end
                     def target(path)
                       path ||= ""
                       base = path.match(/^\//) ? root_url : url
                       " \"" << "#{base}/#{path}".gsub(/["?<>\*]/, '') << "\""
                     end
                     def logger
                       RAILS_DEFAULT_LOGGER
                     end
                     def shellout(cmd, &block)
                       logger.debug "Shelling out: #{cmd}" if logger && logger.debug?
                       IO.popen(cmd, "r+") do |io|
                         io.close_write
                         block.call(io) if block_given?
                       end
                     end
                   end
                   class Entries < Array
                     def sort_by_name
                       sort {|x,y|
                         if x.kind == y.kind
                           x.name <=> y.name
                         else
                           x.kind <=> y.kind
                         end
                       }
                     end
                     def revisions
                       revisions ||= Revisions.new(collect{|entry| entry.lastrev}.compact)
                     end
                   end
                   class Info
                     attr_accessor :root_url, :lastrev
                     def initialize(attributes={})
                       self.root_url = attributes[:root_url] if attributes[:root_url]
                       self.lastrev = attributes[:lastrev]
                     end
                   end
                   class Entry
                     attr_accessor :name, :path, :kind, :size, :lastrev
                     def initialize(attributes={})
                       self.name = attributes[:name] if attributes[:name]
                       self.path = attributes[:path] if attributes[:path]
                       self.kind = attributes[:kind] if attributes[:kind]
                       self.size = attributes[:size].to_i if attributes[:size]
                       self.lastrev = attributes[:lastrev]
                     end
                     def is_file?
                       'file' == self.kind
                     end
                     def is_dir?
                       'dir' == self.kind
                     end
                     def is_text?
                       Redmine::MimeType.is_type?('text', name)
                     end
                   end
                   class Revisions < Array
                     def latest
                       sort {|x,y|
                         unless x.time.nil? or y.time.nil?
                           x.time <=> y.time
                         else
                         end
                       }.last
                     end
                   end
                   class Revision
                     attr_accessor :identifier, :scmid, :name, :author, :time, :message, :paths, :revision, :branch
                     def initialize(attributes={})
                       self.identifier = attributes[:identifier]
                       self.scmid = attributes[:scmid]
                       self.name = attributes[:name] || self.identifier
                       self.author = attributes[:author]
                       self.time = attributes[:time]
                       self.message = attributes[:message] || ""
                       self.paths = attributes[:paths]
                       self.revision = attributes[:revision]
                       self.branch = attributes[:branch]
                     end
                   end
                   # A line of Diff
                   class Diff
                     attr_accessor :nb_line_left
                     attr_accessor :line_left
                     attr_accessor :nb_line_right
                     attr_accessor :line_right
                     attr_accessor :type_diff_right
                     attr_accessor :type_diff_left
                     def initialize ()
                       self.nb_line_left = ''
                       self.nb_line_right = ''
                       self.line_left = ''
                       self.line_right = ''
                       self.type_diff_right = ''
                       self.type_diff_left = ''
                     end
                     def inspect
                       puts '### Start Line Diff ###'
                       puts self.nb_line_left
                       puts self.line_left
                       puts self.nb_line_right
                       puts self.line_right
                     end
                   end
                   class DiffTableList < Array
                     def initialize (diff, type="inline")
                         diff_table = DiffTable.new type
                         diff.each do |line|
-                            if line =~ /^(Index:|diff) (.*)$/
+                            if line =~ /^(---|\+\+\+) (.*)$/
                                 self << diff_table if diff_table.length > 1
                                 diff_table = DiffTable.new type
                             end
                             a = diff_table.add_line line
                         end
                         self << diff_table
                     end
                   end
                   # Class for create a Diff
                   class DiffTable < Hash
                     attr_reader :file_name, :line_num_l, :line_num_r
                     # Initialize with a Diff file and the type of Diff View
                     # The type view must be inline or sbs (side_by_side)
                     def initialize (type="inline")
                       @parsing = false
                       @nb_line = 1
                       @start = false
                       @before = 'same'
                       @second = true
                       @type = type
                     end
                     # Function for add a line of this Diff
                     def add_line(line)
                       unless @parsing
-                        if line =~ /^(Index:|diff) (.*)$/
+                        if line =~ /^(---|\+\+\+) (.*)$/
                           @file_name = $2
                           return false
                         elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                           @line_num_l = $5.to_i
                           @line_num_r = $2.to_i
                           @parsing = true
                         end
                       else
                         if line =~ /^[^\+\-\s@\\]/
                           self.delete(self.keys.sort.last)
                           @parsing = false
                           return false
                         elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                           @line_num_l = $5.to_i
                           @line_num_r = $2.to_i
                         else
                           @nb_line += 1 if parse_line(line, @type)
                         end
                       end
                       return true
                     end
                     def inspect
                       puts '### DIFF TABLE ###'
                       puts "file : #{file_name}"
                       self.each do |d|
                         d.inspect
                       end
                     end
                   private
                     # Test if is a Side By Side type
                     def sbs?(type, func)
                       if @start and type == "sbs"
                         if @before == func and @second
                           tmp_nb_line = @nb_line
                           self[tmp_nb_line] = Diff.new
                         else
                             @second = false
                             tmp_nb_line = @start
                             @start += 1
                             @nb_line -= 1
                         end
                       else
                         tmp_nb_line = @nb_line
                         @start = @nb_line
                         self[tmp_nb_line] = Diff.new
                         @second = true
                       end
                       unless self[tmp_nb_line]
                         @nb_line += 1
                         self[tmp_nb_line] = Diff.new
                       else
                         self[tmp_nb_line]
                       end
                     end
                     # Escape the HTML for the diff
                     def escapeHTML(line)
                         CGI.escapeHTML(line).gsub(/\s/, '&nbsp;')
                     end
                     def parse_line (line, type="inline")
                       if line[0, 1] == "+"
                         diff = sbs? type, 'add'
                         @before = 'add'
                         diff.line_left = escapeHTML line[1..-1]
                         diff.nb_line_left = @line_num_l
                         diff.type_diff_left = 'diff_in'
                         @line_num_l += 1
                         true
                       elsif line[0, 1] == "-"
                         diff = sbs? type, 'remove'
                         @before = 'remove'
                         diff.line_right = escapeHTML line[1..-1]
                         diff.nb_line_right = @line_num_r
                         diff.type_diff_right = 'diff_out'
                         @line_num_r += 1
                         true
                       elsif line[0, 1] =~ /\s/
                         @before = 'same'
                         @start = false
                         diff = Diff.new
                         diff.line_right = escapeHTML line[1..-1]
                         diff.nb_line_right = @line_num_r
                         diff.line_left = escapeHTML line[1..-1]
                         diff.nb_line_left = @line_num_l
                         self[@nb_line] = diff
                         @line_num_l += 1
                         @line_num_r += 1
                         true
                       elsif line[0, 1] = "\\"
                         true
                       else
                         false
                       end
                     end
                   end
                 end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages