bureaucrat 0.0.1

data/lib/bureaucrat/widgets.rb

@@ -0,0 +1,397 @@
+require 'uri'
+
+require 'bureaucrat/utils'
+
+module Bureaucrat
+module Widgets
+  class Media
+    include Utils
+
+    MEDIA_TYPES = [:css, :js]
+    DEFAULT_MEDIA_PATH = 'http://localhost'
+
+    attr_accessor :media_path
+
+    def initialize(media_attrs={})
+      self.media_path = media_attrs.delete(:media_path) || DEFAULT_MEDIA_PATH
+      media_attrs = media_attrs.to_hash if media_attrs.is_a?(Media)
+      @css = {}
+      @js = []
+
+      MEDIA_TYPES.each do |name|
+          data = media_attrs[name]
+          add_type(name, data) if data
+        end
+    end
+
+    def to_s
+      render
+    end
+
+    def to_hash
+      hash = {}
+      MEDIA_TYPES.each {|name| hash[name] = instance_variable_get("@#{name}")}
+      hash
+    end
+
+    def render
+      mark_safe(MEDIA_TYPES.map do |name|
+                  render_type(name)
+                end.inject(&:+).join("\n"))
+    end
+
+    def render_type(type)
+      send("render_#{type}")
+    end
+
+    def render_js
+      @js.map do |path|
+          "<script type=\"text/javascript\" src=\"#{absolute_path(path)}\"></script>"
+        end
+    end
+
+    def render_css
+      fragments = @css.keys.sort.map do |medium|
+          @css[medium].map do |path|
+            "<link href=\"#{absolute_path(path)}\" type=\"text/css\" media=\"#{medium}\" rel=\"stylesheet\" />"
+          end
+        end
+      fragments.empty? ? fragments : fragments.inject(&:+)
+    end
+
+    def absolute_path(path)
+      path =~ /^(\/|https?:\/\/)/ ? path : URI.join(media_path, path)
+    end
+
+    def [](name)
+      raise IndexError("Unknown media type '#{name}'") unless
+        MEDIA_TYPES.include?(name)
+      Media.new(name => instance_variable_get("@{name}"))
+    end
+
+    def add_type(type, data)
+      send("add_#{type}", data)
+    end
+
+    def add_js(data)
+      @js += data.select {|path| !@js.include?(path)}
+    end
+
+    def add_css(data)
+      data.each do |medium, paths|
+          @css[medium] ||= []
+          css = @css[medium]
+          css.concat(paths.select {|path| !css.include?(path)})
+        end
+    end
+
+    def +(other)
+      combined = Media.new
+      MEDIA_TYPES.each do |name|
+          combined.add_type(name, instance_variable_get("@#{name}"))
+          combined.add_type(name, other.instance_variable_get("@#{name}"))
+        end
+      combined
+    end
+  end
+
+  class Widget
+    include Utils
+
+    class << self
+      attr_accessor :needs_multipart_form, :is_hidden
+
+      def inherited(c)
+        super(c)
+        c.is_hidden = is_hidden
+        c.needs_multipart_form = needs_multipart_form
+      end
+    end
+
+    self.needs_multipart_form = false
+    self.is_hidden = false
+
+    attr_reader :attrs
+
+    def initialize(attrs=nil)
+      @attrs = attrs.nil? ? {} : attrs.dup
+    end
+
+    def initialize_copy(original)
+      super(original)
+      @attrs = original.attrs.dup
+    end
+
+    def render(name, value, attrs=nil)
+      raise NotImplementedError
+    end
+
+    def build_attrs(extra_attrs=nil, options={})
+      attrs = @attrs.merge(options)
+      attrs.update(extra_attrs) if extra_attrs
+      attrs
+    end
+
+    def value_from_datahash(data, files, name)
+      return data[name]
+    end
+
+    def self.id_for_label(id_)
+      id_
+    end
+
+    def has_changed?(initial, data)
+      data_value = data || ''
+      initial_value = initial || ''
+      initial_value != data_value
+    end
+
+    def hidden?
+      self.class.is_hidden
+    end
+
+    def media
+      Media.new
+    end
+  end
+
+  class Input < Widget
+    class << self
+      attr_accessor :input_type
+
+      # Copy data to the child class
+      def inherited(c)
+        super(c)
+        c.input_type = input_type.dup if input_type
+      end
+    end
+
+    self.is_hidden = false
+    self.input_type = nil
+
+    def render(name, value, attrs=nil)
+      value ||= ''
+      final_attrs = build_attrs(attrs,
+                                :type => self.class.input_type.to_s,
+                                :name => name.to_s)
+      final_attrs[:value] = value.to_s unless value == ''
+      mark_safe("<input#{flatatt(final_attrs)} />")
+    end
+  end
+
+  class TextInput < Input
+    self.input_type = 'text'
+  end
+
+  class PasswordInput < Input
+    self.input_type = 'password'
+
+    def initialize(attrs=nil, render_value=true)
+      super(attrs)
+      @render_value = render_value
+    end
+
+    def render(name, value, attrs=nil)
+      value = nil unless @render_value
+      super(name, value, attrs)
+    end
+  end
+
+  class HiddenInput < Input
+    self.input_type = 'hidden'
+    self.is_hidden = true
+  end
+
+  class MultipleHiddenInput < HiddenInput
+    # Used by choice fields
+    attr_accessor :choices
+
+    def initialize(attrs=nil, choices=[])
+      super(attrs)
+      # choices can be any enumerable
+      @choices = choices
+    end
+
+    def render(name, value, attrs=nil, choices=[])
+      value ||= []
+      final_attrs = build_attrs(attrs, :type => self.class.input_type,
+                                :name => name)
+      mark_safe(value.map do |v|
+                  rattrs = {:value => v.to_s}.merge(final_attrs)
+                  "<input#{flatatt(rattrs)} />"
+                end.join("\n"))
+    end
+
+    def value_from_datahash(data, files, name)
+      #if data.is_a?(MultiValueDict) || data.is_a?(MergeDict)
+      #  data.getlist(name)
+      #else
+      #  data[name]
+      #end
+      data[name]
+    end
+  end
+
+  class FileInput < Input
+    self.input_type = 'file'
+    self.needs_multipart_form = true
+
+    def render(name, value, attrs=nil)
+      super(name, nil, attrs)
+    end
+
+    def value_from_datahash(data, files, name)
+      files.fetch(name, nil)
+    end
+
+    def has_changed?(initial, data)
+      data.nil?
+    end
+  end
+
+  class Textarea < Widget
+      def initialize(attrs=nil)
+        # The 'rows' and 'cols' attributes are required for HTML correctness.
+        @attrs = {:cols => '40', :rows => '10'}
+        @attrs.merge!(attrs) if attrs
+      end
+
+      def render(name, value, attrs=nil)
+        value ||= ''
+        final_attrs = build_attrs(attrs, :name => name)
+        mark_safe("<textarea#{flatatt(final_attrs)}>#{conditional_escape(value.to_s)}</textarea>")
+      end
+  end
+
+  # DateInput
+  # DateTimeInput
+  # TimeInput
+
+  class CheckboxInput < Widget
+    def initialize(attrs=nil, check_test=nil)
+      super(attrs)
+      @check_test = check_test || lambda {|v| make_bool(v)}
+    end
+
+    def render(name, value, attrs=nil)
+      final_attrs = build_attrs(attrs, :type => 'checkbox', :name => name.to_s)
+      result = self.check_test(value) rescue false
+      final_attrs[:checked] = 'checked' if result
+      final_attrs[:value] = value.to_s unless
+        ['', true, false, nil].include?(value)
+      mark_safe("<input#{flatatt(final_attrs)} />")
+    end
+
+    def value_from_datahash(data, files, name)
+      data.include?(name) ? super(data, files, name) : false
+    end
+
+    def has_changed(initial, data)
+      make_bool(initial) != make_bool(data)
+    end
+  end
+
+  class Select < Widget
+    attr_accessor :choices
+
+    def initialize(attrs=nil, choices=[])
+      super(attrs)
+      @choices = choices.collect
+    end
+
+    def render(name, value, attrs=nil, choices=[])
+      value = '' if value.nil?
+      final_attrs = build_attrs(attrs, :name => name)
+      output = ["<select#{flatatt(final_attrs)}>"]
+      options = render_options(choices, [value])
+      output << options if options && !options.empty?
+      output << '</select>'
+      mark_safe(output.join("\n"))
+    end
+
+    def render_options(choices, selected_choices)
+      selected_choices = selected_choices.map(&:to_s).uniq
+      output = []
+      (@choices + choices).each do |option_value, option_label|
+          if option_label.is_a?(Array)
+            output << '<optgroup label="%s">' % escape(option_value.to_s)
+            option_label.each do |option|
+              val, label = option
+              output << render_option(val, label, selected_choices)
+            end
+            output << '</optgroup>'
+          else
+            output << render_option(option_value, option_label,
+                                    selected_choices)
+          end
+        end
+      output.join("\n")
+    end
+
+    def render_option(option_value, option_label, selected_choices)
+      option_value = option_value.to_s
+      selected_html = selected_choices.include?(option_value) ? ' selected="selected"' : ''
+      "<option value=\"#{escape(option_value)}\"#{selected_html}>#{conditional_escape(option_label.to_s)}</option>"
+    end
+  end
+
+  class NullBooleanSelect < Select
+    def initialize(attrs=nil)
+      choices = [['1', 'Unknown'], ['2', 'Yes'], ['3', 'No']]
+      super(attrs, choices)
+    end
+
+    def render(name, value, attrs=nil, choices=[])
+      value = case value
+              when true, '2' then '2'
+              when false, '3' then '3'
+              else '1'
+              end
+      super(name, value, attrs, choices)
+    end
+
+    def value_from_datahash(data, files, name)
+      value = data[name]
+      case value
+      when '2', true then true
+      when '3', false then false
+      else nil
+      end
+    end
+
+    def has_changed?(initial, data)
+      make_bool(initial) != make_bool(data)
+    end
+  end
+
+  class SelectMultiple < Select
+    def render(name, value, attrs=nil, choices=[])
+      value = [] if value.nil?
+      final_attrs = build_attrs(attrs, :name => name)
+      output = ["<select multiple=\"multiple\"#{flatatt(final_attrs)}>"]
+      options = render_options(choices, value)
+      output << options if options && !options.empty?
+      output << '</select>'
+      mark_safe(output.join("\n"))
+    end
+
+    def value_from_datahash(data, files, name)
+      #if data.is_a?(MultiValueDict) || data.is_a?(MergeDict)
+      #  data.getlist(name)
+      #else
+      #  data[name]
+      #end
+      data[name]
+    end
+
+    def has_changed?(initial, data)
+      initial = [] if initial.nil?
+      data = [] if data.nil?
+      return true if initial.length != data.length
+      initial.zip(data).each do |value1, value2|
+          return true if value1.to_s != value2.to_s
+        end
+      false
+    end
+  end
+end; end

data/lib/bureaucrat/wizard.rb

@@ -0,0 +1,220 @@
+require 'digest'
+
+require 'bureaucrat/forms'
+# import cPickle as pickle
+
+# from django.conf import settings
+# from django.http import Http404
+# from django.shortcuts import render_to_response
+# from django.template.context import RequestContext
+# from django.utils.hashcompat import md5_constructor
+# from django.utils.translation import ugettext_lazy as _
+
+module Bureaucrat; Wizard
+  module Utils
+    def security_hash(request, form, *args)
+      data = []
+      form.each do |bf|
+        value = if form.empty_permitted? && ! form.changed? then bf.data
+                else bf.field.clean(bf.data)
+                end
+        value ||= ''
+        value = value.strip if value.respond_to? :strip
+        data.append([bf.name, value])
+      end
+
+      data += args
+      data << settings.SECRET_KEY # FIXME
+
+      Digest::MD5.hexdigest(Marshal.dump(data))
+    end
+
+    module_function :security_hash
+  end
+
+  class FormWizard
+    # FIXME
+    # The HTML (and POST data) field name for the "step" variable.
+
+    class << self
+      attr_accessor :step_field_name
+    end
+
+    self.step_field_name = "wizard_step"
+
+    def initialize(form_list, initial=Hash.new)
+      @form_list = form_list.dup
+      @initial = initial
+      @step = 0
+    end
+
+    def get_form(step, data=nil)
+      @form_list[step].new(data,
+                           :prefix => prefix_for_step(step),
+                           :initial => @initial.fetch(step, nil))
+    end
+
+    def num_steps
+      @form_list.length
+    end
+
+    def new(request, *args)
+      current_step = determine_step(request, *args)
+      parse_params(request, *args)
+
+      raise ArgumentError("Step #{current_step} does not exist") if
+        current_step >= num_steps
+
+      (0...current_step).each do |i|
+        form = get_form(i, request.POST)
+
+        return render_hash_failure(request, i) if
+          request.POST.fetch("hash_#{i}", '') != security_hash(request, form)
+
+        process_step(request, form, i)
+      end
+
+      form = get_form(current_step, request.post? ? request.POST : nil)
+
+      if form.valid?
+        process_step(request, form, current_step)
+        next_step = current_step + 1
+
+        if next_step == num_steps
+          final_form_list = (0...num_steps).map {|i| get_form(i, request.POST)}
+
+          final_form_list.each_with_index do |f, i|
+            return render_revalidation_failure(request, i, f) unless f.valid?
+          end
+
+          return done(request, final_form_list)
+        else
+          form = get_form(next_step)
+          @step = current_step = next_step
+        end
+      end
+
+      render(form, request, current_step)
+    end
+
+    def render(form, request, step, context=nil)
+      "Renders the given Form object, returning an HttpResponse." # FIXME
+      old_data = request.POST
+      prev_fields = []
+
+      if old_data
+        hidden = Widgets::HiddenInput.new
+        # Collect all data from previous steps and render it as HTML hidden fields.
+        (0...step).each do |i|
+          old_form = get_form(i, old_data)
+          hash_name = "hash_#{i}"
+          hash = old_data[hash_name] || security_hash(request, old_form)
+          prev_fields += old_form.map {|bf| bf.as_hidden}
+          prev_fields << hidden.render(hash_name, hash)
+        end
+      end
+
+      render_template(request, form, prev_fields.join(''), step, context)
+    end
+
+    # METHODS SUBCLASSES MIGHT OVERRIDE IF APPROPRIATE
+
+    def prefix_for_step(step)
+      step.to_s
+    end
+
+    def render_hash_failure(request, step)
+      # Hook for rendering a template if a hash check failed.
+
+      # step is the step that failed. Any previous step is guaranteed to be
+      # valid.
+
+      # This default implementation simply renders the form for the given step,
+      # but subclasses may want to display an error message, etc.
+      render(get_form(step), request, step, :context => {:wizard_error => _('We apologize, but your form has expired. Please continue filling out the form from this page.')})
+    end
+
+    def render_revalidation_failure(request, step, form)
+      # Hook for rendering a template if final revalidation failed.
+
+      # It is highly unlikely that this point would ever be reached, but See
+      # the comment in __call__() for an explanation.
+      render(form, request, step)
+    end
+
+    def security_hash(request, form)
+      Utils::security_hash(request, form)
+    end
+
+    def determine_step(request, *args)
+      if request.post?
+        begin
+          Integer(request.POST.fetch(step_field_name, 0))
+        rescue ArgumentError
+          0
+        end
+      else
+        0
+      end
+    end
+
+    def parse_params(request, *args)
+    end
+
+    def get_template(step)
+      'forms/wizard.erb'
+    end
+
+    def render_template(request, form, previous_fields, step, context=nil)
+
+      # Renders the template for the given step, returning an HttpResponse object.
+
+      # Override this method if you want to add a custom context, return a
+      # different MIME type, etc. If you only need to override the template
+      # name, use get_template() instead.
+
+      # The template will be rendered with the following context:
+      #     step_field -- The name of the hidden field containing the step.
+      #     step0      -- The current step (zero-based).
+      #     step       -- The current step (one-based).
+      #     step_count -- The total number of steps.
+      #     form       -- The Form instance for the current step (either empty
+      #                   or with errors).
+      #     previous_fields -- A string representing every previous data field,
+      #                   plus hashes for completed forms, all in the form of
+      #                   hidden fields. Note that you'll need to run this
+      #                   through the 'safe' template filter, to prevent
+      #                   auto-escaping, because it's raw HTML.
+
+      context ||= {}
+      # FIXME
+      render_to_response(get_template(step),
+                         context.merge(:step_field => step_field_name,
+                                       :step0 => step,
+                                       :step => step + 1,
+                                       :step_count => num_steps,
+                                       :form => form,
+                                       :previous_fields => previous_fields),
+                         :context_instance => RequestContext(request))
+    end
+
+    def process_step(request, form, step)
+      # Hook for modifying the FormWizard's internal state, given a fully
+      # validated Form object. The Form is guaranteed to have clean, valid
+      # data.
+
+      # This method should *not* modify any of that data. Rather, it might want
+      # to set self.extra_context or dynamically alter self.form_list, based on
+      # previously submitted forms.
+
+      # Note that this method is called every time a page is rendered for *all*
+      # submitted steps.
+    end
+
+    # METHODS SUBCLASSES MUST OVERRIDE ########################################
+
+    def done(request, form_list)
+      raise NotImplementedError.new("#{self.class.name} doesn't define the required 'done' method.")
+    end
+  end
+end

data/lib/bureaucrat.rb

@@ -0,0 +1,10 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+module Bureaucrat
+  VERSION = '0.0.1'
+end
+
+require 'bureaucrat/widgets'
+require 'bureaucrat/fields'
+require 'bureaucrat/forms'