openbill 0.1.4 → 0.1.5

data/vendor/generators/vo/USAGE

@@ -0,0 +1,9 @@
+Description:
+  The cairngorm VO generator creates a ValueObject (VO) class in src.
+  specify the base classpath, and then the name of the ValueObject
+  extra options are interpreted as public attributes (of type String)
+  
+Example:
+  ./script/generate vo com/innberg/innspace thing 
+  
+  This creates an ThingVO class in src/com/innberg/innspace/vo

data/vendor/generators/vo/templates/vo_template.as

@@ -0,0 +1,18 @@
+package <%= class_name.downcase.gsub('::','.') %>.vo
+{
+	import com.adobe.cairngorm.vo.IValueObject;
+	
+	[Bindable]
+	[RemoteClass(alias="<%= class_name.downcase.gsub('::','.') %>.vo.<%= actions.first.camelcase %>VO")]
+	public class <%= actions.first.camelcase %>VO implements IValueObject
+	{
+
+		public var id : int;		
+<% attributes = actions.slice(1, actions.size-1)
+for atr in attributes -%>
+
+		public var <%=atr %> : String;
+<% end -%>	
+		
+	}
+}

data/vendor/generators/vo/vo_generator.rb

@@ -0,0 +1,7 @@
+class VoGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      m.template "vo_template.as", File.join('src', class_path, file_name,'vo', "#{actions.first.camelcase}VO.as")
+    end
+  end
+end

data/vendor/generators/worbservice/USAGE

@@ -0,0 +1,8 @@
+Description:
+  The weborb service generator creates a werorb service class in services.
+  the normal filenaming conventions are not used because weborb looks for classes that that stick to the actionscript filenaming conventions i.e. ThingService.rb instead of thing_service.rb
+  
+Example:
+  ./script/generate worbservice com/innberg/innspace/thing
+  
+  This creates an ThingService class in app/service/com/innberg/innspace/ThingService

data/vendor/generators/worbservice/templates/service.rb

@@ -0,0 +1,11 @@
+require 'weborb/context'
+require 'rbconfig'
+
+class <%= class_name %>Service
+  
+<% for action in actions -%>
+
+  def <%= action %>
+  end
+<% end -%>
+end

data/vendor/generators/worbservice/worbservice_generator.rb

@@ -0,0 +1,7 @@
+class WorbserviceGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+       m.template 'service.rb',      File.join('app/services', class_path, "#{file_name.camelcase}Service.rb")
+    end
+  end
+end

data/vendor/plugins/enum-column/init.rb

@@ -0,0 +1,9 @@
+require 'enum/enum_adapter'
+require 'enum/mysql_adapter' if defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+require 'enum/postgresql_adapter' if defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+require 'enum/sqlite3_adapter' if defined? ActiveRecord::ConnectionAdapters::SQLite3Adapter
+require 'enum/schema_statements'
+require 'enum/schema_definitions'
+require 'enum/quoting'
+require 'enum/validations'
+require 'enum/active_record_helper'

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

@@ -0,0 +1,107 @@
+
+module ActionView
+  module Helpers
+    module FormHelper
+      # helper to create a select drop down list for the enumerated values. This
+      # is the default input tag.
+      def enum_select(object_name, method, options = {})
+        if RAILS_GEM_VERSION < '2.2.0'
+          tag = InstanceTag.new(object_name, method, self, nil, options.delete(:object))
+        else
+          tag = InstanceTag.new(object_name, method, self, options.delete(:object))
+        end
+        tag.to_enum_select_tag(options)
+      end
+
+      # Creates a set of radio buttons for all the enumerated values.
+      def enum_radio(object_name, method, options = {})
+        if RAILS_GEM_VERSION < '2.2.0'
+          tag = InstanceTag.new(object_name, method, self, nil, options.delete(:object))
+        else
+          tag = InstanceTag.new(object_name, method, self, options.delete(:object))
+        end
+        tag.to_enum_radio_tag(options)        
+      end
+    end
+
+    class FormBuilder
+      def enum_select(method, options = { })
+        @template.enum_select(@object_name, method, options)
+      end
+
+      def enum_radio(method, options = { })
+        @template.enum_radio(@object_name, method, options)
+      end
+    end
+    
+    class InstanceTag #:nodoc:
+      alias __to_tag_enum to_tag
+
+      # Add the enumeration tag support. Defaults using the select tag to
+      # display the options.
+      def to_tag(options = {})
+        if column_type == :enum
+          to_enum_select_tag(options)
+        else
+          __to_tag_enum(options)
+        end
+      end
+
+      # Create a select tag and one option for each of the
+      # enumeration values.
+      def to_enum_select_tag(options = {})
+        # Remove when we no longer support 1.1.
+        begin
+          v = value(object)
+        rescue ArgumentError
+          v = value
+        end
+        add_default_name_and_id(options)
+        tag_text = "<select"
+        tag_text << tag_options(options)
+        tag_text << ">"
+        values = enum_values
+        raise ArgumentError, "No values for enum select tag" unless values
+        if options[:include_blank]
+          tag_text << "<option value=\"\"></option>\n"
+        end
+        values.each do |enum|
+          tag_text << "<option value=\"#{enum}\""
+          tag_text << ' selected="selected"' if v and v == enum
+          tag_text << ">#{enum}</option>"
+        end
+        tag_text << "</select>"
+      end
+
+      # Creates a set of radio buttons and labels.
+      def to_enum_radio_tag(options = {})
+        # Remove when we no longer support 1.1.
+        begin
+          v = value(object)
+        rescue ArgumentError
+          v = value
+        end
+        add_default_name_and_id(options)
+        values = enum_values
+        raise ArgumentError, "No values for enum select tag" unless values
+        tag_text = ''
+        template = options.dup
+        template.delete('checked')
+        values.each do |enum|
+          opts = template.dup
+          opts['checked'] = 'checked' if v and v == enum
+          opts['id'] = "#{opts['id']}_#{enum}"
+          tag_text << "<label>#{enum}: "
+          tag_text << to_radio_button_tag(enum, opts)
+          tag_text << "</label>"
+        end
+        tag_text
+      end
+
+      # Gets the list of values for the column.
+      def enum_values
+        object.send("column_for_attribute", @method_name).values
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+
+# This module provides all the column helper methods to deal with the
+# values and adds the common type management code for the adapters.
+module ActiveRecordEnumerations
+  module Column
+    # Add the values accessor to the column class.
+    def self.included(klass)
+      klass.module_eval <<-EOE
+        def values; @limit; end
+      EOE
+    end
+
+    # Add the type to the native database types. This will most
+    # likely need to be modified in the adapter as well.
+    def native_database_types
+      types = super
+      types[:enum] = { :name => "enum" }
+      types
+    end
+
+    # The new constructor with a values argument.
+    def initialize(name, default, sql_type = nil, null = true, values = nil)
+      super(name, default, sql_type, null)
+      @limit = values if type == :enum
+    end
+
+    # The class for enum is Symbol.
+    def klass
+      if type == :enum
+        Symbol
+      else
+        super
+      end
+    end
+
+    # Convert to a symbol.
+    def type_cast(value)
+      return nil if value.nil?
+      if type == :enum
+        ActiveRecordEnumerations::Column.value_to_symbol(value)
+      else
+        super
+      end
+    end
+
+    # Code to convert to a symbol.
+    def type_cast_code(var_name)
+      if type == :enum
+        "ActiveRecordEnumerations::Column.value_to_symbol(#{var_name})"
+      else
+        super
+      end
+    end
+
+    # The enum simple type.
+    def simplified_type(field_type)
+      if field_type =~ /enum/i
+        :enum
+      else
+        super
+      end
+    end
+
+    # Safely convert the value to a symbol. 
+    def self.value_to_symbol(value)
+      case value
+      when Symbol
+        value
+      when String
+        value.empty? ? nil : value.intern
+      else
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlAdapter
+      alias __native_database_types_enum native_database_types
+      
+      def native_database_types #:nodoc
+        types = __native_database_types_enum
+        types[:enum] = { :name => "enum" }
+        types
+      end
+
+      def columns(table_name, name = nil)#:nodoc:
+        sql = "SHOW FIELDS FROM #{table_name}"
+        columns = []
+        execute(sql, name).each { |field| columns << MysqlColumnWithEnum.new(field[0], field[4], field[1], field[2] == "YES") }
+        columns
+      end
+    end
+    
+    class MysqlColumnWithEnum < MysqlColumn
+      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/postgresql_adapter.rb

@@ -0,0 +1,64 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      alias __native_database_types_enum native_database_types
+      
+      def native_database_types #:nodoc
+        types = __native_database_types_enum
+        types[:enum] = { :name => "character varying(32)" }
+        types
+      end
+
+      def columns(table_name, name = nil)#:nodoc:
+        column_definitions(table_name).collect do |name, type, default, notnull, consrc|
+          values = nil
+          if consrc and consrc =~ /ANY \(\(ARRAY(\[[^]]+\])/o and type == native_database_types[:enum][:name]
+            values = eval $1.gsub(/::character varying/, '')
+            type = 'enum'
+          end
+          
+          # typmod now unused as limit, precision, scale all handled by superclass
+          PostgreSQLColumnWithEnum.new(name, default_value(default),
+                                       translate_field_type(type), notnull == "f",
+                                       values)
+        end
+      end
+
+      # Add constraints to the list of columns. This will only pick up check constraints.
+      # We'll filter the constraint for the column type and ANY ((ARRAY[ type.
+      def column_definitions(table_name)
+        query <<-end_sql
+          SELECT a.attname, format_type(a.atttypid, a.atttypmod), d.adsrc, a.attnotnull, c.consrc
+            FROM pg_attribute a LEFT JOIN pg_attrdef d
+              ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+              LEFT JOIN pg_constraint c ON a.attrelid = c.conrelid AND 
+                c.contype = 'c' AND c.conkey[1] = a.attnum
+            WHERE a.attrelid = '#{table_name}'::regclass
+              AND a.attnum > 0 AND NOT a.attisdropped
+            ORDER BY a.attnum
+        end_sql
+      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 PostgreSQLColumnWithEnum < Column
+      include ActiveRecordEnumerations::Column
+      
+      def initialize(name, default, sql_type = nil, null = true, values = nil)
+        if values
+          values = values.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/quoting.rb

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,12 @@
+
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,40 @@
+
+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

@@ -0,0 +1,125 @@
+<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

@@ -0,0 +1,28 @@
+
+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