bureaucrat 0.0.3 → 0.10.0

data/lib/bureaucrat/quickfields.rb

@@ -1,64 +1,92 @@
-require 'bureaucrat/fields'
-
 module Bureaucrat
-module Quickfields
-  include Fields
-
-  def hide(name)
-    base_fields[name] = base_fields[name].dup
-    base_fields[name].widget = Widgets::HiddenInput.new
-  end
-
-  def string(name, options={})
-    field name, CharField.new(options)
-  end
-
-  def text(name, options={})
-    field name, CharField.new(options.merge(:widget => Widgets::Textarea.new))
-  end
-
-  def password(name, options={})
-    field name, CharField.new(options.merge(:widget => Widgets::PasswordInput.new))
+  # Shortcuts for declaring form fields
+  module Quickfields
+    include Fields
+
+    # Hide field named +name+
+    def hide(name)
+      base_fields[name] = base_fields[name].dup
+      base_fields[name].widget = Widgets::HiddenInput.new
+    end
+
+    # Delete field named +name+
+    def delete(name)
+      base_fields.delete name
+    end
+
+    # Declare a +CharField+ with text input widget
+    def string(name, options = {})
+      field name, CharField.new(options)
+    end
+
+    # Declare a +CharField+ with text area widget
+    def text(name, options = {})
+      field name, CharField.new(options.merge(widget: Widgets::Textarea.new))
+    end
+
+    # Declare a +CharField+ with password widget
+    def password(name, options = {})
+      field name, CharField.new(options.merge(widget: Widgets::PasswordInput.new))
+    end
+
+    # Declare an +IntegerField+
+    def integer(name, options = {})
+      field name, IntegerField.new(options)
+    end
+
+    # Declare a +BigDecimalField+
+    def decimal(name, options = {})
+      field name, BigDecimalField.new(options)
+    end
+
+    # Declare a +RegexField+
+    def regex(name, regexp, options = {})
+      field name, RegexField.new(regexp, options)
+    end
+
+    # Declare an +EmailField+
+    def email(name, options = {})
+      field name, EmailField.new(options)
+    end
+
+    # Declare a +FileField+
+    def file(name, options = {})
+      field name, FileField.new(options)
+    end
+
+    # Declare a +BooleanField+
+    def boolean(name, options = {})
+      field name, BooleanField.new(options)
+    end
+
+    # Declare a +NullBooleanField+
+    def null_boolean(name, options = {})
+      field name, NullBooleanField.new(options)
+    end
+
+    # Declare a +ChoiceField+ with +choices+
+    def choice(name, choices = [], options = {})
+      field name, ChoiceField.new(choices, options)
+    end
+
+    # Declare a +TypedChoiceField+ with +choices+
+    def typed_choice(name, choices = [], options = {})
+      field name, TypedChoiceField.new(choices, options)
+    end
+
+    # Declare a +MultipleChoiceField+ with +choices+
+    def multiple_choice(name, choices = [], options = {})
+      field name, MultipleChoiceField.new(choices, options)
+    end
+
+    # Declare a +ChoiceField+ using the +RadioSelect+ widget
+    def radio_choice(name, choices = [], options = {})
+      field name, ChoiceField.new(choices, options.merge(widget: Widgets::RadioSelect.new))
+    end
+
+    # Declare a +MultipleChoiceField+ with the +CheckboxSelectMultiple+ widget
+    def checkbox_multiple_choice(name, choices = [], options = {})
+      field name, MultipleChoiceField.new(choices, options.merge(widget: Widgets::CheckboxSelectMultiple.new))
+    end
   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
+end

data/lib/bureaucrat/temporary_uploaded_file.rb

@@ -0,0 +1,14 @@
+module Bureaucrat
+  class TemporaryUploadedFile
+    attr_accessor :filename, :content_type, :name, :tempfile, :head
+
+    def initialize(data)
+      @filename = data[:filename]
+      @content_type = data[:content_type]
+      @name = data[:name]
+      @tempfile = data[:tempfile]
+      @size = @tempfile.size
+      @head = data[:head]
+    end
+  end
+end

data/lib/bureaucrat/utils.rb

@@ -1,84 +1,101 @@
 module Bureaucrat
-module Utils
+  module Utils
+    extend self
 
-  module SafeData
-  end
+    module SafeData
+    end
 
-  class SafeString < String
-    include SafeData
+    class SafeString < String
+      include SafeData
 
-    def +(rhs)
-      rhs.is_a?(SafeString) ? SafeString.new(super(rhs)) : super(rhs)
+      def +(rhs)
+        rhs.is_a?(SafeString) ? SafeString.new(super(rhs)) : super(rhs)
+      end
     end
-  end
 
-  # Dumb implementation that is good enough for Forms
-  class OrderedHash < Hash
-    def initialize
-      super()
-      @ordered_keys = []
-    end
+    class StringAccessHash < Hash
+      def initialize(other = {})
+        super()
+        update(other)
+      end
 
-    def []=(key, value)
-      super(key, value)
-      @ordered_keys << key unless @ordered_keys.include?(key)
-    end
+      def []=(key, value)
+        super(key.to_s, value)
+      end
 
-    def each
-      @ordered_keys.each do |key|
-          yield key, self[key]
-        end
-    end
+      def [](key)
+        super(key.to_s)
+      end
 
-    def initialize_copy(original)
-      super(original)
-      @ordered_keys = original.instance_eval('@ordered_keys').dup
+      def fetch(key, *args)
+        super(key.to_s, *args)
+      end
+
+      def include?(key)
+        super(key.to_s)
+      end
+
+      def update(other)
+        other.each_pair{|k, v| self[k] = v}
+        self
+      end
+
+      def merge(other)
+        dup.update(other)
+      end
+
+      def delete(key)
+        super(key.to_s)
+      end
     end
-  end
 
-module_function
+    def blank_value?(value)
+      !value || value == ''
+    end
 
-  def mark_safe(s)
-    s.is_a?(SafeData) ? s : SafeString.new(s.to_s)
-  end
+    def mark_safe(s)
+      s.is_a?(SafeData) ? s : SafeString.new(s.to_s)
+    end
 
-  ESCAPES = {
-    '&' => '&amp;',
-    '<' => '&lt;',
-    '>' => '&gt;',
-    '"' => '&quot;',
-    "'" => '&#39;'
-  }
-  def escape(html)
-    mark_safe(html.gsub(/[&<>"']/) {|match| ESCAPES[match]})
-  end
+    ESCAPES = {
+      '&' => '&amp;',
+      '<' => '&lt;',
+      '>' => '&gt;',
+      '"' => '&quot;',
+      "'" => '&#39;'
+    }
+    def escape(html)
+      mark_safe(html.gsub(/[&<>"']/) {|match| ESCAPES[match]})
+    end
 
-  def conditional_escape(html)
-    html.is_a?(SafeData) ? html : escape(html)
-  end
+    def conditional_escape(html)
+      html.is_a?(SafeData) ? html : escape(html)
+    end
 
-  def flatatt(attrs)
-    attrs.map {|k, v| " #{k}=\"#{conditional_escape(v)}\""}.join('')
-  end
+    def flatatt(attrs)
+      attrs.map {|k, v| " #{k}=\"#{conditional_escape(v)}\""}.join('')
+    end
 
-  def format_string(string, values)
-    output = string.dup
-    values.each_pair do |variable, value|
+    def format_string(string, values)
+      output = string.dup
+      values.each_pair do |variable, value|
         output.gsub!(/%\(#{variable}\)s/, value.to_s)
       end
-    output
-  end
+      output
+    end
 
-  def pretty_name(name)
-    name.to_s.capitalize.gsub(/_/, ' ')
-  end
+    def pretty_name(name)
+      name.to_s.capitalize.gsub(/_/, ' ')
+    end
 
-  def make_float(value)
-    value += '0' if value.is_a?(String) && value != '.' && value[-1,1] == '.'
-    Float(value)
-  end
+    def make_float(value)
+      value += '0' if value.is_a?(String) && value != '.' && value[-1,1] == '.'
+      Float(value)
+    end
+
+    def make_bool(value)
+      !(value.respond_to?(:empty?) ? value.empty? : [0, nil, false].include?(value))
+    end
 
-  def make_bool(value)
-    !(value.respond_to?(:empty?) ? value.empty? : [0, nil, false].include?(value))
   end
-end; end
+end

data/lib/bureaucrat/validators.rb

@@ -0,0 +1,163 @@
+module Bureaucrat
+  module Validators
+    def empty_value?(value)
+      value.nil? || value == '' || value == [] || value == {}
+    end
+    module_function :empty_value?
+
+    class RegexValidator
+      attr_accessor :regex, :message, :code
+
+      def initialize(options = {})
+        @regex = Regexp.new(options.fetch(:regex, ''))
+        @message = options.fetch(:message, 'Enter a valid value.')
+        @code = options.fetch(:code, :invalid)
+      end
+
+      # Validates that the input validates the regular expression
+      def call(value)
+        if regex !~ value
+          raise ValidationError.new(@message, code, regex: regex)
+        end
+      end
+    end
+
+    ValidateInteger = lambda do |value|
+      begin
+        Integer(value)
+      rescue ArgumentError
+        raise ValidationError.new('')
+      end
+    end
+
+    # Original from Django's EmailField:
+    # email_re = re.compile(
+    #    r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*"  # dot-atom
+    #    r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"' # quoted-string
+    #    r')@(?:[A-Z0-9]+(?:-*[A-Z0-9]+)*\.)+[A-Z]{2,6}$', re.IGNORECASE)  # domain
+    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}$
+    /xi
+
+    ValidateEmail =
+      RegexValidator.new(regex: EMAIL_RE,
+                         message: 'Enter a valid e-mail address.')
+
+    SLUG_RE = /^[-\w]+$/
+
+    ValidateSlug =
+      RegexValidator.new(regex: SLUG_RE,
+                         message: "Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens.")
+
+    IPV4_RE = /^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$/
+
+    IPV4Validator =
+      RegexValidator.new(regex: IPV4_RE,
+                         message: 'Enter a valid IPv4 address.')
+
+    COMMA_SEPARATED_INT_LIST_RE = /^[\d,]+$/
+
+    ValidateCommaSeparatedIntegerList =
+      RegexValidator.new(regex: COMMA_SEPARATED_INT_LIST_RE,
+                         message: 'Enter only digits separated by commas.',
+                         code: :invalid)
+
+    class BaseValidator
+      def initialize(limit_value)
+        @limit_value = limit_value
+      end
+
+      def message
+        'Ensure this value is %(limit_value)s (it is %(show_value)s).'
+      end
+
+      def code
+        :limit_value
+      end
+
+      def compare(a, b)
+        a.object_id != b.object_id
+      end
+
+      def clean(x)
+        x
+      end
+
+      def call(value)
+        cleaned = clean(value)
+        params = { limit_value: @limit_value, show_value: cleaned }
+
+        if compare(cleaned, @limit_value)
+          msg = Utils.format_string(message, params)
+          raise ValidationError.new(msg, code, params)
+        end
+      end
+    end
+
+    class MaxValueValidator < BaseValidator
+      def message
+        'Ensure this value is less than or equal to %(limit_value)s.'
+      end
+
+      def code
+        :max_value
+      end
+
+      def compare(a, b)
+        a > b
+      end
+    end
+
+    class MinValueValidator < BaseValidator
+      def message
+        'Ensure this value is greater than or equal to %(limit_value)s.'
+      end
+
+      def code
+        :min_value
+      end
+
+      def compare(a, b)
+        a < b
+      end
+    end
+
+    class MinLengthValidator < BaseValidator
+      def message
+        'Ensure this value has at least %(limit_value)d characters (it has %(show_value)d).'
+      end
+
+      def code
+        :min_length
+      end
+
+      def compare(a, b)
+        a < b
+      end
+
+      def clean(x)
+        x.length
+      end
+    end
+
+    class MaxLengthValidator < BaseValidator
+      def message
+        'Ensure this value has at most %(limit_value)d characters (it has %(show_value)d).'
+      end
+
+      def code
+        :max_length
+      end
+
+      def compare(a, b)
+        a > b
+      end
+
+      def clean(x)
+        x.length
+      end
+    end
+  end
+end