active_form 0.0.1

data/lib/loob/uri_validator.rb

@@ -0,0 +1,140 @@
+require 'net/http'
+require 'uri'
+
+module Loob
+  class UriValidator
+  
+    # possible error statuses: 
+    # :invalid_scheme
+    # :invalid_host
+    # :invalid_content_type
+    # :invalid_format
+    # :moved_permanently
+    # :not_accessible
+  
+    DEFAULT_HTTP_OK_CODES = [
+			Net::HTTPMovedPermanently,
+			Net::HTTPOK,
+			Net::HTTPCreated,
+			Net::HTTPAccepted,
+			Net::HTTPNonAuthoritativeInformation,
+			Net::HTTPPartialContent,
+			Net::HTTPFound,
+			Net::HTTPTemporaryRedirect,
+			Net::HTTPSeeOther
+		].freeze
+  
+    attr_accessor :response_codes, :content_types, :schemes, :hosts, :port
+    attr_reader :error
+    
+    class << self
+    
+      def valid_uri?(str, options = {})
+        self.new(options).valid_uri?(str)
+      end
+      alias :valid_url? :valid_uri?
+      
+      def valid_domain?(str, options = {})
+        self.new(options).valid_domain?(str)
+      end
+      
+    end
+    
+    def initialize(options = {})
+      self.schemes = options[:schemes] || []
+      self.hosts = options[:hosts] || []
+      self.content_types = options[:content_types] || []
+      self.response_codes = options[:response_codes] || DEFAULT_HTTP_OK_CODES
+      self.port = options[:port] || 80
+    end
+    
+    [:response_codes, :content_types, :schemes, :hosts].each do |setter|
+      self.module_eval("def #{setter}=(args); @#{setter} = [*args]; end") 
+    end
+    
+    def valid_uri?(str)
+      reset_error!
+      begin
+        moved_retry ||= false
+				not_allowed_retry ||= false
+        
+        uri = URI.parse(str)
+        uri.path = '/' if uri.path.length < 1        
+        return set_error(:invalid_scheme) unless validate_scheme(uri)
+        return set_error(:invalid_host) unless validate_host(uri)
+        
+        http = Net::HTTP.new(uri.host, (uri.scheme == 'https') ? 443 : port)
+        if uri.scheme == 'https'
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        response = not_allowed_retry ? http.request_get(uri.path) {|r|} : http.request_head(uri.path)        
+        raise unless validate_response_code(response)
+        return set_error(:invalid_content_type) unless validate_content_type(response)      
+      rescue URI::InvalidURIError
+        return set_error(:invalid_format)
+      rescue
+        if response.is_a?(Net::HTTPMovedPermanently)
+          unless moved_retry
+            moved_retry = true
+            str += '/' # In case webserver is just adding a /
+            retry
+          else
+            return set_error(:moved_permanently)            
+          end
+        elsif response.is_a?(Net::HTTPMethodNotAllowed)
+          unless not_allowed_retry # Retry with a GET 
+            not_allowed_retry = true
+            retry
+          else
+            return set_error(:not_accessible)
+          end
+        else       
+          return set_error(:not_accessible)
+        end
+      end
+      return true
+    end
+    alias :valid_url? :valid_uri?
+    
+    def valid_domain?(str)
+      begin
+        uri = URI.parse(str)
+        return valid_uri?("#{uri.scheme || 'http'}://#{uri.host || str}/")
+      rescue URI::InvalidURIError, URI::NameError
+        return set_error(:invalid_format)
+      end
+    end
+   
+    private
+    
+    def reset_error!
+      @error = nil
+    end
+    
+    def set_error(code)
+      @error = code
+      false
+    end
+    
+    def validate_scheme(uri)
+      return true if schemes.empty?
+      schemes.find { |match| match.kind_of?(Regexp) ? uri.scheme =~ match : uri.scheme.index(match) }
+    end
+    
+    def validate_host(uri)
+      return true if hosts.empty?
+      hosts.find { |match| match.kind_of?(Regexp) ? uri.host =~ match : uri.host.index(match) }
+    end
+    
+    def validate_response_code(response)
+      response_codes.include?(response.class)
+    end
+    
+    def validate_content_type(response)
+      return true if content_types.empty?
+      content_types.find { |match| match.kind_of?(Regexp) ? response['content-type'] =~ match : response['content-type'].index(match) }
+    end
+    
+  end
+end

data/lib/rails/acts_as_dropdown/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 DeLynn Berry
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/rails/acts_as_dropdown/acts_as_dropdown.rb

@@ -0,0 +1,119 @@
+# Copyright (c) 2006 DeLynn Berry
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module ActiveRecord #:nodoc:
+  module Acts #:nodoc:
+    # Specify this act if you want to your model be used easily with the <tt>select</tt> form helper. By default the
+    # plugin assumes you want to use the <tt>id</tt> attribute for the option's value and the <tt>name</tt> attribute for
+    # the option's text.
+    #
+    # Example:
+    #
+    #   class State < ActiveRecord::Base
+    #     acts_as_dropdown
+    #   end
+    #
+    #   State.to_dropdown   # => [["Alabama", 1], ["Alaska", 2], ["Arizona", 3], ["California", 4], ["Colorado", 5]]
+    #
+    # The <tt>value</tt>, <tt>text</tt>, <tt>conditions</tt>, and <tt>order</tt> can also be altered from the default configuration
+    # by using the options hash.
+    #
+    # Example:
+    #
+    #   class State < ActiveRecord::Base
+    #     acts_as_dropdown :text => "abbreviation", :conditions => "id < 4"
+    #   end
+    #
+    #   State.to_dropdown   # => [["AL", 1], ["AK", 2], ["AZ", 3], ["CA", 4]]
+    #
+    # The class method <tt>to_dropdown</tt> can also alter the default class configuration using the same options hash.
+    #
+    # Example:
+    #
+    #   class State < ActiveRecord::Base
+    #     acts_as_dropdown :text => "abbreviation", :conditions => "id < 4"
+    #   end
+    #
+    #   State.to_dropdown :text => "name", :conditions => nil   # => [["Alabama", 1], ["Alaska", 2], ["Arizona", 3], ["California", 4], ["Colorado", 5]]
+    #
+    # See ActiveRecord::Acts::Dropdown::ClassMethods#acts_as_dropdown for configuration options
+    module Dropdown
+      def self.included(base) # :nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # == Configuration options
+        #
+        # * <tt>text</tt> - This is the class attribute that will be used as the text/label for the option tag (defaults to name).
+        # * <tt>value</tt> - This is the class attribute that will be used to fill in the option's value parameter (defaults to id).
+        # * <tt>conditions</tt> - This is the conditions string that will be used when executing the <tt>find</tt> method on the object (defaults to nil).
+        # * <tt>order</tt> - This is the order string that will be used when executing the <tt>find</tt> method on the object (defaults to the <tt>value</tt> attribute).
+        def acts_as_dropdown(options = {})
+          cattr_accessor :dropdown_text_attr, :dropdown_value_attr, :conditions_string, :order_string
+
+          self.dropdown_text_attr   = options[:text] || "name"
+          self.dropdown_value_attr  = options[:value] || "id"
+          self.conditions_string    = options[:conditions] || nil
+          self.order_string         = options[:order] || self.dropdown_value_attr.to_s
+        end
+        
+        # === Example:
+        #
+        #   class State < ActiveRecord::Base
+        #     acts_as_dropdown
+        #   end
+        #
+        #   >> State.to_dropdown
+        #   => [["Alabama", 1], ["Alaska", 2], ["Arizona", 3], ["California", 4], ["Colorado", 5]]
+        #
+        # The <tt>value</tt>, <tt>text</tt>, <tt>conditions</tt>, and <tt>order</tt> can also be altered from the default configuration
+        # by using the options hash.
+        #
+        # === Example:
+        #
+        #   class State < ActiveRecord::Base
+        #     acts_as_dropdown :text => "abbreviation", :conditions => "id < 4"
+        #   end
+        #
+        #   >> State.to_dropdown 
+        #   => [["AL", 1], ["AK", 2], ["AZ", 3], ["CA", 4]]
+        #
+        # The class method <tt>to_dropdown</tt> can also alter the default class configuration using the same options hash.
+        #
+        # === Example:
+        #
+        #   class State < ActiveRecord::Base
+        #     acts_as_dropdown :text => "abbreviation", :conditions => "id < 4"
+        #   end
+        #
+        #   >> State.to_dropdown :text => "name", :conditions => nil
+        #   => [["Alabama", 1], ["Alaska", 2], ["Arizona", 3], ["California", 4], ["Colorado", 5]]
+        def to_dropdown(options = {})
+          acts_as_dropdown(options) unless options.empty?
+          find(:all, :conditions => self.conditions_string, :order => self.order_string).to_dropdown(self.dropdown_text_attr.to_sym, self.dropdown_value_attr.to_sym)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActiveRecord::Acts::Dropdown)

data/lib/rails/acts_as_dropdown/dropdown.rb

@@ -0,0 +1,27 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module Dropdown
+        # Collects the contents of the array and creates a new array that can be easily used
+        # with the <tt>select</tt> form helper method.
+        #
+        # == Options
+        # * <tt>text</tt> - This is the attribute that will be used as the text/label for the option tag (defaults to name).
+        # * <tt>value</tt> - This is the attribute that will be used to fill in the option's value parameter (defaults to id).
+        #
+        # === Example
+        #
+        #   >> @states = State.find(:all, :order => "id")
+        #   >> @states.to_dropdown 
+        #   => [["Alabama", 1], ["Alaska", 2], ["Arizona", 3], ["California", 4], ["Colorado", 5]]
+        def to_dropdown(text = "name", value = "id")
+          self.collect { |x| [x.send(text.to_sym), x.send(value.to_sym)] }
+        end
+      end
+    end
+  end
+end
+
+class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::Dropdown
+end

data/lib/rails/controller_helper.rb

@@ -0,0 +1,19 @@
+module ActiveForm
+  module ControllerHelper
+   
+    def create_active_form(*args, &block)
+      form = ActiveForm::compose(*args, &block)
+      form.update_from_params(params)
+      instance_variable_set("@#{form.name}", form)
+    end
+  
+    def build_active_form(definition_name, *args, &block)
+      form = ActiveForm::Definition::build(definition_name, *args, &block)
+      form.update_from_params(params)
+      instance_variable_set("@#{form.name}", form)
+    end
+   
+  end
+end
+
+ActionController::Base.send(:include, ActiveForm::ControllerHelper) if Object.const_defined?('ActionController')

data/lib/rails/model/loader.rb

@@ -0,0 +1,206 @@
+module ActiveForm
+  class Definition
+  
+    attr_accessor :model_instance
+    
+    def clear_validations!
+      super
+      model_instance.errors.clear if model_instance.respond_to?(:errors)
+    end
+    
+    def validate_element
+      super      
+      code_lookup = ActiveRecord::Errors.default_error_messages.invert      
+      if model_instance.respond_to?(:valid?) && model_instance.respond_to?(:errors)
+        unless model_instance.valid?
+          errors_on_base = [*model.instance.errors.on_base] rescue []
+          errors_on_base.each { |msg| self.errors.add(msg, 'ar_base') unless msg.blank? }       
+          model_instance.errors.each do |attr, msg| 
+            if elem = self[attr]
+              code = code_lookup.key?(msg) ? code_lookup[msg] : 'elem'
+              msg = "%s: #{msg}" unless code == 'elem'
+              elem.errors.add(elem.format_message(msg), "ar_#{code}")
+            end
+          end
+        end
+      end
+    end
+    
+  end
+end
+
+module ActiveForm
+  module Model
+    
+    def self.load(*args, &block)
+      custom_type = args.first.kind_of?(Symbol) ? args.shift : nil
+      instance = args.shift
+      definition_name = "#{instance.class.name.underscore}"
+      definitions = case instance
+        when ActiveRecord::Base then
+          if instance.new_record?
+            ["create_#{definition_name}", definition_name]
+          else
+            ["update_#{definition_name}", definition_name]
+          end
+        else
+          return nil
+        end     
+      args.unshift("#{definition_name}_form") if args.empty? || args.first.kind_of?(Hash)
+      definitions.unshift("#{custom_type}_#{definition_name}") unless custom_type.nil?
+      if name = definitions.detect { |name| ActiveForm::get(name) }
+        Definition.new.build(name, instance, *args, &block)
+      else
+        AutoDefinition.new.build(definition_name, instance, *args, &block)
+      end
+    end
+    
+    def self.load!(*args, &block)
+      form = load(*args, &block)
+      form.submit_element
+      form
+    end
+    
+    def self.build(*args, &block)
+      instance = args.shift
+      return nil unless instance.kind_of?(ActiveRecord::Base)
+      definition_name = "#{instance.class.name.underscore}"
+      args.unshift("#{definition_name}_form") if args.empty? || args.first.kind_of?(Hash)
+      AutoDefinition.new.build(definition_name, instance, *args, &block)
+    end
+    
+    def self.build!(*args, &block)
+      form = build(*args, &block)
+      form.submit_element
+      form
+    end
+    
+    class Definition
+      
+      def initialize
+        @now = Time.now
+      end
+      
+      def build(name, instance, *args, &block)
+        form = ActiveForm::build(name, *args, &block)        
+        pk_column = instance.column_for_attribute(instance.class.primary_key)
+        form.insert_element_at_top(self.class.primary_key_column(pk_column)) if !pk_column.nil? && form[instance.class.primary_key.to_sym].nil?
+        instance.class.columns.each { |column| (elem = form[column.name]) ? elem.type_cast = column.type : nil }
+        form = instance.new_record? ? prepare_new_record(form, instance) : prepare_record(form, instance)
+        assign_validation(form, instance)
+        form
+      end
+      
+      def assign_validation(form, instance)
+        # TODO reflect_on_validations here
+      end
+      
+      def prepare_new_record(form, instance)
+        prepare_record(form, instance)
+        form.get_elements_of_type(:select_date, :select_time, :select_datetime).each { |elem| elem.value = @now if elem.blank? }
+        instance.class.columns.each { |column| ((elem = form[column.name]) && !column.default.blank?) ? elem.type_cast = column.default : nil }
+        form
+      end
+      
+      def prepare_record(form, instance)
+        form.update_values(ActiveForm::Values.new(instance.attributes))
+        form.model_instance = instance
+        form
+      end
+      
+      def column_to_element(column, options = {})
+        options[:default] = column.default unless column.default.blank?
+        
+        element = self.class.respond_to?("#{column.type}_column") ? self.class.send("#{column.type}_column", column, options) : self.class.string_column(column, options)
+        element.label = column.human_name
+        element
+      end
+      
+      def association_column_to_element(assoc, column, options = {})
+        options[:default] = column.default unless column.default.blank?
+        
+        element = self.class.respond_to?("#{assoc.macro}_column") ? self.class.send("#{assoc.macro}_column", assoc, column, options) : self.class.integer_column(column, options)
+        element.label = column.human_name
+        element
+      end   
+      
+      def associations_lookup(instance)
+        instance.class.reflect_on_all_associations.inject({}) do |lookup, assoc|
+          if assoc.macro == :belongs_to
+            lookup[assoc.primary_key_name] = assoc
+          end
+          lookup
+        end
+      end
+      
+      class << self
+        
+        def belongs_to_column(assoc, column, options = {})
+          if assoc.klass.respond_to?(:dropdown_text_attr)
+            ActiveForm::Element::build(:select_from_model, column.name, options.merge(:type_cast => :integer, :model => assoc.klass.to_s, :to_dropdown => true))
+          else
+            integer_column(column, options)
+          end
+        end
+        
+        def primary_key_column(column, options = {})
+          ActiveForm::Element::build(:hidden, column.name, options.merge(:type_cast => :integer))
+        end
+      
+        def string_column(column, options = {})
+          type = column.name =~ /password/i ? :password : :text
+          ActiveForm::Element::build(type, column.name, options.merge(:type_cast => :string))
+        end
+      
+        def text_column(column, options = {})
+          ActiveForm::Element::build(:textarea, column.name, options.merge(:type_cast => :text))
+        end
+      
+        def integer_column(column, options = {})
+          ActiveForm::Element::build(:text, column.name, options.merge(:type_cast => :integer))
+        end
+        alias :float_column :integer_column
+      
+        def date_column(column, options = {})
+          ActiveForm::Element::build(:select_date, column.name, options.merge(:type_cast => :date))
+        end
+      
+        def datetime_column(column, options = {})
+          ActiveForm::Element::build(:select_datetime, column.name, options.merge(:type_cast => :time))
+        end
+        alias :timestamp_column :datetime_column
+      
+        def boolean_column(column, options = {})
+          ActiveForm::Element::build(:text, column.name, options.merge(:type_cast => :boolean))
+        end
+      
+      end
+      
+    end
+    
+    class AutoDefinition < Definition
+      
+      def build(name, instance, *args, &block)     
+        assoc_lookup = associations_lookup(instance)
+        assoc_lookup_keys = assoc_lookup.keys
+        
+        form = ActiveForm::compose(*args)  
+        instance.class.columns.each do |column|
+          if column.primary
+            form << self.class.primary_key_column(column)
+          elsif column.name =~ /(_id)$/ && assoc_lookup_keys.include?(column.name)
+            form << association_column_to_element(assoc_lookup[column.name], column)
+          else
+            form << column_to_element(column)
+          end
+        end      
+        form.instance_eval(&block) if block_given?
+        form = instance.new_record? ? prepare_new_record(form, instance) : prepare_record(form, instance)
+        assign_validation(form, instance)
+        form
+      end
+      
+    end
+    
+  end
+end