bureaucrat 0.0.3 → 0.10.0

metadata

@@ -1,36 +1,30 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: bureaucrat
-version: !ruby/object:Gem::Version 
-  version: 0.0.3
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Bruno Deferrari
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-11-03 00:00:00 -02:00
-default_executable: 
+date: 2012-04-14 00:00:00.000000000 Z
 dependencies: []
-
-description: 
+description: Bureaucrat is a form handling library for Ruby.
 email: utizoc@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/bureaucrat/fields.rb
 - lib/bureaucrat/forms.rb
 - lib/bureaucrat/formsets.rb
 - lib/bureaucrat/quickfields.rb
+- lib/bureaucrat/temporary_uploaded_file.rb
 - lib/bureaucrat/utils.rb
-- lib/bureaucrat/validation.rb
-- lib/bureaucrat/validation_old.rb
+- lib/bureaucrat/validators.rb
 - lib/bureaucrat/widgets.rb
-- lib/bureaucrat/wizard.rb
 - lib/bureaucrat.rb
 - README.md
 - LICENSE
@@ -39,33 +33,30 @@ files:
 - test/formsets_test.rb
 - test/test_helper.rb
 - test/widgets_test.rb
-has_rdoc: true
+- Rakefile
+- bureaucrat.gemspec
 homepage: http://github.com/tizoc/bureaucrat
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.11
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Form handling for Ruby inspired by Django forms.
 test_files: []
-

data/lib/bureaucrat/validation.rb

@@ -1,130 +0,0 @@
-require 'bureaucrat/utils'
-
-module Bureaucrat
-module Validation
-
-  class ValidationError < Exception
-    attr_reader :error_code, :parameters
-
-    def initialize(error_code, parameters=nil)
-      @error_code = error_code
-      @parameters = parameters || {}
-    end
-  end
-
-  module Validates
-    module_function
-    def fail_with(error_code, parameters=nil)
-      raise ValidationError.new(error_code, parameters)
-    end
-  end
-
-  module Converters
-    include Validates
-
-    module_function
-
-    def to_integer(string)
-      Integer(string)
-    rescue ArgumentError
-      fail_with(:invalid)
-    end
-
-    def to_float(string)
-      Utils.make_float(string)
-    rescue ArgumentError
-      fail_with(:invalid)
-    end
-
-    def to_big_decimal(string)
-      Utils.make_float(string)
-      BigDecimal.new(string)
-    rescue ArgumentError
-      fail_with(:invalid)
-    end
-
-    def to_bool(string)
-      ['false', '0'].include?(string) ? false : Utils.make_bool(string)
-    end
-  end
-
-  module Validators
-    include Validates
-
-    module_function
-
-    def empty_value?(value)
-      value.nil? || value == ''
-    end
-
-    def is_present(value)
-      fail_with(:required) if empty_value?(value)
-    end
-
-    def not_empty(value)
-      fail_with(:required) if value.empty?
-    end
-
-    def is_true(value)
-      fail_with(:required) unless value
-    end
-
-    def is_array(value)
-      fail_with(:invalid_list) unless value.kind_of(Array)
-    end
-
-    def has_min_length(value, min_length)
-      value_length = value.length
-      fail_with(:min_length, :min => min_length,
-                :length => value_length) if value_length < min_length
-    end
-
-    def has_max_length(value, max_length)
-      value_length = value.length
-      fail_with(:max_length, :max => max_length,
-                :length => value_length) if value_length > max_length
-    end
-
-    def is_not_lesser_than(value, min_value)
-      fail_with(:min_value, :min => min_value) if value < min_value
-    end
-
-    def is_not_greater_than(value, max_value)
-      fail_with(:max_value, :max => max_value) if value > max_value
-    end
-
-    def has_max_digits(value, max_digits)
-      sign, alldigits, _, whole_digits = value.split
-      fail_with(:max_digits, :max => max_digits) if alldigits > max_digits
-    end
-
-    def has_max_decimal_places(values, decimal_places)
-      sign, alldigits, _, whole_digits = value.split
-      decimals = alldigits.length - whole_digits
-      fail_with(:max_decimal_places, :max => decimal_places) if
-        decimals > decimal_places
-    end
-
-    def has_max_whole_digits(value, max_digits)
-      sign, alldigits, _, whole_digits = value.split
-      fail_with(:max_digits, :max => max_digits) if alldigits > max_digits
-    end
-
-    def included_in(value, collection)
-      fail_with(:not_included, :collection => collection) unless
-        collection.include?(value)
-    end
-
-    def matches_regex(value, regex, error_code=:invalid)
-      fail_with(error_code, :regex => regex) if regex !~ value
-    end
-
-    EMAIL_RE = /(^[-!#\$%&'*+\/=?^_`{}|~0-9A-Z]+(\.[-!#\$%&'*+\/=?^_`{}|~0-9A-Z]+)*|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-011\013\014\016-\177])*")@(?:[A-Z0-9]+(?:-*[A-Z0-9]+)*\.)+[A-Z]{2,6}$/i
-
-    def is_email(value)
-      matches_regex(value, EMAIL_RE)
-    end
-  end
-
-end
-end

data/lib/bureaucrat/validation_old.rb

@@ -1,148 +0,0 @@
-  module ValueValidator
-    def initialize_vv(format_validator, adaptor, value_validator)
-      @vv_format_validator = format_validator
-      @vv_adaptor = adaptor
-      @vv_value_validator = value_validator
-    end
-
-    # add_format_validator
-    # add_value_validator
-
-    def clean(value, all_values={}, object=nil)
-      return if @vv_format_validator.validate(value, all_values, object)
-      @vv_value_validator.validate(@vv_adaptor.call(value), all_values, object)
-    end
-  end
-
-    module Adaptors
-    class Adaptor
-      include Validates
-
-      def initialize(allow_blank=false)
-        @allow_blank = allow_blank
-      end
-
-      def to_object(value)
-        if blank?(value)
-          fail_with(:blank) unless @allow_blank
-          nil
-        else
-          adapt(value)
-        end
-      end
-
-      def adapt(value)
-        value
-      end
-    end
-
-    class IntegerAdaptor < Adaptor
-      def adapt(value)
-        begin
-          Integer(value)
-        rescue ArgumentError
-          fail_with(:not_integer)
-        end
-      end
-    end
-
-    class FloatAdaptor < Adaptor
-      include Bureaucrat::Utils
-
-      def adapt(value)
-        begin
-          make_float(value)
-        rescue ArgumentError
-          fail_with(:not_float)
-        end
-      end
-    end
-
-  end
-
-    class Validator
-      include Validates
-
-      def initialize(allow_blank=false)
-        @allow_blank = allow_blank
-      end
-
-      def valid?(value, all_values={}, object=nil)
-        validate(value, all_values, object)
-        true
-      end
-
-      def validate(value, all_values={}, object=nil)
-        blank?(value) && @allow_blank
-      end
-
-      def blank?(value)
-        value.nil? || value.empty?
-      end
-    end
-
-    class HasMinimumLengthOf < Validator
-      def initialize(min_length)
-        @min_length = min_length
-      end
-
-      def validate(value, all_values={}, object=nil)
-        value_length = value.length
-        fail_with(:min_length,
-                  :min_length => @min_length,
-                  :value_length => value_length) if value_length < @min_length
-      end
-    end
-
-    class HasMaximumLengthOf < Validator
-      def initialize(max_length)
-        @max_length = max_length
-      end
-
-      def validate(value, all_values={}, object=nil)
-        value_length = value.length
-        fail_with(:max_length,
-                  :max_length => @max_length,
-                  :value_length => value_length) if value_length < @max_length
-      end
-    end
-
-    class IsEqualOrGreaterThan < Validator
-      def initialize(min_value)
-        @min_value = min_value
-      end
-
-      def validate(value, all_values={}, object=nil)
-        fail_with(:less_than, :min_value => @min_value) if value < @min_value
-      end
-    end
-
-    class IsEqualOrLessThan < Validator
-      def initialize(max_value)
-        @max_value = max_value
-      end
-
-      def validate(value, all_values={}, object=nil)
-        fail_with(:more_than, :max_value => @max_value) if value > @max_value
-      end
-    end
-
-    class MatchesRegex < Validator
-      def initialize(regex, custom_error_code=nil)
-        @regex = regex
-        @custom_error_code = custom_error_code
-      end
-
-      def validate(value, all_values={}, object=nil)
-        fail_with(@custom_error_code || :not_matching_regex,
-                  :regex => @regex) if @regex !~ value
-      end
-    end
-
-    class IsEmail < MatchesRegex
-      EMAIL_RE = /(^[-!#\$%&'*+\/=?^_`{}|~0-9A-Z]+(\.[-!#\$%&'*+\/=?^_`{}|~0-9A-Z]+)*|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-011\013\014\016-\177])*")@(?:[A-Z0-9]+(?:-*[A-Z0-9]+)*\.)+[A-Z]{2,6}$/i
-
-      def initialize
-        super(EMAIL_RE, :is_not_email)
-      end
-    end

data/lib/bureaucrat/wizard.rb

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