bureaucrat 0.0.1

data/lib/bureaucrat/forms.rb

@@ -0,0 +1,346 @@
+require 'bureaucrat/utils'
+require 'bureaucrat/validation'
+require 'bureaucrat/widgets'
+require 'bureaucrat/fields'
+
+module Bureaucrat; module Forms
+  class BoundField
+    include Utils
+
+    attr_accessor :label
+
+    def initialize(form, field, name)
+      @form = form
+      @field = field
+      @name = name
+      @html_name = form.add_prefix(name).to_sym
+      @html_initial_name = form.add_initial_prefix(name).to_sym
+      @label = @field.label || pretty_name(name)
+      @help_text = @field.help_text || ''
+    end
+
+    def to_s
+      @field.show_hidden_initial ? as_widget + as_hidden(nil, true) : as_widget
+    end
+
+    def errors
+      @form.errors.fetch(@name, @form.error_class.new)
+    end
+
+    def as_widget(widget=nil, attrs=nil, only_initial=false)
+      widget ||= @field.widget
+      attrs ||= {}
+      auto_id = self.auto_id
+      attrs[:id] ||= auto_id if auto_id && !widget.attrs.key?(:id)
+
+      if !@form.bound?
+        data = @form.initial.fetch(@name, @field.initial)
+        data = data.call if data.respond_to?(:call)
+      else
+        if @field.is_a?(Fields::FileField) && @data.nil?
+          data = @form.initial.fetch(@name, @field.initial)
+        else
+          data = self.data
+        end
+      end
+
+      name = only_initial ? @html_initial_name : @html_name
+
+      widget.render(name.to_s, data, attrs)
+    end
+
+    def as_text(attrs=nil, only_initial=false)
+      as_widget(Widgets::TextInput.new, attrs, only_initial)
+    end
+
+    def as_textarea(attrs=nil, only_initial=false)
+      as_widget(Widgets::Textarea.new, attrs, only_initial)
+    end
+
+    def as_hidden(attrs=nil, only_initial=false)
+      as_widget(@field.hidden_widget, attrs, only_initial)
+    end
+
+    def data
+      @field.widget.value_from_datahash(@form.data, @form.files, @html_name)
+    end
+
+    def label_tag(contents=nil, attrs=nil)
+      contents ||= conditional_escape(@label)
+      widget = @field.widget
+      id_ = widget.attrs[:id] || self.auto_id
+
+      if id_
+        attrs = attrs ? flattatt(attrs) : ''
+        contents = "<label for=\"#{Widgets::Widget.id_for_label(id_)}\"#{attrs}>#{contents}</label>"
+      end
+
+      mark_safe(contents)
+    end
+
+    def hidden?
+      @field.widget.hidden?
+    end
+
+    def auto_id
+      fauto_id = @form.auto_id
+      fauto_id ? fauto_id % @html_name : ''
+    end
+  end
+
+  class Form
+    include Utils
+    include Validation
+
+    class << self
+      attr_writer :base_fields
+
+      def base_fields
+        @base_fields ||= Utils::OrderedHash.new
+      end
+
+      def field(name, field_obj)
+        base_fields[name] = field_obj
+      end
+
+      # Copy data to the child class
+      def inherited(c)
+        super(c)
+        c.base_fields = base_fields.dup
+      end
+    end
+
+    attr_accessor :error_class, :auto_id, :initial, :data, :files, :cleaned_data
+
+    def bound? ; @is_bound; end
+
+    def initialize(data=nil, options={})
+      @is_bound = !data.nil?
+      @data = data ? data.dup : {}
+      @data.each {|k, v| @data[k.to_sym] ||= v}
+      @files = options.fetch(:files, {})
+      @auto_id = options.fetch(:auto_id, 'id_%s')
+      @prefix = options[:prefix]
+      @initial = options.fetch(:initial, {})
+      @error_class = options.fetch(:error_class, Fields::ErrorList)
+      @label_suffix = options.fetch(:label_suffix, ':')
+      @empty_permitted = options.fetch(:empty_permitted, false)
+      @errors = nil
+      @changed_data = nil
+
+      @fields = self.class.base_fields.dup
+      @fields.each { |key, value| @fields[key] = value.dup }
+    end
+
+    def to_s
+      as_table
+    end
+
+    def [](name)
+      field = @fields[name] or return nil
+      BoundField.new(self, field, name)
+    end
+
+    def errors
+      full_clean if @errors.nil?
+      @errors
+    end
+
+    def valid?
+      @is_bound && (errors.nil? || errors.empty?)
+    end
+
+    def add_prefix(field_name)
+      @prefix ? :"#{@prefix}-#{field_name}" : field_name
+    end
+
+    def add_initial_prefix(field_name)
+      "initial-#{add_prefix(field_name)}"
+    end
+
+    def empty_permitted?
+      @empty_permitted
+    end
+
+    def as_table
+      html_output('<tr><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>',
+                  '<tr><td colspan="2">%s</td></tr>', '</td></tr>',
+                  '<br />%s', false)
+    end
+
+    def as_ul
+      html_output('<li>%(errors)s%(label)s %(field)s%(help_text)s</li>',
+                  '<li>%s</li>', '</li>', ' %s', false)
+    end
+
+    def as_p
+      html_output('<p>%(label)s %(field)s%(help_text)s</p>',
+                  '%s', '</p>', ' %s', true)
+    end
+
+    def non_field_errors
+      errors.fetch(:__NON_FIELD_ERRORS, @error_class.new)
+    end
+
+    def full_clean
+      @errors = Fields::ErrorHash.new
+
+      return unless bound?
+
+      @cleaned_data = {}
+
+      return if empty_permitted? && !changed?
+
+      @fields.each do |name, field|
+          value = field.widget.value_from_datahash(@data, @files,
+                                                   add_prefix(name))
+
+          begin
+            if field.is_a?(Fields::FileField)
+              initial = @initial.fetch(name, field.initial)
+              @cleaned_data[name] = field.clean(value, initial)
+            else
+              @cleaned_data[name] = field.clean(value)
+            end
+
+            clean_method = 'clean_%s' % name
+            @cleaned_data[name] = send(clean_method) if respond_to?(clean_method)
+          rescue Fields::FieldValidationError => e
+            @errors[name] = e.messages
+            @cleaned_data.clear
+          end
+        end
+
+      begin
+        @cleaned_data = clean
+      rescue Fields::FieldValidationError => e
+        @errors[:__NON_FIELD_ERRORS] = e.messages
+      end
+      @cleaned_data = nil if @errors && !@errors.empty?
+    end
+
+    def clean
+      @cleaned_data
+    end
+
+    def changed?
+      changed_data && !changed_data.empty?
+    end
+
+    def changed_data
+      if @changed_data.nil?
+        @changed_data = []
+
+        @fields.each do |name, field|
+            prefixed_name = add_prefix(name)
+            data_value = field.widget.value_from_datahash(@data, @files,
+                                                          prefixed_name)
+            if !field.show_hidden_initial
+              initial_value = @initial.fetch(name, field.initial)
+            else
+              initial_prefixed_name = add_initial_prefix(name)
+              hidden_widget = field.hidden_widget.new
+              initial_value = hidden_widget.value_from_datahash(@data, @files,
+                                                                initial_prefixed_name)
+            end
+
+            @changed_data << name if
+              field.widget.has_changed?(initial_value, data_value)
+          end
+      end
+
+      @changed_data
+    end
+
+    def media
+      @fields.values.inject(Widgets::Media.new) do |media, field|
+          media + field.widget.media
+        end
+    end
+
+    def multipart?
+      @fields.any? {|f| f.widgetneeds_multipart_form?}
+    end
+
+    def hidden_fields
+      @fields.select {|f| f.hidden?}
+    end
+
+    def visible_fields
+      @fields.select {|f| !f.hidden?}
+    end
+
+  private
+    def html_output(normal_row, error_row, row_ender, help_text_html,
+                    errors_on_separate_row)
+      top_errors = non_field_errors
+      output, hidden_fields = [], []
+
+      add_fields_output(output, hidden_fields, normal_row, error_row,
+                        help_text_html, errors_on_separate_row, top_errors)
+      output = [error_row % top_errors] + output unless top_errors.empty?
+      add_hidden_fields_output(output, hidden_fields, row_ender)
+
+      mark_safe(output.join("\n"))
+    end
+
+    def add_fields_output(output, hidden_fields, normal_row, error_row,
+                          help_text_html, errors_on_separate_row,
+                          top_errors)
+      @fields.each do |name, field|
+          bf = BoundField.new(self, field, name)
+          bf_errors = @error_class.new(bf.errors.map {|e| conditional_escape(e)})
+          if bf.hidden?
+            top_errors += bf_errors.map do |e|
+              "(Hidden field #{name}) #{e.to_s}"
+            end unless bf_errors.empty?
+            hidden_fields << bf.to_s
+          else
+            output << error_row % bf_errors if
+              errors_on_separate_row && !bf_errors.empty?
+
+            label = ''
+            unless bf.label.nil? || bf.label.empty?
+              label = conditional_escape(bf.label)
+              label += @label_suffix if @label_suffix && label[-1,1] !~ /[:?.!]/
+              label = bf.label_tag(label)
+            end
+
+            help_text = field.help_text.empty? ? '' : help_text_html % field.help_text
+            vars = {
+              :errors => bf_errors, :label => label,
+              :field => bf, :help_text => help_text
+            }
+            output << format_string(normal_row, vars)
+          end
+        end
+    end
+
+    def add_hidden_fields_output(output, hidden_fields, row_ender)
+      unless hidden_fields.empty?
+        str_hidden = hidden_fields.join('')
+
+        unless output.empty?
+          last_row = output[-1]
+          if last_row !~ /#{row_ender}$/
+            vars = {
+              :errors => '', :label => '', :field => '', :help_text => ''
+            }
+            last_row = format_string(normal_row, vars)
+            output << last_row
+          end
+          output[-1] = last_row[0...-row_ender.length] + str_hidden + row_ender
+        else
+          output << str_hidden
+        end
+      end
+    end
+
+    def raw_value(fieldname)
+      field = @fields.fetch(fieldname)
+      prefix = add_prefix(fieldname)
+      field.widget.value_from_datahash(@data, @files, prefix)
+    end
+
+  end
+end; end

data/lib/bureaucrat/formsets.rb

@@ -0,0 +1,256 @@
+require 'bureaucrat/utils'
+require 'bureaucrat/validation'
+require 'bureaucrat/widgets'
+require 'bureaucrat/forms'
+
+# TODO: needs more testing
+module Bureaucrat
+module Formsets
+  TOTAL_FORM_COUNT = :'TOTAL_FORMS'
+  INITIAL_FORM_COUNT = :'INITIAL_FORMS'
+  ORDERING_FIELD_NAME = :'ORDER'
+  DELETION_FIELD_NAME = :'DELETE'
+
+  class ManagementForm < Forms::Form
+    include Fields
+    include Widgets
+
+    field TOTAL_FORM_COUNT, IntegerField.new(:widget => HiddenInput)
+    field INITIAL_FORM_COUNT, IntegerField.new(:widget => HiddenInput)
+  end
+
+  class BaseFormSet
+    include Utils
+    include Validation
+    include Fields
+    include Forms
+
+    def self.default_prefix
+      'form'
+    end
+
+    attr_accessor :form, :extra, :can_order, :can_delete, :max_num
+
+    def initialize(data=nil, options={})
+      @is_bound = !data.nil?
+      @prefix = options.fetch(:prefix, self.class.default_prefix)
+      @auto_id = options.fetch(:auto_id, 'id_%s')
+      @data = data
+      @files = options[:files]
+      @initial = options[:initial]
+      @error_class = options.fetch(:error_class, ErrorList)
+      @errors = nil
+      @non_form_errors = nil
+
+      construct_forms
+    end
+
+    def to_s
+      as_table
+    end
+
+    def management_form
+      if @data || @files
+        form = ManagementForm.new(@data, :auto_id => @auto_id,
+                                  :prefix => @prefix)
+        raise ValidationError.new('ManagementForm data is missing or has been tampered with') unless
+          form.valid?
+      else
+        form = ManagementForm.new(nil, :auto_id => @auto_id,
+                                  :prefix => @prefix,
+                                  :initial => {
+                                    TOTAL_FORM_COUNT => total_form_count,
+                                    INITIAL_FORM_COUNT => initial_form_count
+                                  })
+      end
+      form
+    end
+
+    def total_form_count
+      if @data || @files
+        management_form.cleaned_data[TOTAL_FORM_COUNT]
+      else
+        n = initial_form_count + self.extra
+        (n > self.max_num && self.max_num > 0) ? self.max_num : n
+      end
+    end
+
+    def initial_form_count
+      if @data || @files
+        management_form.cleaned_data[INITIAL_FORM_COUNT]
+      else
+        n = @initial ? @initial.length : 0
+        (n > self.max_num && self.max_num > 0) ? self.max_num : n
+      end
+    end
+
+    def construct_forms
+      @forms = (0...total_form_count).map { |i| construct_form(i) }
+    end
+
+    def construct_form(i, options={})
+      defaults = {:auto_id => @auto_id, :prefix => add_prefix(i)}
+      defaults[:files] = @files if @files
+      defaults[:initial] = @initial[i] if @initial && @initial[i]
+
+      # Allow extra forms to be empty.
+      defaults[:empty_permitted] = true if i >= initial_form_count
+      defaults.merge!(options)
+      form = self.form.new(@data, defaults)
+      add_fields(form, i)
+      form
+    end
+
+    def initial_forms
+      @forms[0, initial_form_count]
+    end
+
+    def extra_forms
+      n = initial_form_count
+      @forms[n, @forms.length - n]
+    end
+
+    # Maybe this should just go away?
+    def cleaned_data
+      unless valid?
+        raise NoMethodError.new("'#{self.class.name}' object has no method 'cleaned_data'")
+      end
+      @forms.collect(&:cleaned_data)
+    end
+
+    def deleted_forms
+      unless valid? && self.can_delete
+        raise NoMethodError.new("'#{self.class.name}' object has no method 'deleted_forms'")
+      end
+
+      if @deleted_form_indexes.nil?
+        @deleted_form_indexes = (0...total_form_count).select do |i|
+            form = @forms[i]
+            (i < initial_form_count || form.changed?) && form.cleaned_data[DELETION_FIELD_NAME]
+          end
+      end
+      @deleted_form_indexes.map {|i| @forms[i]}
+    end
+
+    def ordered_forms
+      unless valid? && self.can_order
+        raise NoMethodError.new("'#{self.class.name}' object has no method 'ordered_forms'")
+      end
+
+      if @ordering.nil?
+        @ordering = (0...total_form_count).map do |i|
+            form = @forms[i]
+            next if i >= initial_form_count && !form.changed?
+            next if self.can_delete && form.cleaned_data[DELETION_FIELD_NAME]
+            [i, form.cleaned_data[ORDERING_FIELD_NAME]]
+          end.compact
+        @ordering.sort! do |a, b|
+            if x[1].nil? then 1
+            elsif y[1].nil? then -1
+            else x[1] - y[1]
+            end
+          end
+      end
+
+      @ordering.map {|i| @forms[i.first]}
+    end
+
+    def non_form_errors
+      @non_form_errors || @error_class.new
+    end
+
+    def errors
+      full_clean if @errors.nil?
+      @errors
+    end
+
+    def valid?
+      return false unless @is_bound
+      forms_valid = true
+      (0...total_form_count).each do |i|
+          form = @forms[i]
+          if self.can_delete
+            field = form.fields[DELETION_FIELD_NAME]
+            raw_value = form.send(:raw_value, DELETION_FIELD_NAME)
+            should_delete = field.clean(raw_value)
+            next if should_delete
+          end
+          forms_valid = false unless errors[i].empty?
+        end
+      forms_valid && non_form_errors.empty?
+    end
+
+    def full_clean
+      if @is_bound
+        @errors = @forms.collect(&:errors)
+
+        begin
+          self.clean
+        rescue ValidationError => e
+          @non_form_errors = e.messages
+        end
+      else
+        @errors = []
+      end
+    end
+
+    def clean
+    end
+
+    def add_fields(form, index)
+      if self.can_order
+        attrs = {:label => 'Order', :required => false}
+        attrs[:initial] = index + 1 if index < initial_form_count
+        form.fields[ORDERING_FIELD_NAME] = IntegerField.new(attrs)
+      end
+      if self.can_delete
+        field = BooleanField.new(:label => 'Delete', :required => false)
+        form.fields[DELETION_FIELD_NAME] = field
+      end
+    end
+
+    def add_prefix(index)
+      '%s-%s' % [@prefix, index]
+    end
+
+    def multipart?
+      @forms && @forms.first.multipart?
+    end
+
+    def media
+      @forms ? @forms.first.media : Media.new
+    end
+
+    def as_table
+      forms = @forms.map(&:as_table).join(' ')
+      mark_safe([management_form.to_s, forms].join("\n"))
+    end
+  end
+
+  module_function
+
+  def make_formset_class(form, options={})
+    formset = options.fetch(:formset, BaseFormSet)
+    attrs = {
+        :form => form,
+        :extra => options.fetch(:extra, 1),
+        :can_order => options.fetch(:can_order, false),
+        :can_delete => options.fetch(:can_delete, false),
+        :max_num => options.fetch(:max_num, 0)
+      }
+    Class.new(formset) do
+        attrs.each do |name, value|
+          define_method(name) { value }
+        end
+      end
+  end
+
+  def all_valid?(formsets)
+    valid = true
+    formsets.each do |formset|
+        valid = false unless formset.valid?
+      end
+    valid
+  end
+
+end; end

data/lib/bureaucrat/quickfields.rb

@@ -0,0 +1,59 @@
+require 'bureaucrat/fields'
+
+module Bureaucrat
+module Quickfields
+  include Fields
+
+  def hide(name)
+    base_fields[name].widget = Widgets::HiddenInput.new
+  end
+
+  def string(name, options={})
+    field name, CharField.new(options)
+  end
+
+  def password(name, options={})
+    field name, CharField.new(options.merge(:widget => Widgets::PasswordInput.new))
+  end
+
+  def integer(name, options={})
+    field name, IntegerField.new(options)
+  end
+
+  def decimal(name, options={})
+    field name, BigDecimalField.new(options)
+  end
+
+  def regex(name, regexp, options={})
+    field name, RegexField.new(regexp, options)
+  end
+
+  def email(name, options={})
+    field name, EmailField.new(options)
+  end
+
+  def file(name, options={})
+    field name, FileField.new(options)
+  end
+
+  def boolean(name, options={})
+    field name, BooleanField.new(options)
+  end
+
+  def null_boolean(name, options={})
+    field name, NullBooleanField.new(options)
+  end
+
+  def choice(name, choices=[], options={})
+    field name, ChoiceField.new(choices, options)
+  end
+
+  def typed_choice(name, choices=[], options={})
+    field name, TypedChoiceField.new(choices, options)
+  end
+
+  def multiple_choice(name, choices=[], options={})
+    field name, MultipleChoiceField.new(choices, options)
+  end
+
+end; end