openbill 0.1.6 → 0.1.7

data/vendor/plugins/enum-column/lib/enum/quoting.rb

@@ -1,17 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters # :nodoc:
-    module Quoting
-      alias __quote_enum quote
-
-      # Quote a symbol as a normal string. This will support quoting of
-      # enumerated values.
-      def quote(value, column = nil)
-        if !value.is_a? Symbol
-          __quote_enum(value, column)
-        else
-          ActiveRecord::Base.send(:quote_bound_value, value.to_s)
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/enum-column/lib/enum/schema_definitions.rb

@@ -1,12 +0,0 @@
-
-module ActiveRecord
-  module ConnectionAdapters
-    class TableDefinition
-      def enum(*args)
-        options = args.extract_options!
-        column_names = args
-        column_names.each { |name| column(name, 'enum', options) }
-      end
-    end
-  end
-end

data/vendor/plugins/enum-column/lib/enum/schema_statements.rb

@@ -1,32 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters # :nodoc:
-    module SchemaStatements
-      alias __type_to_sql_enum type_to_sql
-
-      # Add enumeration support for schema statement creation. This
-      # will have to be adapted for every adapter if the type requires
-      # anything by a list of allowed values. The overrides the standard
-      # type_to_sql method and chains back to the default. This could 
-      # be done on a per adapter basis, but is generalized here.
-      #
-      # will generate enum('a', 'b', 'c') for :limit => [:a, :b, :c]
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-        if type == :enum
-          native = native_database_types[type]
-          column_type_sql = native[:name] || 'enum'
-          
-          column_type_sql << "(#{limit.map { |v| quote(v) }.join(',')})"
-          column_type_sql          
-        else
-          # Edge rails fallback for Rails 1.1.6. We can remove the
-          # rescue once everyone has upgraded to 1.2.
-          begin
-            __type_to_sql_enum(type, limit, precision, scale)
-          rescue ArgumentError
-            __type_to_sql_enum(type, limit)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/enum-column/lib/enum/sqlite3_adapter.rb

@@ -1,52 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class SQLite3Adapter
-      alias __native_database_types_enum native_database_types
-      
-      def native_database_types #:nodoc
-        types = __native_database_types_enum
-        types[:enum] = { :name => "varchar(32)" }
-        types
-      end
-
-      def columns(table_name, name = nil)#:nodoc:
-        constraints = { }
-        @connection.execute "SELECT sql FROM sqlite_master WHERE name = '#{table_name}'" do |row|
-          sql = row[0]
-          sql.scan(/, \"(\w+)\" varchar\(32\) CHECK\(\"\w+\" in \(([^\)]+)\)/i) do |column, constraint|
-            constraints[column] = constraint
-          end
-        end
-        table_structure(table_name).map do |field|
-          name = field['name']
-          type = field['type']
-          if (const = constraints[name])
-            type = "enum(#{const.strip})"
-          end
-          SQLite3ColumnWithEnum.new(name, field['dflt_value'], type, field['notnull'] == "0")
-        end
-      end
-
-      def add_column_options!(sql, options)
-        unless sql =~ /\(32\)\('[^']+'/
-          super(sql, options)
-        else
-          sql.gsub!(/("[^"]+")([^3]+32\))(.+)/, '\1\2 CHECK(\1 in \3)')
-          super(sql, options)
-        end
-      end
-    end
-    
-    class SQLite3ColumnWithEnum < SQLiteColumn
-      include ActiveRecordEnumerations::Column
-      
-      def initialize(name, default, sql_type = nil, null = true)
-        if sql_type =~ /^enum/i
-          values = sql_type.sub(/^enum\('([^)]+)'\)/i, '\1').split("','").map { |v| v.intern }
-          default = default.intern if default and !default.empty?
-        end
-        super(name, default, sql_type, null, values)
-      end
-    end
-  end
-end

data/vendor/plugins/enum-column/lib/enum/validations.rb

@@ -1,40 +0,0 @@
-
-module ActiveRecord
-  module Validations
-    module ClassMethods
-      # Automatically validates the column against the schema definition
-      # for nullability, format, and enumerations. Handles integers, floats,
-      # enumerations, and string limits.
-      #
-      # Usage: validates_columns :severity, :name
-      def validates_columns(*column_names)
-        begin
-          cols = columns_hash
-          column_names.each do |name|
-            col = cols[name.to_s]
-            raise ArgumentError, "Cannot find column #{name}" unless col
-            
-            # test for nullability
-            validates_presence_of(name) if !col.null
-            
-            # Test various known types.
-            case col.type
-            when :enum
-              validates_inclusion_of name, :in => col.values, :allow_nil => true
-              
-            when :integer, :float
-              validates_numericality_of name, :allow_nil => true
-              
-            when :string
-              if col.limit
-                validates_length_of name, :maximum => col.limit, :allow_nil => true
-              end
-            end
-          end
-        rescue ActiveRecord::StatementInvalid=>e
-          raise e unless e.message.include?("42S02") # swallow the exception if its for a missing table
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/enum-column/readme.html

@@ -1,125 +0,0 @@
-<html>
-<head>
-<title>Ruby on Rails Enumerated Column Constraints</title>
-<style>
-body { 
-    font-family: "Lucida Sans", Verdana, sans-serif;
-    font-size: small;
-}
-
-h1 { font-size: 175%; }
-
-.indent { 
-    margin-left: 4em;
-}
-
-</style>
-</head>
-<body>
-  <h1>Ruby on Rails Enumerated Column Constraints</h1>
-  <h2>Overview</h2>
-  <p>This plugin is an ROR extension to support enumerations in the database schema using the enum type in MySQL or column constraints in other databases. Currently only MySQL has been implemented, but other connection adapters can easily be extended to check for column constraints and then parse out the possible values.</p>
-
-  <p>This makes it very easy to implement and maintain controlled vocabularies in the database schema without having to change the validations and the view. I have made an effort to make the modifications without modifying the core classes, but I have not been extreamly successful. I have had to make some modifications that are version dependent and then put some exception handlers to make the backward compatible. </p>
-
-<p>This is not the ideal solution and could cause some performance issues in the helpers. The core code still works with both 1.1 and 1.2 without modification.</p>
-
-<h2>Installation</h2>
-
-<p>To install using the plugin script:</p>
-<pre>
-    script/plugin install enum-column
-</pre>
-
-<p>To manually install using Subversion, do the following. In your <code>vendor/plugins</code> directory, 
-  type the following:<p>
-<pre>
-    svn checkout svn://rubyforge.org/var/svn/enum-column
-</pre>
-
-<p>Otherwize download the latest zip or tarball and unpack it in your <code>vendor/plugins</code> directory.</p>
-
-<h2>How to use it.</h2>
-
-<h3>In your schema</h3>
-
-<p>When you create your schema, specify the constraint as a limit:</p>
-<pre>
-  create_table :enumerations, :force => true do |t|
-    t.column :severity, :enum, :limit =&gt; [:low, :medium, :high, :critical],
-       :default => :medium
-    t.column :color, :enum, :limit =&gt; [:red, :blue, :green, :yellow]
-    ...
-  end
-</pre>
-
-<h3>In the model</h3>
-<p>You can then automatically validate this column using:</p>
-<pre>
-    validates_columns :severity, :color
-</pre>
-
-<p>The rest will be handled for you. All enumerated values will be given as symbols.</p>
-<pre>
-    @e = Enumeration.new
-    @e.severity = :low
-</pre>
-
-<h3>In the views.</h3>
-
-<p>In the controller:</p>
-<pre>
-   @e = Enumeration.new
-</pre>
-
-<p>The enumerates list of values will be specified as follows:</p>
-<pre>
-    &lt;%= input 'e', 'severity' %&gt;
-</pre>
-
-<p>Will create a select/option list:</p>
-<pre>
-     &lt;select id="e_severity" name="e[severity]"&gt;
-     	     &lt;option value="low"&gt;low&lt;/option&gt;
-	     &lt;option value="medium" selected="selected"&gt;medium&lt;/option&gt;
-	     &lt;option value="high"&gt;high&lt;/option&gt;
-	     &lt;option value="critical"&gt;critical&lt;/option&gt;
-     &lt;/select&gt;
-</pre>
-
-<div class="indent">
-     <select id="e_severity" name="e[severity]">
-     	     <option value="low">low</option>
-	     <option value="medium" selected="selected">medium</option>
-	     <option value="high">high</option>
-	     <option value="critical">critical</option>
-     </select>
-</div>
-
-<p>You can also create a set of radio buttons using the following helper:</p>
-<pre>
-    &lt;%= enum_radio('e', 'severity') %=&gt;
-</pre>
-<p>Will produce the following group of radio buttons:</p>
-<pre>
-    &lt;label&gt;low: &lt;input id="test_severity_low" name="test[severity]" type="radio" value="low" /&gt;&lt;/label&gt;
-    &lt;label&gt;medium: &lt;input checked="checked" id="test_severity_medium" name="test[severity]" type="radio" value="medium" /&gt;&lt;/label&gt;
-    &lt;label&gt;high: &lt;input id="test_severity_high" name="test[severity]" type="radio" value="high" /&gt;&lt;/label&gt;
-    &lt;label&gt;critical: &lt;input id="test_severity_critical" name="test[severity]" type="radio" value="critical" /&gt;&lt;/label&gt;
-</pre>
-
-<div class="indent">
-    <label>low: <input id="test_severity_low" name="test[severity]" type="radio" value="low" /></label>
-    <label>medium: <input checked="checked" id="test_severity_medium" name="test[severity]" type="radio" value="medium" /></label>
-    <label>high: <input id="test_severity_high" name="test[severity]" type="radio" value="high" /></label>
-    <label>critical: <input id="test_severity_critical" name="test[severity]" type="radio" value="critical" /></label>
-</div>
-
-<p>You can always use the column reflection to get the list of possible values from the database column. </p>
-<pre>
-    Enumeration.columns_hash['color'].values
-    
-    Will yield: [:red, :blue, :green, :yellow]
-</pre>
-
-

data/vendor/plugins/enum-column/test/db/schema.rb

@@ -1,28 +0,0 @@
-
-ActiveRecord::Schema.define do
-  create_table :enumerations, :force => true do |t|
-    t.column :severity, :enum, :limit => [:low, :medium, :high, :critical],
-       :default => :medium
-    t.column :color, :enum, :limit => [:red, :blue, :green, :yellow]
-    t.column :string_field, :string, :limit => 8, :null => false
-    t.column :int_field, :integer
-  end
-
-
-  create_table :basic_enums, :force => true  do |t|
-    t.column :value, :enum, :limit => [:good, :working]
-  end
-  
-  create_table :basic_default_enums, :force => true  do |t|
-    t.column :value, :enum, :limit => [:good, :working],:default => :working
-  end
-
-  create_table :nonnull_enums, :force => true  do |t|
-    t.column :value, :enum, :limit => [:good, :working],:null => false
-  end
-
-  create_table :nonnull_default_enums, :force => true  do |t|
-    t.column :value, :enum, :limit => [:good, :working],:null => false,:default => :working
-  end
-
-end

data/vendor/plugins/enum-column/test/enum_mysql_test.rb

@@ -1,220 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'fixtures/enumeration'
-
-class EnumerationsTest < Test::Unit::TestCase
-  class EnumController < ActionController::Base
-    def test1
-      @test = Enumeration.new
-      render :inline => "<%= input('test', 'severity')%>"
-    end
-
-    def test2
-      @test = Enumeration.new
-      render :inline => "<%= enum_radio('test', 'severity')%>"
-    end
-  end
-
-  def setup
-    Enumeration.connection.execute 'DELETE FROM enumerations'
-  end
-  
-  def test_column_values
-    columns = Enumeration.columns_hash
-    color_column = columns['color']
-    assert color_column
-    assert_equal [:red, :blue, :green, :yellow], color_column.values
-
-    severity_column = columns['severity']
-    assert severity_column
-    assert_equal [:low, :medium, :high, :critical], severity_column.values
-    assert_equal :medium, severity_column.default
-  end
-
-  def test_insert_enum
-    row = Enumeration.new
-    row.color = :blue
-    row.string_field = 'test'
-    assert_equal :medium, row.severity
-    assert row.save
-
-    db_row = Enumeration.find(row.id)
-    assert db_row
-    assert :blue, row.color
-    assert :medium, row.severity
-  end
-
-  # Uses the automatic validates_columns to create automatic validation rules
-  # for columns based on the schema information.
-  def test_bad_value
-    row = Enumeration.new
-    row.color = :violet
-    row.string_field = 'test'
-    assert !row.save
-    
-    assert row.errors
-    assert_equal 'is not included in the list', row.errors['color']
-  end
-
-  def test_other_types
-    row = Enumeration.new
-    row.string_field = 'a' * 10
-    assert !row.save
-    assert_equal 'is too long (maximum is 8 characters)', row.errors['string_field']
-
-    row = Enumeration.new
-    assert !row.save
-    assert_equal 'can\'t be blank', row.errors['string_field']
-
-    row = Enumeration.new
-    row.string_field = 'test'
-    row.int_field = 'aaaa'
-    assert !row.save
-    assert_equal 'is not a number', row.errors['int_field']
-
-    row = Enumeration.new
-    row.string_field = 'test'
-    row.int_field = '500'
-    assert row.save
-  end
-
-  def test_view_helper
-    request  = ActionController::TestRequest.new
-    response = ActionController::TestResponse.new
-    request.action = 'test1'
-    body = EnumController.process(request, response).body
-    assert_equal '<select id="test_severity" name="test[severity]"><option value="low">low</option><option value="medium" selected="selected">medium</option><option value="high">high</option><option value="critical">critical</option></select>', body
-  end
-
-  def test_radio_helper
-    request  = ActionController::TestRequest.new
-    response = ActionController::TestResponse.new
-    request.action = 'test2'
-    body = EnumController.process(request, response).body
-    assert_equal '<label>low: <input id="test_severity_low" name="test[severity]" type="radio" value="low" /></label><label>medium: <input checked="checked" id="test_severity_medium" name="test[severity]" type="radio" value="medium" /></label><label>high: <input id="test_severity_high" name="test[severity]" type="radio" value="high" /></label><label>critical: <input id="test_severity_critical" name="test[severity]" type="radio" value="critical" /></label>', body
-  end
-
-
-  # Basic tests
-  def test_create_basic_default
-    assert (object = BasicEnum.create)
-    assert_nil object.value,
-      "Enum columns without explicit default, default to null if allowed"
-    assert !object.new_record?
-  end
-
-  def test_create_basic_good
-    assert (object = BasicEnum.create(:value => :good))
-    assert_equal :good, object.value
-    assert !object.new_record?
-    assert (object = BasicEnum.create(:value => :working))
-    assert_equal :working, object.value
-    assert !object.new_record?
-  end
-
-  def test_create_basic_null
-    assert (object = BasicEnum.create(:value => nil))
-    assert_nil object.value
-    assert !object.new_record?
-  end
-
-  def test_create_basic_bad
-    assert (object = BasicEnum.create(:value => :bad))
-    assert object.new_record?
-  end
-
-  # Basic w/ Default
-
-  ######################################################################
-
-  def test_create_basic_wd_default
-    assert (object = BasicDefaultEnum.create)
-    assert_equal :working, object.value, "Explicit default ignored columns"
-    assert !object.new_record?
-  end
-
-  def test_create_basic_wd_good
-    assert (object = BasicDefaultEnum.create(:value => :good))
-    assert_equal :good, object.value
-    assert !object.new_record?
-    assert (object = BasicDefaultEnum.create(:value => :working))
-    assert_equal :working, object.value
-    assert !object.new_record?
-  end
-
-  def test_create_basic_wd_null
-    assert (object = BasicDefaultEnum.create(:value => nil))
-    assert_nil object.value
-    assert !object.new_record?
-  end
-
-  def test_create_basic_wd_bad
-    assert (object = BasicDefaultEnum.create(:value => :bad))
-    assert object.new_record?
-  end
-
-
-
-  # Nonnull
-
-  ######################################################################
-
-  def test_create_nonnull_default
-    assert (object = NonnullEnum.create)
-#    assert_equal :good, object.value,
-#      "Enum columns without explicit default, default to first value if null not allowed"
-    assert object.new_record?
-  end
-
-  def test_create_nonnull_good
-    assert (object = NonnullEnum.create(:value => :good))
-    assert_equal :good, object.value
-    assert !object.new_record?
-    assert (object = NonnullEnum.create(:value => :working))
-    assert_equal :working, object.value
-    assert !object.new_record?
-  end
-
-  def test_create_nonnull_null
-    assert (object = NonnullEnum.create(:value => nil))
-    assert object.new_record?
-  end
-
-  def test_create_nonnull_bad
-    assert (object = NonnullEnum.create(:value => :bad))
-    assert object.new_record?
-  end
-
-  # Nonnull w/ Default
-
-  ######################################################################
-
-  def test_create_nonnull_wd_default
-    assert (object = NonnullDefaultEnum.create)
-    assert_equal :working, object.value
-    assert !object.new_record?
-  end
-
-  def test_create_nonnull_wd_good
-    assert (object = NonnullDefaultEnum.create(:value => :good))
-    assert_equal :good, object.value
-    assert !object.new_record?
-    assert (object = NonnullDefaultEnum.create(:value => :working))
-    assert_equal :working, object.value
-    assert !object.new_record?
-  end
-
-  def test_create_nonnull_wd_null
-    assert (object = NonnullDefaultEnum.create(:value => nil))
-    assert object.new_record?
-  end
-
-  def test_create_nonnull_wd_bad
-    assert (object = NonnullDefaultEnum.create(:value => :bad))
-    assert object.new_record?
-  end
-
-  def test_quoting
-    value = ActiveRecord::Base.send(:sanitize_sql, ["value = ? ", :"'" ] )
-    assert_equal "value = '\\'' ", value
-  end
-end