formize 0.0.10 → 0.0.11

data/README.rdoc

@@ -4,21 +4,37 @@ Simple form DSL with dynamic interactions for Rails.
 
 == Installation
 
-Add it to your Gemfile:
+Add to your Gemfile these fllowing lines:
   gem "jquery-rails" # Need to be explicitly specified
   gem "formize"
 
+== Assets incorporation (JavaScripts and Stylesheets)
+Formize comes with basic scripts and stylesheets which must be included in the layout (at least at the start).
+
+=== In Rails 3.0.x
 Formize requires the gem +jquery-rails+, so if you don't already use it:
   rails generate jquery:install
 
 Then install +formize+ in your app like +jquery-rails+:
   rails generate formize:install
 
-It's not necessary, but I recommend to use HAML with it for cleaner views:
-  gem "haml"
+These previous commands install all the needed files in your +public/+ directory. 
+Then the files can be included with an helper:
+  # app/views/layouts/application.html.erb
+  <%= formize_include_tag -%>
+
+=== In Rails ≥ 3.1
+With the asset pipeline, there is no need to run generators or copy files. So for stylesheets:
+  # app/assets/stylesheets/application.css
+  *= require formize
+
+And for javascripts:
+  # app/assets/javascripts/application.js
+  *= require formize
 
 == Usage
 
+
 In controller:
 
   class OrdersController < ApplicationController

data/VERSION

@@ -1 +1 @@
-0.0.10
+0.0.11

data/lib/assets/javascripts/formize.js

@@ -103,6 +103,7 @@ Formize.Dialog = {
     },
 
     submitForm: function(form) {
+	var form = $(this);
         var dialog_id = form.attr('data-dialog');
         var dialog = $('#'+dialog_id);
 	
@@ -121,7 +122,7 @@ Formize.Dialog = {
 		    $(document).trigger("dom:update", dialog.attr('id'));
                 } else {
                     // Refresh element with its refresh URL
-                    var updated = $('#'+dialog.attr('data-dialog-update'));
+		    var updated_id = '#'+dialog.attr('data-dialog-update'), updated = $(updated_id);
                     if (updated[0] !== undefined) {
 			var url = updated.attr('data-refresh');
 			$.ajax(url, {
@@ -129,6 +130,7 @@ Formize.Dialog = {
 			    success: function(data2, textStatus2, request2) {
 				updated.replaceWith(request2.responseText);
 				$(document).trigger("dom:update");
+				$(updated_id+' input').trigger("emulated:change");
 			    }
 			});
                     }
@@ -171,6 +173,20 @@ Formize.refreshDependents = function (event) {
     return false;
 }
 
+Formize.Toggles = {
+
+    ifChecked: function () {
+	if (this.checked) {
+	    $($(this).attr('data-show')).slideDown();
+	    $($(this).attr('data-hide')).slideUp();
+	} else {
+	    $($(this).attr('data-show')).slideUp();
+	    $($(this).attr('data-hide')).slideDown();
+	}
+    }
+
+}
+
 
 /**
  * Special method which is a sharthand to bind every element
@@ -279,14 +295,16 @@ behave("a[data-close-dialog]", "click", function() {
 });
 
 // Submits dialog forms
-behave("form[data-dialog]", "submit", function() {
-    return Formize.Dialog.submitForm($(this));
-});
+behave("form[data-dialog]", "submit", Formize.Dialog.submitForm);
 
+// Refresh dependents on changes
 behave("*[data-dependents]", "change", Formize.refreshDependents);
+behave("*[data-dependents]", "emulated:change", Formize.refreshDependents);
 // Compensate for changes made with keyboard
 behave("select[data-dependents]", "keypress", Formize.refreshDependents);
-behave("*[data-dependents]", "emulated:change", Formize.refreshDependents);
+
+behave("input[data-show], input[data-hide]", "load", Formize.Toggles.ifChecked);
+behave("input[data-show], input[data-hide]", "change", Formize.Toggles.ifChecked);
 
 // Resizes the overlay automatically
 $(window).resize(function() {

data/lib/formize.rb

@@ -1,10 +1,14 @@
-require 'rubygems'
-require "bundler/setup"
-require 'active_support'
-# Formize provides controller's side defined forms.
+# require 'rubygems'
+# require 'bundler/setup'
+# require 'active_support'
+require 'formize/railtie' if defined?(::Rails)
+require 'formize/engine' if defined?(::Rails)
+
+# :include: ../README.rdoc
 module Formize
+  extend ActiveSupport::Autoload
 
-  def self.configure(name, value = nil)
+  def self.configure(name, value = nil) # :nodoc:
     unless self.respond_to?("#{name}=")
       # mattr_accessor(name)
       code  = "unless defined?(@@#{name})\n"
@@ -37,11 +41,11 @@ module Formize
   # How many select options can be displayed before to become a +unroll+
   configure :select_count_max, 7
 
+  autoload :Definition
+  autoload :Helpers
+  autoload :ActionController
+  autoload :Generator
 end
 
-require 'action_view'
-require 'formize/definition'
-require 'formize/generator'
-require 'formize/form_helper'
-require 'formize/action_pack'
+# require 'action_view'
 

data/lib/formize/{action_pack.rb → action_controller.rb}

@@ -21,13 +21,14 @@ module Formize
         options[:view_form_method_name]   = "_#{self.controller_name}_formize_form_#{name}_tag"
         options[:view_fields_method_name] = "_#{self.controller_name}_formize_fields_#{name}_tag"
         options[:method_name] = options[:view_fields_method_name]
-        form = Formize::Form.new(name, model, options)
+        options[:best_name] = "#{self.controller_name}#{'_'+name.to_s if name != self.controller_name.to_sym}"
+        form = Formize::Definition::Form.new(name, model, options)
         if block_given?
           yield form
         else
           formize_by_default(form)
         end
-        generator = Formize::Generator.new(form, self)
+        generator = Formize::Generator::Base.new(form, self)
         class_eval(generator.controller_code, "#{__FILE__}:#{__LINE__}")
         ActionView::Base.send(:class_eval, generator.view_code, "#{__FILE__}:#{__LINE__}")
       end
@@ -40,7 +41,7 @@ module Formize
           for column in form.model.columns
             next if column.name =~ /_count$/ or [:id, :created_at, :updated_at, :lock_version, :type, :creator_id, :updater_id].include?(column.name.to_sym)
             if column.name =~ /_id$/
-              reflections = form.model.reflections.select{|k, x| x.primary_key_name.to_s == column.name.to_s }
+              reflections = form.model.reflections.select{ |k, x| x.primary_key_name.to_s == column.name.to_s }
               if reflections.size == 1
                 f.field(column.name.gsub(/_id$/, ''), :choices=>:all, :source=>:foreign_class, :new=>true)
                 # elsif reflections.size > 1 # AMBIGUITY
@@ -60,5 +61,5 @@ module Formize
 
 end
 
-require 'action_controller'
-ActionController::Base.send(:include, Formize::ActionController)
+# require 'action_controller'
+# ActionController::Base.send(:include, Formize::ActionController)

data/lib/formize/definition.rb

@@ -1,5 +1,9 @@
-# require 'formize/definition/element'
-require 'formize/definition/form'
-require 'formize/definition/form_element'
-require 'formize/definition/field_set'
-require 'formize/definition/field'
+module Formize
+  # @private
+  module Definition
+    autoload :Form, 'formize/definition/form'
+    autoload :FormElement, 'formize/definition/form_element'
+    autoload :FieldSet, 'formize/definition/field_set'
+    autoload :Field, 'formize/definition/field'
+  end
+end

data/lib/formize/definition/field.rb

@@ -1,65 +1,67 @@
 module Formize
 
+  module Definition
 
-  # Represents the field element
-  class Field < FormElement
-    attr_reader :name, :options, :column, :record_name, :method, :type, :required, :choices, :input_id, :source, :item_label, :field_id, :reflection, :html_options, :default, :search_attributes
+    # Represents the field element
+    class Field < FormElement
+      attr_reader :name, :column, :record_name, :method, :type, :required, :choices, :input_id, :source, :item_label, :field_id, :reflection, :html_options, :default, :search_attributes
 
-    TYPES = [:check_box, :choice, :date, :datetime, :label, :numeric, :password, :mono_choice, :string, :text_area].freeze
+      TYPES = [:check_box, :choice, :date, :datetime, :label, :numeric, :password, :mono_choice, :string, :text_area].freeze
 
-    def initialize(form, parent, name, options={})
-      super(form, parent)
-      @name = name.to_s
-      @options = (options.is_a?(Hash) ? options : {})      
-      @column = form.model.columns_hash[@name]
-      @record_name = form.record_name
-      @method = @name
-      unless @options[:default].nil?
-        @default = (@options[:default].is_a?(String) ? Code.new(@options[:default]) : @options[:default])
-      end
-      @html_options = @options.delete(:html_options)||{}
-      @depend_on = @options.delete(:depend_on)
-      raise ArgumentError.new("A depended element must defined before its dependencies (#{@depended.inspect})") if !@depend_on.blank? and form.fields[@depend_on].nil?
-      if type = @options.delete(:as)
-        raise ArgumentError.new("Unknown field type (got #{@options[:as].inspect}, expects #{TYPES.join(', ')})") unless TYPES.include? type
-        @type = type
-      else
-        @type = :password if @name.to_s.match /password/
-        if @choices = @options.delete(:choices)
-          if @choices.is_a? Array
-            @type = :choice 
-          elsif [Symbol, Hash].include? @choices.class
-            @type = :mono_choice 
-            @reflection = form.model.reflections[@method.to_sym]
-            @source = @options.delete(:source) # || @reflection.class_name
-            @is_method = true if @options[:new]
-            @method_name = self.form.unique_name + "_inf_" + @name
-            @method = @reflection.primary_key_name
-            unless @item_label = @options.delete(:item_label)
-              model = @reflection.class_name.constantize
-              available_methods = (model.columns_hash.keys+model.instance_methods).collect{|x| x.to_s}
-              @item_label = [:label, :name, :title, :code, :number, :inspect].detect{|x| available_methods.include?(x.to_s)}
+      def initialize(form, parent, name, options={})
+        super(form, parent, options)
+        @name = name.to_s
+        @column = form.model.columns_hash[@name]
+        @record_name = form.record_name
+        @method = @name
+        unless @options[:default].nil?
+          @default = @options.delete(:default) # (@options[:default].is_a?(String) ? Formize::Generator::Code.new(@options[:default]) : @options[:default])
+        end
+        @html_options = @options.delete(:html_options)||{}
+        @depend_on = @options.delete(:depend_on)
+        raise ArgumentError.new("A depended element must defined before its dependencies (#{@depended.inspect})") if !@depend_on.blank? and form.all_fields[@depend_on].nil?
+        if type = @options.delete(:as)
+          raise ArgumentError.new("Unknown field type (got #{@options[:as].inspect}, expects #{TYPES.join(', ')})") unless TYPES.include? type
+          @type = type
+        else
+          @type = :password if @name.to_s.match /password/
+          if @choices = @options.delete(:choices)
+            if @choices.is_a? Array
+              @type = :choice 
+            elsif [Symbol, Hash].include? @choices.class
+              @type = :mono_choice 
+              @reflection = form.model.reflections[@method.to_sym]
+              @source = @options.delete(:source) # || @reflection.class_name
+              @is_method = true if @options[:new]
+              @method_name = self.form.unique_name + "_inf_" + @name
+              @method = @reflection.primary_key_name
+              unless @item_label = @options.delete(:item_label)
+                model = @reflection.class_name.constantize
+                available_methods = (model.columns_hash.keys+model.instance_methods).collect{|x| x.to_s}
+                @item_label = [:label, :name, :title, :code, :number, :inspect].detect{|x| available_methods.include?(x.to_s)}
+              end
+              @search_attributes = @options[:search] || @reflection.class_name.constantize.content_columns.select{|c| c.type != :boolean and ![:created_at, :updated_at, :lock_version].include?(c.name.to_sym)}.collect{|c| c.name.to_sym}
+            else
+              raise ArgumentError.new("Option :choices must be Array, Symbol or Hash (got #{@choices.class.name})")
             end
-            @search_attributes = @options[:search] || @reflection.class_name.constantize.content_columns.select{|c| c.type != :boolean and ![:created_at, :updated_at, :lock_version].include?(c.name.to_sym)}.collect{|c| c.name.to_sym}
-          else
-            raise ArgumentError.new("Option :choices must be Array, Symbol or Hash (got #{@choices.class.name})")
           end
+          if column
+            @type = :check_box if column.type == :boolean
+            @type = :date if column.type == :date
+            @type = :datetime if column.type==:datetime or column.type==:timestamp
+            @type = :numeric if [:integer, :float, :decimal].include? column.type
+            @type = :text_area if column.type == :text
+          end
+          @type = :label if @form.model.readonly_attributes.include? @record_name
+          @type ||= :string
         end
-        if column
-          @type = :check_box if column.type == :boolean
-          @type = :date if column.type == :date
-          @type = :datetime if column.type==:datetime or column.type==:timestamp
-          @type = :numeric if [:integer, :float, :decimal].include? column.type
-          @type = :text_area if column.type == :text
-        end
-        @type = :label if @form.model.readonly_attributes.include? @record_name
-        @type ||= :string
+        @required = false
+        @required = !@column.null if @column
+        @required = true if @options.delete(:required).is_a?(TrueClass)
+        @input_id = form.model.name.underscore << '_' << method.to_s
+        @field_id = "ff" << Time.now.to_i.to_s(36) << rand.to_s[2..-1].to_i.to_s(36)
       end
-      @required = false
-      @required = !@column.null if @column
-      @required = true if @options.delete(:required).is_a?(TrueClass)
-      @input_id = form.model.name.underscore << '_' << method.to_s
-      @field_id = "ff" << Time.now.to_i.to_s(36) << rand.to_s[2..-1].to_i.to_s(36)
+
     end
 
   end

data/lib/formize/definition/field_set.rb

@@ -1,40 +1,65 @@
 module Formize
+  
+  module Definition
 
+    # Represents a group of fields which can depend on other fields
+    class Group < FormElement
+      attr_reader :name, :options, :html_options
+      
+      def initialize(form, parent, name=nil, options={})
+        super(form, parent, options)
+        @name = if name.blank?
+                  rand.to_s[2..-1].to_i.to_s(36)
+                else
+                  raise ArgumentError.new("Name of group must be written only with a-z and 0-9 and _ (not #{name.inspect})") unless name.to_s == name.to_s.downcase.gsub(/[^a-z0-9\_]/, '')
+                  name.to_s
+                end
+        @depend_on = options.delete(:depend_on)
+        raise ArgumentError.new("A depended element must defined before its dependencies (#{@depended.inspect})") if !@depend_on.blank? and form.all_fields[@depend_on].nil?
+        @html_options = @options.delete(:html_options)||{}
+      end
 
 
-  # Represents a group of fields which can depend on other fields
-  class FieldSet < FormElement
-    attr_reader :name, :options, :title, :html_options
-    
-    def initialize(form, parent, name=nil, options={})
-      super(form, parent)
-      @title = nil
-      @name = if name.blank?
-                rand.to_s[2..-1].to_i.to_s(36)
-              else
-                raise ArgumentError.new("Name of field_set must be written only with a-z and 0-9 and _ (not #{name.inspect})") unless name.to_s == name.to_s.downcase.gsub(/[^a-z0-9\_]/, '')
-                @title = name
-                name.to_s
-              end
-      @depend_on = options.delete(:depend_on)
-      raise ArgumentError.new("A depended element must defined before its dependencies (#{@depended.inspect})") if !@depend_on.blank? and form.fields[@depend_on].nil?
-      @options = (options.is_a?(Hash) ? options : {})
-      @html_options = @options.delete(:html_options)||{}
-    end
+      def field_set(name=nil, options={}, &block)
+        raise ArgumentError.new("Missing block") unless block_given?
+        field_set = self.new_child(FieldSet, name, options)
+        yield field_set
+      end
 
+      def group(name=nil, options={}, &block)
+        raise ArgumentError.new("Missing block") unless block_given?
+        name, options = nil, name if name.is_a? Hash
+        group = self.new_child(Group, name, options)
+        yield group
+      end
 
-    def field_set(name=nil, options={}, &block)
-      raise ArgumentError.new("Missing block") unless block_given?
-      field_set = self.new_child(FieldSet, name, options)
-      yield field_set
-    end
+      def field(name, options={})
+        self.new_child(Field, name, options)
+      end
+
+      def fields(*args)
+        options = {}
+        options = args.delete_at(-1) if args[-1].is_a?(Hash)
+        for name in args
+          self.new_child(Field, name, options)
+        end
+      end
 
-    def field(name, options={})
-      self.new_child(Field, name, options)
     end
 
-  end
 
+    # Represents a set of fields which can depend on other fields
+    # It can be used with a title
+    class FieldSet < Group
+      attr_reader :title
+      
+      def initialize(form, parent, name=nil, options={})
+        super(form, parent, name, options)
+        @title = name
+      end
 
+    end
+
+  end
 
 end

data/lib/formize/definition/form.rb

@@ -1,89 +1,103 @@
-module Formize
-
-  # Represents an environment for a form or list of fields of one Record
-  class Form
-    attr_reader :model, :elements, :record_name, :unique_name, :options, :id
-    @@count = 0
-
-
-    def initialize(name, model, options={})
-      @name = name
-      @model = model
-      @options = options
-      @elements = []
-      @@count += 1
-      @id = @@count.to_s(36)
-      @unique_name = @options.delete(:unique_name) unless @options[:unique_name].blank?
-      @unique_name ||= "_formize#{@id}"
-      @record_name = @model.name.underscore
-    end
-
-    def field_set(name=nil, options={}, &block)
-      raise ArgumentError.new("Missing block") unless block_given?
-      field_set = new_element(FieldSet, name, options)
-      yield field_set
-    end
-
-    def field(name, options={})
-      return new_element(Field, name, options)
-    end
-    
-    # def inner_method_code(options={})
-    #   varh = options[:html_variable] || 'html'
-    #   code = "#{varh} = ''\n"
-    #   for child in children
-    #     code << "#{varh} << " << child.method_call_code << "\n"
-    #   end
-    #   code << "return #{varh}\n"
-    #   return code
-    # end
-
-    def controller_method_name
-      @options[:controller_method_name] || "formize_#{model.underscore}"
-    end
-
-    def view_method_name
-      @options[:method_name] || "_form_#{model.underscore}"
-    end
-
-    def action_name
-      @options[:action_name] || :formize
-    end
-
-    # def methodics
-    #   return elements.collect{|e| e.methodics}.flatten
-    # end
-
-    def mono_choices
-      return elements.collect{|e| e.mono_choices}.flatten
-    end
-
-    def fields
-      return elements.inject(HashWithIndifferentAccess.new){|h, e| h.merge!(e.fields)}
-    end
-
-    def dependents
-      return elements.collect{|e| e.dependents}.flatten
-    end
-
-    def all_elements
-      return elements.collect{|e| e.all_elements}.flatten
-    end
-
-    def dependents_on(element)
-      return elements.collect{|e| e.dependents_on(element)}.flatten
-    end
 
+module Formize
 
-    private
+  module Definition
+    # Represents an environment for a form or list of fields of one Record
+    class Form
+      attr_reader :elements, :model, :name, :record_name, :unique_name, :options, :id
+      @@count = 0
+
+
+      def initialize(name, model, options={})
+        @name = name
+        @model = model
+        @options = options
+        @elements = []
+        @@count += 1
+        @id = @@count.to_s(36)
+        @unique_name = @options.delete(:unique_name) unless @options[:unique_name].blank?
+        @unique_name ||= "_formize#{@id}"
+        @record_name = @model.name.underscore
+      end
+
+      def field_set(name=nil, options={}, &block)
+        raise ArgumentError.new("Missing block") unless block_given?
+        field_set = new_element(FieldSet, name, options)
+        yield field_set
+      end
+
+      def group(name, options={}, &block)
+        raise ArgumentError.new("Missing block") unless block_given?
+        name, options = nil, name if name.is_a? Hash
+        group = new_element(Group, name, options)
+        yield group
+      end
+
+      def field(name, options={})
+        return new_element(Field, name, options)
+      end
+
+      def fields(*args)
+        options = {}
+        options = args.delete_at(-1) if args[-1].is_a?(Hash)
+        for name in args
+          new_element(Field, name, options)
+        end
+      end
+
+      
+      # protected
+
+      def controller_method_name
+        @options[:controller_method_name] || "formize_#{model.underscore}"
+      end
+
+      def view_method_name
+        @options[:method_name] || "_form_#{model.underscore}"
+      end
+
+      def action_name
+        @options[:action_name] || :formize
+      end
+
+      def mono_choices
+        return elements.collect{|e| e.mono_choices}.flatten
+      end
+
+      def all_fields
+        return elements.inject(HashWithIndifferentAccess.new){|h, e| h.merge!(e.all_fields)}
+      end
+
+      def dependents
+        return elements.collect{|e| e.dependents}.flatten
+      end
+
+      def all_elements
+        return elements.collect{|e| e.all_elements}.flatten
+      end
+
+      def dependents_on(element)
+        return elements.collect{|e| e.dependents_on(element)}.flatten
+      end
+
+      def shown_if(element)
+        return elements.collect{|e| e.shown_if(element)}.flatten
+      end
+
+      def hidden_if(element)
+        return elements.collect{|e| e.hidden_if(element)}.flatten
+      end
+
+
+      private
+
+      def new_element(klass, *args)
+        raise ArgumentError.new("Bad child type: #{klass.name} (#{klass.ancestors.inspect}). Must be an Formize::Definition::FormElement") unless klass < Formize::Definition::FormElement # klass.ancestors.include? Formize::FormElement
+        element = klass.new(self, nil, *args)
+        @elements << element
+        return element
+      end
 
-    def new_element(klass, *args)
-      raise ArgumentError.new("Bad child type (#{klass.name}). Must be an Formize::FormElement") unless klass < FormElement
-      element = klass.new(self, nil, *args)
-      @elements << element
-      return element
     end
-
   end
-
 end