bureaucrat 0.0.1

data/lib/bureaucrat/utils.rb

@@ -0,0 +1,84 @@
+module Bureaucrat
+module Utils
+
+  module SafeData
+  end
+
+  class SafeString < String
+    include SafeData
+
+    def +(rhs)
+      rhs.is_a?(SafeString) ? SafeString.new(super(rhs)) : super(rhs)
+    end
+  end
+
+  # Dumb implementation that is good enough for Forms
+  class OrderedHash < Hash
+    def initialize
+      super()
+      @ordered_keys = []
+    end
+
+    def []=(key, value)
+      super(key, value)
+      @ordered_keys << key unless @ordered_keys.include?(key)
+    end
+
+    def each
+      @ordered_keys.each do |key|
+          yield key, self[key]
+        end
+    end
+
+    def initialize_copy(original)
+      super(original)
+      @ordered_keys = original.instance_eval('@ordered_keys').dup
+    end
+  end
+
+module_function
+
+  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
+
+  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 format_string(string, values)
+    output = string.dup
+    values.each_pair do |variable, value|
+        output.gsub!(/%\(#{variable}\)s/, value.to_s)
+      end
+    output
+  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_bool(value)
+    !(value.respond_to?(:empty?) ? value.empty? : [0, nil, false].include?(value))
+  end
+end; end

data/lib/bureaucrat/validation.rb

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

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