Redmine

        @project_tree.keys.each {|p| @project_tree[p] -= [p]} 

  def to_path_param(path)

    path.to_s.split(%r{[/\\]}).select {|p| !p.blank?}

  end

      h = read_attribute(:others).dup || {}

      h.update(attr_name => value)

      write_attribute(:others, h)

      value

<span class="expander" onclick="<%=  remote_function :url => {:action => 'browse', :id => @project, :path => to_path_param(entry.path), :rev => @rev, :depth => (depth + 1), :parent_id => tr_id},

          {:action => (entry.is_dir? ? 'browse' : 'changes'), :id => @project, :path => to_path_param(entry.path), :rev => @rev},

    / <%= link_to h(dir), :action => 'browse', :id => @project, :path => to_path_param(link_path), :rev => @rev %>

    / <%= link_to h(filename), :action => 'changes', :id => @project, :path => to_path_param("#{link_path}/#{filename}"), :rev => @rev %>

<% form_tag({:controller => 'repositories', :action => 'diff', :id => @project, :path => to_path_param(path)}, :method => :get) do %>

    <%= link_to l(:button_view), {:action => 'entry', :id => @project, :path => to_path_param(@path), :rev => @rev } %> |

    <%= link_to l(:button_annotate), {:action => 'annotate', :id => @project, :path => to_path_param(@path), :rev => @rev } %> |

<%= link_to(l(:button_download), {:action => 'entry', :id => @project, :path => to_path_param(@path), :rev => @rev, :format => 'raw' }) if @repository.supports_cat? %>

<%= link_to l(:label_view_diff), :action => 'diff', :id => @project, :path => to_path_param(change.relative_path), :rev => @changeset.revision %>

# Don't change this file!

# Configure your app in config/environment.rb and config/environments/*.rb

RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)

module Rails

  class << self

    def boot!

      unless booted?

        preinitialize

        pick_boot.run

      end

    end

    def booted?

      defined? Rails::Initializer

    end

    def pick_boot

      (vendor_rails? ? VendorBoot : GemBoot).new

    end

    def vendor_rails?

      File.exist?("#{RAILS_ROOT}/vendor/rails")

    end

    def preinitialize

      load(preinitializer_path) if File.exist?(preinitializer_path)

    end

    def preinitializer_path

      "#{RAILS_ROOT}/config/preinitializer.rb"

    end

  class Boot

    def run

      load_initializer

      Rails::Initializer.run(:set_load_path)

    end

  end

  class VendorBoot < Boot

    def load_initializer

      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"

      Rails::Initializer.run(:install_gem_spec_stubs)

    end

  end

  class GemBoot < Boot

    def load_initializer

      self.class.load_rubygems

      load_rails_gem

      require 'initializer'

    end

    def load_rails_gem

      if version = self.class.gem_version

        gem 'rails', version

      else

        gem 'rails'

      end

    rescue Gem::LoadError => load_error

      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)

      exit 1

    end

    class << self

      def rubygems_version

        Gem::RubyGemsVersion if defined? Gem::RubyGemsVersion

      end

      def gem_version

        if defined? RAILS_GEM_VERSION

          RAILS_GEM_VERSION

        elsif ENV.include?('RAILS_GEM_VERSION')

          ENV['RAILS_GEM_VERSION']

        else

          parse_gem_version(read_environment_rb)

        end

      end

      def load_rubygems

        require 'rubygems'

        unless rubygems_version >= '0.9.4'

          $stderr.puts %(Rails requires RubyGems >= 0.9.4 (you have #{rubygems_version}). Please `gem update --system` and try again.)

          exit 1

        end

      rescue LoadError

        $stderr.puts %(Rails requires RubyGems >= 0.9.4. Please install RubyGems and try again: http://rubygems.rubyforge.org)

        exit 1

      end

      def parse_gem_version(text)

        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/

      end

      private

        def read_environment_rb

          File.read("#{RAILS_ROOT}/config/environment.rb")

        end

    end

  end

# All that for this:

Rails.boot!

RAILS_GEM_VERSION = '2.1.0' unless defined? RAILS_GEM_VERSION

ActiveRecord::Errors.default_error_messages = {

  :inclusion => "activerecord_error_inclusion",

  :exclusion => "activerecord_error_exclusion",

  :invalid => "activerecord_error_invalid",

  :confirmation => "activerecord_error_confirmation",

  :accepted  => "activerecord_error_accepted",

  :empty => "activerecord_error_empty",

  :blank => "activerecord_error_blank",

  :too_long => "activerecord_error_too_long",

  :too_short => "activerecord_error_too_short",

  :wrong_length => "activerecord_error_wrong_length",

  :taken => "activerecord_error_taken",

  :not_a_number => "activerecord_error_not_a_number"

}

ActionView::Base.field_error_proc = Proc.new{ |html_tag, instance| "#{html_tag}" }

# Add new mime types for use in respond_to blocks:

Mime::SET << Mime::CSV unless Mime::SET.include?(Mime::CSV)

Mime::Type.register 'application/pdf', :pdf

GLoc.set_config :default_language => :en

GLoc.clear_strings

GLoc.set_kcode

GLoc.load_localized_strings

GLoc.set_config(:raise_string_not_found_errors => false)

require 'redmine'

    Enumeration.find(:all).group_by(&:opt).each do |opt, enums|

    CustomField.find(:all).group_by(&:type).each  do |t, fields|

    super

#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../config/boot'

require 'commands/dbconsole'

#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../../config/boot'

require 'commands/performance/request'

#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../../config/boot'

require 'commands/process/inspector'

    assert assigns(:project_tree).keys.include?(Project.find(1))

           :roles,

           :members,

           :enabled_modules,

    target.workflows.copy(source)

    target.workflows.copy(source)

require 'rubygems'

Gem::manage_gems

require 'rake/rdoctask'

require 'rake/packagetask'

require 'rake/gempackagetask'

require 'rake/testtask'

require 'rake/contrib/rubyforgepublisher'

PKG_NAME           = 'acts_as_versioned'

PKG_VERSION        = '0.3.1'

PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"

PROD_HOST          = "[email protected]"

RUBY_FORGE_PROJECT = 'ar-versioned'

RUBY_FORGE_USER    = 'technoweenie'

desc 'Default: run unit tests.'

task :default => :test

desc 'Test the calculations plugin.'

Rake::TestTask.new(:test) do |t|

  t.libs << 'lib'

  t.pattern = 'test/**/*_test.rb'

  t.verbose = true

end

desc 'Generate documentation for the calculations plugin.'

Rake::RDocTask.new(:rdoc) do |rdoc|

  rdoc.rdoc_dir = 'rdoc'

  rdoc.title    = "#{PKG_NAME} -- Simple versioning with active record models"

  rdoc.options << '--line-numbers --inline-source'

  rdoc.rdoc_files.include('README', 'CHANGELOG', 'RUNNING_UNIT_TESTS')

  rdoc.rdoc_files.include('lib/**/*.rb')

end

spec = Gem::Specification.new do |s|

  s.name            = PKG_NAME

  s.version         = PKG_VERSION

  s.platform        = Gem::Platform::RUBY

  s.summary         = "Simple versioning with active record models"

  s.files           = FileList["{lib,test}/**/*"].to_a + %w(README MIT-LICENSE CHANGELOG RUNNING_UNIT_TESTS)

  s.files.delete      "acts_as_versioned_plugin.sqlite.db"

  s.files.delete      "acts_as_versioned_plugin.sqlite3.db"

  s.files.delete      "test/debug.log"

  s.require_path    = 'lib'

  s.autorequire     = 'acts_as_versioned'

  s.has_rdoc        = true

  s.test_files      = Dir['test/**/*_test.rb']

  s.add_dependency    'activerecord', '>= 1.10.1'

  s.add_dependency    'activesupport', '>= 1.1.1'

  s.author          = "Rick Olson"

  s.email           = "[email protected]"

  s.homepage        = "http://techno-weenie.net"

end

Rake::GemPackageTask.new(spec) do |pkg|

  pkg.need_tar = true

end

desc "Publish the API documentation"

task :pdoc => [:rdoc] do

  Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT, RUBY_FORGE_USER).upload

end

desc 'Publish the gem and API docs'

task :publish => [:pdoc, :rubyforge_upload]

desc "Publish the release files to RubyForge."

task :rubyforge_upload => :package do

  files = %w(gem tgz).map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }

  if RUBY_FORGE_PROJECT then

    require 'net/http'

    require 'open-uri'

    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"

    project_data = open(project_uri) { |data| data.read }

    group_id = project_data[/[?&]group_id=(\d+)/, 1]

    raise "Couldn't get group id" unless group_id

    # This echos password to shell which is a bit sucky

    if ENV["RUBY_FORGE_PASSWORD"]

      password = ENV["RUBY_FORGE_PASSWORD"]

    else

      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "

      password = STDIN.gets.chomp

    end

    login_response = Net::HTTP.start("rubyforge.org", 80) do |http|

      data = [

        "login=1",

        "form_loginname=#{RUBY_FORGE_USER}",

        "form_pw=#{password}"

      ].join("&")

      http.post("/account/login.php", data)

    end

    cookie = login_response["set-cookie"]

    raise "Login failed" unless cookie

    headers = { "Cookie" => cookie }

    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"

    release_data = open(release_uri, headers) { |data| data.read }

    package_id = release_data[/[?&]package_id=(\d+)/, 1]

    raise "Couldn't get package id" unless package_id

    first_file = true

    release_id = ""

    files.each do |filename|

      basename  = File.basename(filename)

      file_ext  = File.extname(filename)

      file_data = File.open(filename, "rb") { |file| file.read }

      puts "Releasing #{basename}..."

      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|

        release_date = Time.now.strftime("%Y-%m-%d %H:%M")

        type_map = {

          ".zip"    => "3000",

          ".tgz"    => "3110",

          ".gz"     => "3110",

          ".gem"    => "1400"

        }; type_map.default = "9999"

        type = type_map[file_ext]

        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"

        query_hash = if first_file then

          {

            "group_id" => group_id,

            "package_id" => package_id,

            "release_name" => PKG_FILE_NAME,

            "release_date" => release_date,

            "type_id" => type,

            "processor_id" => "8000", # Any

            "release_notes" => "",

            "release_changes" => "",

            "preformatted" => "1",

            "submit" => "1"

          }

        else

          {

            "group_id" => group_id,

            "release_id" => release_id,

            "package_id" => package_id,

            "step2" => "1",

            "type_id" => type,

            "processor_id" => "8000", # Any

            "submit" => "Add This File"

          }

        end

        query = "?" + query_hash.map do |(name, value)|

          [name, URI.encode(value)].join("=")

        end.join("&")

        data = [

          "--" + boundary,

          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",

          "Content-Type: application/octet-stream",

          "Content-Transfer-Encoding: binary",

          "", file_data, ""

          ].join("\x0D\x0A")

        release_headers = headers.merge(

          "Content-Type" => "multipart/form-data; boundary=#{boundary}"

        )

        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"

        http.post(target + query, data, release_headers)

      end

      if first_file then

        release_id = release_response.body[/release_id=(\d+)/, 1]

        raise("Couldn't get release id") unless release_id

      end

      first_file = false

    end

  end

    # versioned table ready and that your model has a version field.  This works with optimistic locking if the lock_version

    #   page.versions.earliest # efficient query to find the first version

    #   page.versions.latest   # efficient query to find the most recently created version

    #

    #

    # Simple Queries to page between versions

    #

    #   page.versions.before(version) 

    #   page.versions.after(version)

    #

    # Access the previous/next versions from the versioned model itself

    #

    #   version = page.versions.latest

    #   version.previous # go back one version

    #   version.next     # go forward one version

    #

      CALLBACKS = [:set_new_version, :save_version_on_create, :save_version?, :clear_altered_attributes]

        #   either a symbol or array of symbols.  WARNING - This will attempt to overwrite any attribute setters you may have.

        # 

            :version_column, :max_version_limit, :track_altered_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,

          send :attr_accessor, :altered_attributes

                                                :foreign_key => versioned_foreign_key,

            has_many :versions, version_association_options do

              # finds earliest version of this record

              def earliest

                @earliest ||= find(:first, :order => 'version')

              end

              # find latest version of this record

              def latest

                @latest ||= find(:first, :order => 'version desc')

              end

            end

            after_save   :clear_altered_attributes

              self.track_altered_attributes = true

            # find first version before the given version

            def self.before(version)

              find :first, :order => 'version desc',

                :conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]

            end

            # find first version after the given version.

            def self.after(version)

              find :first, :order => 'version',

                :conditions => ["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]

            end

            def previous

              self.class.before(self)

            end

            def next

              self.class.after(self)

            end

            def versions_count

              page.version

            end

          versioned_class.cattr_accessor :original_class

          versioned_class.original_class = self

        # Finds a specific version of this record

        def find_version(version = nil)

          self.class.find_version(id, version)

        end

        def versions_count

          version

            return false unless version = versions.find_by_version(version)

        # Reverts a model to a given version and saves the model.

            (!self.class.track_altered_attributes || (altered_attributes && altered_attributes.length > 0)) :

            (altered_attributes && altered_attributes.include?(attr_name.to_s))

            new_model.send("#{key}=", orig_model.send(key)) if orig_model.has_attribute?(key)

          end

        protected

          def clear_altered_attributes

            self.altered_attributes = []

            (self.altered_attributes ||= []) << attr_name.to_s unless self.changed?(attr_name) || self.send(attr_name) == attr_value_for_db

          def find_version(id, version = nil)

            return find(id) unless version

            conditions = ["#{versioned_foreign_key} = ? AND version = ?", id, version]

            options = { :conditions => conditions, :limit => 1 }

            if result = find_versions(id, options).first

              result

            else

              raise RecordNotFound, "Couldn't find #{name} with ID=#{id} and VERSION=#{version}"

            end

                :default => col.default,

                :scale => col.scale,

                :precision => col.precision

                :default => type_col.default,

                :scale => type_col.scale,

                :precision => type_col.precision

              CALLBACKS.each do |attr_name|

                alias_method "orig_#{attr_name}".to_sym, attr_name

            block.call

          ensure

          end

$:.unshift(File.dirname(__FILE__) + '/../../../rails/activesupport/lib')

$:.unshift(File.dirname(__FILE__) + '/../../../rails/activerecord/lib')

begin

  require 'active_support'

  require 'active_record'

  require 'active_record/fixtures'

rescue LoadError

  require 'rubygems'

  retry

end

require 'acts_as_versioned'

ActiveRecord::Base.configurations = {'test' => config[ENV['DB'] || 'sqlite3']}

ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])

$:.unshift(Test::Unit::TestCase.fixture_path)

    :dependent => :nullify, :order => 'version desc'

      if ActiveRecord::Base.connection.respond_to?(:initialize_schema_information)

        ActiveRecord::Base.connection.initialize_schema_information

        ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"

      else

        ActiveRecord::Base.connection.initialize_schema_migrations_table

        ActiveRecord::Base.connection.assume_migrated_upto_version(0)

      end

      t = Thing.create :title => 'blah blah', :price => 123.45, :type => 'Thing'

      # check that the price column has remembered its value correctly

      assert_equal t.price,  t.versions.first.price

      assert_equal t.title,  t.versions.first.title

      assert_equal t[:type], t.versions.first[:type]

      # make sure that the precision of the price column has been preserved

      assert_equal 7, Thing::Version.columns.find{|c| c.name == "price"}.precision

      assert_equal 2, Thing::Version.columns.find{|c| c.name == "price"}.scale

  set_fixture_class :page_versions => Page::Version

    p = Page.create! :title => 'first title', :body => 'first body'