input_sanitizer 0.2.2 → 0.3.33

data/lib/input_sanitizer/extended_converters/comma_joined_integers_converter.rb

@@ -0,0 +1,15 @@
+module InputSanitizer
+  class CommaJoinedIntegersConverter
+    def call(value)
+      value = value.to_s
+      non_valid = value.gsub(/[0-9,]/, "")
+
+      if non_valid.empty?
+        value.split(",").map(&:to_i)
+      else
+        invalid_chars = non_valid.split(//).join(", ")
+        raise InputSanitizer::ConversionError.new("Invalid integers: #{invalid_chars}")
+      end
+    end
+  end
+end

data/lib/input_sanitizer/extended_converters/comma_joined_strings_converter.rb

@@ -0,0 +1,15 @@
+module InputSanitizer
+  class CommaJoinedStringsConverter
+    def call(value)
+      value = value.to_s
+      non_valid = value.gsub(/[a-zA-Z,_]/, "")
+
+      if non_valid.empty?
+        value.split(",").map(&:to_s)
+      else
+        invalid_chars = non_valid.split(//).join(", ")
+        raise InputSanitizer::ConversionError.new("Invalid strings: #{invalid_chars}")
+      end
+    end
+  end
+end

data/lib/input_sanitizer/extended_converters/positive_integer_converter.rb

@@ -0,0 +1,12 @@
+module InputSanitizer
+  class PositiveIntegerConverter < V1::IntegerConverter
+    def call(value)
+      super.tap { |value| raise_error if value <= 0 }
+    end
+
+    private
+    def raise_error
+      raise ConversionError.new("invalid integer (neagtive or zero)")
+    end
+  end
+end

data/lib/input_sanitizer/extended_converters/specific_values_converter.rb

@@ -0,0 +1,19 @@
+module InputSanitizer
+  class SpecificValuesConverter
+    def initialize(values)
+      @valid_values = values
+    end
+
+    def call(value)
+      case
+      when @valid_values.include?(value)
+        value
+      when value.respond_to?(:to_sym) && @valid_values.include?(value.to_sym)
+        value.to_sym
+      else
+        values_joined = @valid_values.join(", ")
+        raise InputSanitizer::ConversionError.new("Possible values: #{values_joined}")
+      end
+    end
+  end
+end

data/lib/input_sanitizer/extended_converters.rb

@@ -1,55 +1,5 @@
-module InputSanitizer
-  class PositiveIntegerConverter < IntegerConverter
-    def call(value)
-      val = super
-      raise ConversionError.new("invalid integer (neagtive or zero)") if val <= 0
-      val
-    end
-  end
-
-  class CommaJoinedIntegersConverter
-    def call(value)
-      non_valid = value.gsub(/[0-9,]/, "")
-      if non_valid.empty?
-        parts = value.split(",").map(&:to_i)
-      else
-        invalid_chars = non_valid.split(//)
-        invalid_chars_desc = invalid_chars.join(", ")
-        raise InputSanitizer::ConversionError.new("Invalid chars: #{invalid_chars_desc}")
-      end
-    end
-  end
-
-  class CommaJoinedStringsConverter
-    def call(value)
-      non_valid = value.gsub(/[a-zA-Z,]/, "")
-      if non_valid.empty?
-        parts = value.split(",").map(&:to_s)
-      else
-        invalid_chars = non_valid.split(//)
-        invalid_chars_desc = invalid_chars.join(", ")
-        raise InputSanitizer::ConversionError.new("Invalid chars: #{invalid_chars_desc}")
-      end
-    end
-  end
-
-  class SpecificValuesConverter
-    def initialize(values)
-      @valid_values = values
-    end
-
-    def call(value)
-      found = @valid_values.include?(value) ? value : nil
-      if !found
-        found = @valid_values.include?(value.to_sym) ? value.to_sym : nil
-      end
-      if !found
-        values_joined = @valid_values.join(", ")
-        error_message = "Possible values: #{values_joined}"
-        raise InputSanitizer::ConversionError.new(error_message)
-      else
-        found
-      end
-    end
-  end
-end
+dir = File.dirname(__FILE__)
+require File.join(dir, 'extended_converters', 'positive_integer_converter')
+require File.join(dir, 'extended_converters', 'comma_joined_integers_converter')
+require File.join(dir, 'extended_converters', 'comma_joined_strings_converter')
+require File.join(dir, 'extended_converters', 'specific_values_converter')

data/lib/input_sanitizer/restricted_hash.rb

@@ -1,24 +1,65 @@
 module InputSanitizer
-  class KeyNotAllowedError < ArgumentError; end
-
   class RestrictedHash < Hash
     def initialize(allowed_keys)
-      @allowed_keys = allowed_keys
-      super() { |hash, key| default_for_key(key) }
+      @allowed_keys = Set.new(allowed_keys)
+      super()
+    end
+
+    def [](key)
+      raise_not_allowed(key) unless key_allowed?(key)
+      fetch(key, nil)
+    end
+
+    def []=(key, val)
+      @allowed_keys.add(key)
+      super
+    end
+
+    def store(key, val)
+      @allowed_keys.add(key)
+      super
+    end
+
+    def merge!(hash, &block)
+      @allowed_keys.merge(Set[*hash.keys])
+      super
+    end
+
+    def merge(hash, &block)
+      @allowed_keys.merge(Set[*hash.keys])
+      super
     end
 
     def key_allowed?(key)
       @allowed_keys.include?(key)
     end
 
-    private
-    def default_for_key(key)
-      key_allowed?(key) ? nil : raise_not_allowed(key)
+    def transform_keys
+      return enum_for(:transform_keys) unless block_given?
+
+      new_allowed_keys = @allowed_keys.map { |key| yield(key) }
+      result = self.class.new(new_allowed_keys)
+      each_key do |key|
+        result[yield(key)] = self[key]
+      end
+      result
     end
 
+    def transform_keys!
+      return enum_for(:transform_keys!) unless block_given?
+
+      @allowed_keys.map! { |key| yield(key) }
+      keys.each do |key|
+        self[yield(key)] = delete(key)
+      end
+      self
+    end
+
+    private
+
     def raise_not_allowed(key)
       msg = "Key not allowed: #{key}"
-      raise KeyNotAllowedError.new(msg)
+      raise KeyNotAllowedError, msg
     end
   end
 end

data/lib/input_sanitizer/v1/clean_field.rb

@@ -0,0 +1,38 @@
+InputSanitizer::V1::CleanField = MethodStruct.new(:data, :has_key, :converter, :required, :collection, :namespace, :default, :provide, :allow) do
+  def call
+    if has_key
+      convert
+    elsif default
+      converter.call(default)
+    elsif required
+      raise InputSanitizer::ValueMissingError
+    else
+      raise InputSanitizer::OptionalValueOmitted
+    end
+  end
+
+  private
+  def convert
+    if collection
+      data.map { |value| convert_single(value) }
+    else
+      convert_single(data)
+    end
+  end
+
+  def convert_single(value)
+    if namespace
+      { namespace => convert_value(value[namespace]) }
+    else
+      convert_value(value)
+    end
+  end
+
+  def convert_value(value)
+    if provide
+      converter.call(value, provide)
+    else
+      converter.call(value)
+    end
+  end
+end

data/lib/input_sanitizer/{default_converters.rb → v1/default_converters.rb}

@@ -1,15 +1,12 @@
 require 'time'
 require 'date'
 
-module InputSanitizer
-  class ConversionError < Exception
-  end
-
+module InputSanitizer::V1
   class IntegerConverter
     def call(value)
       cast = value.to_i
       if cast.to_s != value.to_s
-        raise ConversionError.new("invalid integer")
+        raise InputSanitizer::ConversionError.new("invalid integer")
       end
       cast
     end
@@ -25,10 +22,10 @@ module InputSanitizer
     ISO_RE = /\A\d{4}-?\d{2}-?\d{2}/
 
     def call(value)
-      raise ConversionError.new("invalid time") unless value =~ ISO_RE
+      raise InputSanitizer::ConversionError.new("invalid time") unless value =~ ISO_RE
       Date.parse(value)
     rescue ArgumentError
-      raise ConversionError.new("invalid iso8601 date")
+      raise InputSanitizer::ConversionError.new("invalid iso8601 date")
     end
   end
 
@@ -43,13 +40,13 @@ module InputSanitizer
         if value =~ ISO_RE
           strip_timezone(Time.parse(value))
         else
-          raise ConversionError.new("invalid time")
+          raise InputSanitizer::ConversionError.new("invalid time")
         end
       else
-        raise ConversionError.new("invalid time")
+        raise InputSanitizer::ConversionError.new("invalid time")
       end
     rescue ArgumentError
-      raise ConversionError.new("invalid time")
+      raise InputSanitizer::ConversionError.new("invalid time")
     end
 
     def strip_timezone(time)
@@ -84,7 +81,7 @@ module InputSanitizer
         message += " for true, or "
         message += falsy.join(", ")
         message += " for false."
-        raise ConversionError.new(message)
+        raise InputSanitizer::ConversionError.new(message)
       end
     end
   end

data/lib/input_sanitizer/v1/sanitizer.rb

@@ -0,0 +1,163 @@
+class InputSanitizer::V1::Sanitizer
+  def initialize(data)
+    @data = symbolize_keys(data)
+    @performed = false
+    @errors = []
+    @cleaned = InputSanitizer::RestrictedHash.new(self.class.fields.keys)
+  end
+
+  def self.clean(data)
+    new(data).cleaned
+  end
+
+  def [](field)
+    cleaned[field]
+  end
+
+  def cleaned
+    return @cleaned if @performed
+
+    perform_clean
+
+    @performed = true
+    @cleaned.freeze
+  end
+
+  def valid?
+    cleaned
+    @errors.empty?
+  end
+
+  def errors
+    cleaned
+    @errors
+  end
+
+  def self.converters
+    {
+      :integer => InputSanitizer::V1::IntegerConverter.new,
+      :string => InputSanitizer::V1::StringConverter.new,
+      :date => InputSanitizer::V1::DateConverter.new,
+      :time => InputSanitizer::V1::TimeConverter.new,
+      :boolean => InputSanitizer::V1::BooleanConverter.new,
+      :integer_or_blank => InputSanitizer::V1::IntegerConverter.new.extend(InputSanitizer::V1::AllowNil),
+      :string_or_blank => InputSanitizer::V1::StringConverter.new.extend(InputSanitizer::V1::AllowNil),
+      :date_or_blank => InputSanitizer::V1::DateConverter.new.extend(InputSanitizer::V1::AllowNil),
+      :time_or_blank => InputSanitizer::V1::TimeConverter.new.extend(InputSanitizer::V1::AllowNil),
+      :boolean_or_blank => InputSanitizer::V1::BooleanConverter.new.extend(InputSanitizer::V1::AllowNil),
+    }
+  end
+
+  def self.inherited(subclass)
+    subclass.fields = self.fields.dup
+  end
+
+  def self.initialize_types_dsl
+    converters.keys.each do |name|
+      class_eval <<-END
+        def self.#{name}(*keys)
+          set_keys_to_converter(keys, :#{name})
+        end
+      END
+    end
+  end
+
+  initialize_types_dsl
+
+  def self.custom(*keys)
+    options = keys.pop
+    converter = options.delete(:converter)
+    keys.push(options)
+    raise "You did not define a converter for a custom type" if converter == nil
+    self.set_keys_to_converter(keys, converter)
+  end
+
+  def self.nested(*keys)
+    options = keys.pop
+    sanitizer = options.delete(:sanitizer)
+    keys.push(options)
+    raise "You did not define a sanitizer for nested value" if sanitizer == nil
+    converter = lambda { |value|
+      instance = sanitizer.new(value)
+      raise InputSanitizer::ConversionError.new(instance.errors) unless instance.valid?
+      instance.cleaned
+    }
+
+    keys << {} unless keys.last.is_a?(Hash)
+    keys.last[:nested] = true
+
+    self.set_keys_to_converter(keys, converter)
+  end
+
+  protected
+  def self.fields
+    @fields ||= {}
+  end
+
+  def self.fields=(new_fields)
+    @fields = new_fields
+  end
+
+  private
+  def self.extract_options!(array)
+    array.last.is_a?(Hash) ? array.pop : {}
+  end
+
+  def perform_clean
+    self.class.fields.each { |field, hash| clean_field(field, hash) }
+  end
+
+  def clean_field(field, hash)
+    if hash[:options][:nested] && @data.has_key?(field)
+      if hash[:options][:collection]
+        raise InputSanitizer::ConversionError.new("expected an array") unless @data[field].is_a?(Array)
+      else
+        raise InputSanitizer::ConversionError.new("expected a hash") unless @data[field].is_a?(Hash)
+      end
+    end
+
+    @cleaned[field] = InputSanitizer::V1::CleanField.call(hash[:options].merge({
+      :has_key => @data.has_key?(field),
+      :data => @data[field],
+      :converter => hash[:converter],
+      :provide => @data[hash[:options][:provide]],
+    }))
+  rescue InputSanitizer::ConversionError => error
+    add_error(field, :invalid_value, @data[field], error.message)
+  rescue InputSanitizer::ValueMissingError => error
+    add_error(field, :missing, nil, nil)
+  rescue InputSanitizer::OptionalValueOmitted
+  end
+
+  def add_error(field, error_type, value, description = nil)
+    @errors << {
+      :field => field,
+      :type => error_type,
+      :value => value,
+      :description => description
+    }
+  end
+
+  def symbolize_keys(data)
+    data.inject({}) do |memo, kv|
+      memo[kv.first.to_sym] = kv.last
+      memo
+    end
+  end
+
+  def self.set_keys_to_converter(keys, converter_or_type)
+    options = extract_options!(keys)
+    converter = if converter_or_type.is_a?(Symbol)
+      converters[converter_or_type]
+    else
+      converter_or_type
+    end
+
+    keys.each do |key|
+      fields[key] = {
+        :converter => converter,
+        :options => options
+      }
+    end
+  end
+end