parlement 0.10 → 0.11

data/vendor/plugins/engines/lib/engines/routing_extensions.rb

@@ -1,28 +0,0 @@
-module ActionController
-  module Routing
-    
-    class << self
-      # This holds the global list of valid controller paths
-      attr_accessor :controller_paths
-    end
-    
-    class ControllerComponent
-      class << self
-      protected
-        def safe_load_paths #:nodoc:
-          if defined?(RAILS_ROOT)
-            paths = $LOAD_PATH.select do |base|
-              base = File.expand_path(base)
-              # Check that the path matches one of the allowed paths in controller_paths
-              base.match(/^#{ActionController::Routing.controller_paths.map { |p| File.expand_path(p) } * '|'}/)
-            end
-            Engines.log.debug "Engines safe_load_paths: #{paths.inspect}"
-            paths
-          else
-            $LOAD_PATH
-          end
-        end        
-      end
-    end
-  end
-end

data/vendor/plugins/engines/lib/engines/testing_extensions.rb

@@ -1,327 +0,0 @@
-# The Engines testing extensions enable developers to load fixtures into specific
-# tables irrespective of the name of the fixtures file. This work is heavily based on
-# patches made by Duane Johnson (canadaduane), viewable at
-# http://dev.rubyonrails.org/ticket/1911
-#
-# Engine developers should supply fixture files in the <engine>/test/fixtures directory
-# as normal. Within their tests, they should load the fixtures using the 'fixture' command
-# (rather than the normal 'fixtures' command). For example:
-#
-#   class UserTest < Test::Unit::TestCase
-#     fixture :users, :table_name => LoginEngine.config(:user_table), :class_name => "User"
-#    
-#     ...
-#
-# This will ensure that the fixtures/users.yml file will get loaded into the correct
-# table, and will use the correct model object class.
-
-
-
-# A FixtureGroup is a set of fixtures identified by a name.  Normally, this is the name of the
-# corresponding fixture filename.  For example, when you declare the use of fixtures in a
-# TestUnit class, like so:
-#   fixtures :users
-# you are creating a FixtureGroup whose name is 'users', and whose defaults are set such that the
-# +class_name+, +file_name+ and +table_name+ are guessed from the FixtureGroup's name.
-class FixtureGroup
-  attr_accessor :table_name, :class_name, :connection
-  attr_reader :group_name, :file_name
-
-  def initialize(file_name, optional_names = {})
-    self.file_name = file_name
-    self.group_name = optional_names[:group_name] || file_name
-    if optional_names[:table_name]
-      self.table_name = optional_names[:table_name]
-      self.class_name = optional_names[:class_name] || Inflector.classify(@table_name.to_s.gsub('.','_'))
-    elsif optional_names[:class_name]
-      self.class_name = optional_names[:class_name]
-      if Object.const_defined?(@class_name)
-        model_class = Object.const_get(@class_name)
-        self.table_name = ActiveRecord::Base.table_name_prefix + model_class.table_name + ActiveRecord::Base.table_name_suffix
-      end
-    end
-
-    # In case either :table_name or :class_name was not set:
-    self.table_name ||= ActiveRecord::Base.table_name_prefix + @group_name.to_s + ActiveRecord::Base.table_name_suffix
-    self.class_name ||= Inflector.classify(@table_name.to_s.gsub('.','_'))
-  end
-
-  def file_name=(name)
-    @file_name = name.to_s
-  end
-  
-  def group_name=(name)
-    @group_name = name.to_sym
-  end
-
-  def class_file_name
-    Inflector.underscore(@class_name)
-  end
-  
-  # Instantiate an array of FixtureGroup objects from an array of strings (table_names)
-  def self.array_from_names(names)
-    names.collect { |n| FixtureGroup.new(n) }
-  end
-  
-  def hash
-    @group_name.hash
-  end
-  
-  def eql?(other)
-    @group_name.eql? other.group_name
-  end
-end
-
-class Fixtures < YAML::Omap
-
-  def self.instantiate_fixtures(object, fixture_group_name, fixtures, load_instances=true)
-    old_logger_level = ActiveRecord::Base.logger.level
-    ActiveRecord::Base.logger.level = Logger::ERROR
-
-    # table_name.to_s.gsub('.','_') replaced by 'fixture_group_name'
-    object.instance_variable_set "@#{fixture_group_name}", fixtures
-    if load_instances
-      ActiveRecord::Base.silence do
-        fixtures.each do |name, fixture|
-          begin
-            if model = fixture.find
-              object.instance_variable_set "@#{name}", model
-            end
-          rescue FixtureClassNotFound
-            # Let's hope the developer has included it himself
-          end
-        end
-      end
-    end
-
-    ActiveRecord::Base.logger.level = old_logger_level
-  end
-
-  # this doesn't really need to be overridden...
-  def self.instantiate_all_loaded_fixtures(object, load_instances=true)
-    all_loaded_fixtures.each do |fixture_group_name, fixtures|
-      Fixtures.instantiate_fixtures(object, fixture_group_name, fixtures, load_instances)
-    end
-  end
-
-  def self.create_fixtures(fixtures_directory, *fixture_groups)
-    connection = block_given? ? yield : ActiveRecord::Base.connection
-    fixture_groups.flatten!
-    
-    # Backwards compatibility: Allow an array of table names to be passed in, but just use them
-    # to create an array of FixtureGroup objects
-    if not fixture_groups.empty? and fixture_groups.first.is_a?(String)
-      fixture_groups = FixtureGroup.array_from_names(fixture_groups)
-    end
-
-    ActiveRecord::Base.silence do
-      fixtures_map = {}
-      fixtures = fixture_groups.map do |group|
-        fixtures_map[group.group_name] = Fixtures.new(connection, fixtures_directory, group)
-      end 
-      # Make sure all refs to all_loaded_fixtures use group_name as hash index, not table_name
-      all_loaded_fixtures.merge! fixtures_map 
-
-      connection.transaction do
-        fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures }
-        fixtures.each { |fixture| fixture.insert_fixtures }
-        
-        # Cap primary key sequences to max(pk).
-        if connection.respond_to?(:reset_pk_sequence!)
-          fixture_groups.each do |fg|
-            connection.reset_pk_sequence!(fg.table_name)
-          end
-        end
-      end
-
-      return fixtures.size > 1 ? fixtures : fixtures.first
-    end
-  end
-
- 
-  attr_accessor :connection, :fixtures_directory, :file_filter
-  attr_accessor :fixture_group
- 
-  def initialize(connection, fixtures_directory, fixture_group, file_filter = DEFAULT_FILTER_RE)
-    @connection, @fixtures_directory = connection, fixtures_directory
-    @fixture_group = fixture_group
-    @file_filter = file_filter
-    read_fixture_files
-  end
- 
-  def delete_existing_fixtures
-    @connection.delete "DELETE FROM #{@fixture_group.table_name}", 'Fixture Delete'
-  end
- 
-  def insert_fixtures
-    values.each do |fixture|
-      @connection.execute "INSERT INTO #{@fixture_group.table_name} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
-    end
-  end
- 
-  private
-    def read_fixture_files
-      if File.file?(yaml_file_path)
-        read_yaml_fixture_files
-      elsif File.file?(csv_file_path)
-        read_csv_fixture_files
-      elsif File.file?(deprecated_yaml_file_path)
-        raise Fixture::FormatError, ".yml extension required: rename #{deprecated_yaml_file_path} to #{yaml_file_path}"
-      elsif File.directory?(single_file_fixtures_path)
-        read_standard_fixture_files
-      else
-        raise Fixture::FixtureError, "Couldn't find a yaml, csv or standard file to load at #{@fixtures_directory} (#{@fixture_group.file_name})."
-      end
-    end
-
-    def read_yaml_fixture_files
-      # YAML fixtures
-      begin
-        if yaml = YAML::load(erb_render(IO.read(yaml_file_path)))
-          yaml = yaml.value if yaml.respond_to?(:type_id) and yaml.respond_to?(:value)
-          yaml.each do |name, data|
-            self[name] = Fixture.new(data, fixture_group.class_name)
-          end
-        end
-      rescue Exception=>boom
-        raise Fixture::FormatError, "a YAML error occured parsing #{yaml_file_path}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{boom.class}: #{boom}"
-      end      
-    end
-
-    def read_csv_fixture_files
-      # CSV fixtures
-      reader = CSV::Reader.create(erb_render(IO.read(csv_file_path)))
-      header = reader.shift
-      i = 0
-      reader.each do |row|
-        data = {}
-        row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-        self["#{@fixture_group.class_file_name}_#{i+=1}"]= Fixture.new(data, @fixture_group.class_name)
-      end
-    end
-
-    def read_standard_fixture_files
-      # Standard fixtures
-      path = File.join(@fixtures_directory, @fixture_group.file_name)
-      Dir.entries(path).each do |file|
-        path = File.join(@fixtures_directory, @fixture_group.file_name, file)
-        if File.file?(path) and file !~ @file_filter
-          self[file] = Fixture.new(path, @fixture_group.class_name)
-        end
-      end
-    end
- 
-    def yaml_file_path
-      fixture_path_with_extension ".yml"
-    end
- 
-    def deprecated_yaml_file_path
-      fixture_path_with_extension ".yaml"
-    end
- 
-    def csv_file_path
-      fixture_path_with_extension ".csv"
-    end
-    
-    def single_file_fixtures_path
-      fixture_path_with_extension ""
-    end
- 
-    def fixture_path_with_extension(ext)
-      File.join(@fixtures_directory, @fixture_group.file_name + ext)
-    end 
-
-    def erb_render(fixture_content)
-      ERB.new(fixture_content).result
-    end
-
-end
-
-module Test #:nodoc:
-  module Unit #:nodoc:
-    class TestCase #:nodoc:
-      cattr_accessor :fixtures_directory
-      class_inheritable_accessor :fixture_groups
-      class_inheritable_accessor :fixture_table_names
-      class_inheritable_accessor :use_transactional_fixtures
-      class_inheritable_accessor :use_instantiated_fixtures   # true, false, or :no_instances
-      class_inheritable_accessor :pre_loaded_fixtures
-
-      self.fixture_groups = []
-      self.use_transactional_fixtures = false
-      self.use_instantiated_fixtures = true
-      self.pre_loaded_fixtures = false
-
-      @@already_loaded_fixtures = {}
-
-      # Backwards compatibility
-      def self.fixture_path=(path); self.fixtures_directory = path; end
-      def self.fixture_path; self.fixtures_directory; end
-      def fixture_group_names; fixture_groups.collect { |g| g.group_name }; end
-      def fixture_table_names; fixture_group_names; end
-
-      def self.fixture(file_name, options = {})
-        self.fixture_groups |= [FixtureGroup.new(file_name, options)]
-        require_fixture_classes
-        setup_fixture_accessors
-      end
-
-      def self.fixtures(*file_names)
-        self.fixture_groups |= FixtureGroup.array_from_names(file_names.flatten)
-        require_fixture_classes
-        setup_fixture_accessors
-      end
-
-      def self.require_fixture_classes(fixture_groups_override = nil)
-        (fixture_groups_override || fixture_groups).each do |group| 
-          begin
-            require group.class_file_name
-          rescue LoadError
-            # Let's hope the developer has included it himself
-          end
-        end
-      end
-
-      def self.setup_fixture_accessors(fixture_groups_override=nil)
-        (fixture_groups_override || fixture_groups).each do |group|
-          define_method(group.group_name) do |fixture, *optionals|
-            force_reload = optionals.shift
-            @fixture_cache[group.group_name] ||= Hash.new
-            @fixture_cache[group.group_name][fixture] = nil if force_reload
-            @fixture_cache[group.group_name][fixture] ||= @loaded_fixtures[group.group_name][fixture.to_s].find
-          end
-        end
-      end
-
-      private
-        def load_fixtures
-          @loaded_fixtures = {}
-          fixtures = Fixtures.create_fixtures(fixtures_directory, fixture_groups)
-          unless fixtures.nil?
-            if fixtures.instance_of?(Fixtures)
-              @loaded_fixtures[fixtures.fixture_group.group_name] = fixtures
-            else
-              fixtures.each { |f| @loaded_fixtures[f.fixture_group.group_name] = f }
-            end
-          end
-        end
-
-        def instantiate_fixtures
-          if pre_loaded_fixtures
-            raise RuntimeError, 'Load fixtures before instantiating them.' if Fixtures.all_loaded_fixtures.empty?
-            unless @@required_fixture_classes
-              groups = Fixtures.all_loaded_fixtures.values.collect { |f| f.group_name }
-              self.class.require_fixture_classes groups
-              @@required_fixture_classes = true
-            end
-            Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
-          else
-            raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
-            @loaded_fixtures.each do |fixture_group_name, fixtures|
-              Fixtures.instantiate_fixtures(self, fixture_group_name, fixtures, load_instances?)
-            end
-          end
-        end
-    end
-  end
-end

data/vendor/plugins/engines/tasks/deprecated_engines.rake

@@ -1,7 +0,0 @@
-# Old-style engines rake tasks.
-# NOTE: THESE ARE DEPRICATED! PLEASE USE THE NEW STYLE!
-
-task :engine_info => "engines:info"
-task :engine_migrate => "db:migrate:engines"
-task :enginedoc => "doc:engines"
-task :load_plugin_fixtures => "db:fixtures:engines:load"

data/vendor/plugins/engines/test/action_view_extensions_test.rb

@@ -1,9 +0,0 @@
-ENV["RAILS_ENV"] = "test"
-require File.expand_path(File.dirname(__FILE__) + '/../../../../config/environment')
-require 'test_help'
-
-class ActionViewExtensionsTest < Test::Unit::TestCase
-  def test_stylesheet_path
-    assert true
-  end
-end

data/vendor/plugins/engines/test/ruby_extensions_test.rb

@@ -1,115 +0,0 @@
-ENV["RAILS_ENV"] = "test"
-require File.expand_path(File.dirname(__FILE__) + '/../../../../config/environment')
-require 'test_help'
-
-class RubyExtensionsTest < Test::Unit::TestCase
-
-  def setup
-    # create the module to be used for config testing
-    eval "module TestModule end"
-  end  
-
-  def teardown
-    # remove the TestModule constant from our scope
-    self.class.class_eval { remove_const :TestModule }
-  end
-
-
-  #
-  # Module.config
-  #
-
-  def test_config_no_arguments
-    assert_raise(RuntimeError) { TestModule.config }
-  end
-  
-  def test_config_array_arguments
-    TestModule.config :monkey, 123
-    assert_equal(123, TestModule.config(:monkey))
-  end
-  
-  def test_config_hash_arguments
-    TestModule.config :monkey => 123, :donkey => 456
-    assert_equal(123, TestModule.config(:monkey))
-    assert_equal(456, TestModule.config(:donkey))
-  end
-
-  def test_config_can_store_hash
-    TestModule.config :hash, :key1 => 'val1', :key2 => 'val2'
-    assert_equal({:key1 => 'val1', :key2 => 'val2'}, TestModule.config(:hash))
-  end
-    
-  def test_config_cant_overwrite_existing_config_values
-    TestModule.config :monkey, 123
-    assert_equal(123, TestModule.config(:monkey))
-    TestModule.config :monkey, 456
-    assert_equal(123, TestModule.config(:monkey))
-    
-    TestModule.config :monkey => 456
-    assert_equal(123, TestModule.config(:monkey))    
-    
-    # in this case, the resulting Hash only has {:baboon => "goodbye!"} - that's Ruby, users beware.
-    TestModule.config :baboon => "hello", :baboon => "goodbye!"
-    assert_equal("goodbye!", TestModule.config(:baboon))    
-  end
-  
-  def test_config_force_new_value
-    TestModule.config :monkey, 123
-    TestModule.config :man, 321
-    assert_equal(123, TestModule.config(:monkey))
-    assert_equal(321, TestModule.config(:man))
-    TestModule.config :monkey, 456, :force
-    assert_equal(456, TestModule.config(:monkey))  
-    TestModule.config :monkey => 456, :man => 654, :force => true
-    assert_equal(456, TestModule.config(:monkey))
-    assert_equal(654, TestModule.config(:man))      
-    TestModule.config :monkey => 789, :man => 987, :force => false
-    assert_equal(456, TestModule.config(:monkey))
-    assert_equal(654, TestModule.config(:man))
-    
-    TestModule.config :hash, :key1 => 'val1', :key2 => 'val2'
-    assert_equal({:key1 => 'val1', :key2 => 'val2'}, TestModule.config(:hash))
-    TestModule.config :hash => {:key1 => 'val3', :key2 => 'val4'}, :force => true
-    assert_equal({:key1 => 'val3', :key2 => 'val4'}, TestModule.config(:hash))           
-  end
-  
-  # this test is somewhat redundant, but it might be an idea to havbe it explictly anyway
-  def test_config_get_values
-    TestModule.config :monkey, 123
-    assert_equal(123, TestModule.config(:monkey))
-  end
-  
-  def test_config_get_multiple_values
-    TestModule.config :monkey, 123
-    TestModule.config :donkey, 456
-    assert_equal([123, 456], TestModule.config([:monkey, :donkey]))
-  end
-  
-  
-  #
-  # Module.default_constant
-  #
-  
-  def test_default_constant_set
-    TestModule.default_constant :Monkey, 123
-    assert_equal(123, TestModule::Monkey)
-    TestModule.default_constant "Hello", 456
-    assert_equal(456, TestModule::Hello)
-  end
-
-  def test_default_constant_cannot_set_again
-    TestModule.default_constant :Monkey, 789
-    assert_equal(789, TestModule::Monkey)
-    TestModule.default_constant :Monkey, 456
-    assert_equal(789, TestModule::Monkey)
-  end
-
-  def test_default_constant_bad_arguments
-    # constant names must be Captialized
-    assert_raise(NameError) { TestModule.default_constant :lowercase_name, 123 }
-    
-    # constant names should be given as Strings or Symbols
-    assert_raise(RuntimeError) { TestModule.default_constant 123, 456 }
-    assert_raise(RuntimeError) { TestModule.default_constant Object.new, 456 }
-  end
-end

data/vendor/plugins/guid/README.TXT

@@ -1,29 +0,0 @@
-# This plugin for ActiveRecord makes the "ID" field into a URL-safe GUID
-# It is a mashup by Andy Singleton <andy@assembla.com> that includes 
-# * the UUID class from Bob Aman.
-# * the plugin skeleton from Demetrius Nunes
-# * the 22 character URL-safe format from Andy Singleton
-# You can get standard 36 char UUID formats instead
-# TODO: Auto-detect a character ID field and use a GUID in this case (DRY principle)
-# 
-# This library is free software; you can redistribute it and/or modify it
-# under the terms of the MIT license.
-# 
-# TO USE
-# Install as a plugin in the rails directory vendor/plugin/guid
-# define ID as char(22)
-# call "usesguid" in ActiveRecord class declaration, like
-class Mymodel < ActiveRecord::Base
-  usesguid			
-  
-# if your ID field is not called "ID", call "usesguid :column =>'IdColumnName' "
-
-# if you create your tables with migrations, you need to bypass the rails default primary key index. Do this:
-
-create_table :mytable, :id => false do |t|
-  t.column :id, :string, :limit => 22
-  ... more fields
-end      
-
-execute "ALTER TABLE mytable ADD PRIMARY KEY (id)"
-

data/vendor/plugins/guid/init.rb

@@ -1,30 +0,0 @@
-# Copyright (c) 2005 Assembla, Inc.
-#
-# This plugin for ActiveRecord makes the "ID" field into a URL-safe GUID
-# It is a mashup by Andy Singleton <andy@assembla.com> that includes 
-# * the UUID class from Bob Aman.
-# * the plugin skeleton from Demetrius Nunes
-# * the 22 character URL-safe format from Andy Singleton
-# You can get standard 36 char UUID formats instead
-# TODO: Auto-detect a character ID field and use a GUID in this case (DRY principle)
-# 
-# This library is free software; you can redistribute it and/or modify it
-# under the terms of the MIT license.
-# 
-# TO USE
-# Install as a plugin in the rails directory vendor/plugin/guid
-# define ID as char(22)
-# call "usesguid" in ActiveRecord class declaration, like
-#   class Mymodel < ActiveRecord::Base
-#	  usesguid			
-#
-# if your ID field is not called "ID", call "usesguid :column =>'IdColumnName' "
-
-# if you create your tables with migrations, you need to bypass the rails default primary key index. Do this:
-#   create_table :mytable, :id => false do |t|
-#     t.column :id, :string, :limit => 22
-#     ... more fields
-#   end      
-#   execute "ALTER TABLE mytable ADD PRIMARY KEY (id)"
-
-require 'usesguid'

data/vendor/plugins/guid/lib/usesguid.rb

@@ -1,37 +0,0 @@
-# from Demetrio Nunes
-# Modified by Andy Singleton to use different GUID generator
-#
-# MIT License
-
-require 'uuid22'
-
-module ActiveRecord
-  module Usesguid #:nodoc:
-  
-    def self.append_features(base)
-      super
-      base.extend(ClassMethods)  
-    end
-
-    
-    module ClassMethods
-      
-      def usesguid(options = {})
-                
-        class_eval do
-          set_primary_key options[:column] if options[:column]
-          
-          def after_initialize
-            self.id ||= UUID.timestamp_create().to_s22
-          end
-        end        
-        
-      end
-      
-    end
-  end
-end
-
-ActiveRecord::Base.class_eval do
-  include ActiveRecord::Usesguid
-end

data/vendor/plugins/guid/lib/uuid22.rb

@@ -1,43 +0,0 @@
-# Copyright (c) 2005 Assembla, Inc.
-# MIT License
-
-require 'uuidtools'
-
-class UUID
-
-  # Make an array of 64 URL-safe characters
-  @@chars64=('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a + ['-','_']
-    #return a 22 byte URL-safe string, encoded six bits at a time using 64 characters
-  def to_s22
-  	integer=self.to_i
-  	rval=''
-    22.times do
-      c=(integer & 0x3F)
-      rval+=@@chars64[c]
-      integer =integer >> 6
-    end
-    return rval.reverse
-  end
-  	# Create a new UUID from a 22char string
-  def self.parse22(s)
-    	# get the integer representation
-    integer=0
-    s.each_byte {|c|
-    	integer = integer << 6
-      pos=@@chars64.index(c.chr)
-      integer+=pos
-    }
-
-    time_low = (integer >> 96) & 0xFFFFFFFF
-    time_mid = (integer >> 80) & 0xFFFF
-    time_hi_and_version = (integer >> 64) & 0xFFFF
-    clock_seq_hi_and_reserved = (integer >> 56) & 0xFF
-    clock_seq_low = (integer >> 48) & 0xFF
-    nodes = []
-    for i in 0..5 do
-      nodes << ((integer >> (40 - (i * 8))) & 0xFF)
-    end
-    return new(time_low, time_mid, time_hi_and_version,
-      clock_seq_hi_and_reserved, clock_seq_low, nodes)
-  end	
-end