mutations 0.5.0

data/lib/mutations/command.rb

@@ -0,0 +1,149 @@
+# IDEA i just had (protected parameters):
+# optional do
+#   boolean :skip_confirmation, protected: true
+# end
+# Given the above, skip_confirmation is only accepted as a parameter if it's passed in a later hash, eg this would make it take:
+# User::ChangeEmail.run!(params, user: current_user, skip_confirmation: true)
+# But this would not:
+# params = {user: current_user, skip_confirmation: true}
+# User::ChangeEmail.run!(params)
+
+
+module Mutations
+  class Command
+    
+    ##
+    ## 
+    ##
+    class << self
+      def required(&block)
+        self.input_filters.required(&block)
+        
+        self.input_filters.required_keys.each do |key|
+          define_method(key) do 
+            @filtered_input[key]
+          end
+          
+          define_method("#{key}_present?") do 
+            @filtered_input.has_key?(key)
+          end
+          
+          define_method("#{key}=") do |v|
+            @filtered_input[key] = v
+          end
+        end
+      end
+      
+      def optional(&block)
+        self.input_filters.optional(&block)
+        
+        self.input_filters.optional_keys.each do |key|
+          define_method(key) do 
+            @filtered_input[key]
+          end
+          
+          define_method("#{key}_present?") do 
+            @filtered_input.has_key?(key)
+          end
+          
+          define_method("#{key}=") do |v|
+            @filtered_input[key] = v
+          end
+        end
+      end
+      
+      def run(*args)
+        new(*args).execute!
+      end
+      
+      def run!(*args)
+        m = run(*args)
+        if m.success?
+          m.result
+        else
+          raise ValidationException.new(m.errors)
+        end
+      end
+      
+      def input_filters
+        @input_filters ||= begin
+          if Command == self.superclass
+            HashFilter.new
+          else
+            self.superclass.input_filters.dup
+          end
+        end
+      end
+      
+    end
+  
+    # Instance methods
+    def initialize(*args)
+      if args.length == 0
+        @original_hash = {}
+      else
+        @original_hash = args.shift
+        raise ArgumentError.new("All arguments must be hashes") unless @original_hash.is_a?(Hash)
+        @original_hash = @original_hash.with_indifferent_access
+      end
+      
+      args.each do |a|
+        raise ArgumentError.new("All arguments must be hashes") unless a.is_a?(Hash)
+        @original_hash.merge!(a)
+      end
+    end
+    
+    def input_filters
+      self.class.input_filters
+    end
+    
+    def execute!
+      @filtered_input, @errors = self.input_filters.filter(@original_hash)
+      return Outcome.new(false, nil, @errors) if @errors
+      
+      # IDEA/TODO: run validate block
+      
+      r = execute
+      if @errors # Execute can add errors
+        return Outcome.new(false, nil, @errors)
+      else
+        return Outcome.new(true, r, nil)
+      end
+    end
+    
+    # add_error("name", :too_short)
+    # add_error("colors.foreground", :not_a_color) # => to create errors = {colors: {foreground: :not_a_color}}
+    # or, supply a custom message:
+    # add_error("name", :too_short, "The name 'blahblahblah' is too short!")
+    def add_error(key, kind, message = nil)
+      raise ArgumentError.new("Invalid kind") unless kind.is_a?(Symbol)
+      
+      @errors ||= ErrorHash.new
+      cur_errors = @errors
+      parts = key.to_s.split(".")
+      while part = parts.shift
+        part = part.to_sym
+        if parts.length > 0
+          cur_errors[part] = ErrorHash.new unless cur_errors[part].is_a?(ErrorHash)
+          cur_errors = cur_errors[part]
+        else
+          cur_errors[part] = ErrorAtom.new(key, kind, message: message)
+        end
+      end
+      @errors
+    end
+    
+    def merge_errors(hash)
+      @errors ||= ErrorHash.new
+      @errors.merge!(hash)
+    end
+    
+    def inputs
+      @filtered_input
+    end
+    
+    def execute
+      # Meant to be overridden
+    end
+  end
+end

data/lib/mutations/errors.rb

@@ -0,0 +1,152 @@
+module Mutations
+  
+  # Offers a non-localized, english only, non configurable way to get error messages.  This probably isnt good enough for users as-is.
+  class DefaultErrorMessageCreator
+    
+    MESSAGES = Hash.new("is invalid").tap do |h|
+      h.merge!(
+        # General
+        nils: "can't be nil",
+        required: "is required",
+      
+        # Datatypes
+        string: "isn't a string",
+        integer: "isn't an integer",
+        boolean: "isn't a boolean",
+        hash: "isn't a hash",
+        array: "isn't an array",
+        model: "isn't the right class",
+        
+        # String
+        empty: "can't be blank",
+        max_length: "is too long",
+        min_length: "is too short",
+        matches: "isn't in the right format",
+        in: "isn't an option",
+        
+        # Array
+        class: "isn't the right class",
+        
+        # Integer
+        min: "is too small",
+        max: "is too big",
+        
+        # Model
+        new_records: "isn't a saved model"
+      )
+    end
+    
+    # Key is either a symbol or a fixnum
+    def message(key, error_symbol, options = {})
+      if options[:index]
+        "#{(key || 'array').to_s.titleize}[#{options[:index]}] #{MESSAGES[error_symbol]}"
+      else
+        "#{key.to_s.titleize} #{MESSAGES[error_symbol]}"
+      end
+    end
+  end
+
+  
+  class ErrorAtom
+
+    # NOTE: in the future, could also pass in:
+    #  - error type
+    #  - value (eg, string :name, length: 5 # value=5)
+
+    # ErrorAtom.new(:name, :too_short)
+    # ErrorAtom.new(:name, :too_short, message: "is too short")
+    def initialize(key, error_symbol, options = {})
+      @key = key
+      @symbol = error_symbol
+      @message = options[:message]
+      @index = options[:index]
+    end
+
+    def symbolic
+      @symbol
+    end
+
+    def message
+      @message ||= Mutations.error_message_creator.message(@key, @symbol, index: @index)
+    end
+
+    def message_list
+      Array(message)
+    end
+  end
+
+  # mutation.errors is an ErrorHash instance like this:
+  # {
+  #   email: ErrorAtom(:matches),
+  #   name: ErrorAtom(:too_weird, message: "is too weird"),
+  #   adddress: { # Nested ErrorHash object
+  #     city: ErrorAtom(:not_found, message: "That's not a city, silly!"),
+  #     state: ErrorAtom(:in)
+  #   }
+  # }
+  class ErrorHash < HashWithIndifferentAccess
+
+    # Returns a nested HashWithIndifferentAccess where the values are symbols.  Eg:
+    # {
+    #   email: :matches,
+    #   name: :too_weird,
+    #   adddress: {
+    #     city: :not_found,
+    #     state: :in
+    #   }
+    # }
+    def symbolic
+      HashWithIndifferentAccess.new.tap do |hash|
+        each do |k, v|
+          hash[k] = v.symbolic
+        end
+      end
+    end
+
+    # Returns a nested HashWithIndifferentAccess where the values are messages. Eg:
+    # {
+    #   email: "isn't in the right format",
+    #   name: "is too weird",
+    #   adddress: {
+    #     city: "is not a city",
+    #     state: "isn't a valid option"
+    #   }
+    # }
+    def message
+      HashWithIndifferentAccess.new.tap do |hash|
+        each do |k, v|
+          hash[k] = v.message
+        end
+      end
+    end
+
+    # Returns a flat array where each element is a full sentence. Eg:
+    # [
+    #   "Email isn't in the right format.",
+    #   "Name is too weird",
+    #   "That's not a city, silly!",
+    #   "State isn't a valid option."
+    # ]
+    def message_list
+      list = []
+      each do |k, v|
+        list.concat(v.message_list)
+      end
+      list
+    end
+  end
+  
+  class ErrorArray < Array
+    def symbolic
+      map {|e| e && e.symbolic }
+    end
+
+    def message
+      map {|e| e && e.message }
+    end
+
+    def message_list
+      compact.map {|e| e.message_list }.flatten
+    end
+  end
+end

data/lib/mutations/exception.rb

@@ -0,0 +1,13 @@
+module Mutations
+  class ValidationException < ::StandardError
+    attr_accessor :errors
+    
+    def initialize(errors)
+      self.errors = errors
+    end
+    
+    def to_s
+      "Mutations::ValidationException: #{self.errors.message_list.join('; ')}"
+    end
+  end
+end

data/lib/mutations/hash_filter.rb

@@ -0,0 +1,131 @@
+module Mutations
+  class HashFilter < InputFilter
+    @default_options = {
+      nils: false,            # true allows an explicit nil to be valid. Overrides any other options
+    }
+    
+    attr_accessor :optional_inputs
+    attr_accessor :required_inputs
+    
+    def initialize(opts = {}, &block)
+      super(opts)
+      
+      @optional_inputs = {}
+      @required_inputs = {}
+      @current_inputs = @required_inputs
+      
+      if block_given?
+        instance_eval &block
+      end
+    end
+    
+    def dup
+      dupped = HashFilter.new
+      @optional_inputs.each_pair do |k, v|
+        dupped.optional_inputs[k] = v
+      end
+      @required_inputs.each_pair do |k, v|
+        dupped.required_inputs[k] = v
+      end
+      dupped
+    end
+    
+    def required(&block)
+      # TODO: raise if nesting is wrong
+      @current_inputs = @required_inputs
+      instance_eval &block
+    end
+    
+    def optional(&block)
+      # TODO: raise if nesting is wrong
+      @current_inputs = @optional_inputs
+      instance_eval &block
+    end
+    
+    def required_keys
+      @required_inputs.keys
+    end
+    
+    def optional_keys
+      @optional_inputs.keys
+    end
+    
+    # Basic types:
+    def string(name, options = {})
+      @current_inputs[name.to_sym] = StringFilter.new(options)
+    end
+    
+    def integer(name, options = {})
+      @current_inputs[name.to_sym] = IntegerFilter.new(options)
+    end
+    
+    def boolean(name, options = {})
+      @current_inputs[name.to_sym] = BooleanFilter.new(options)
+    end
+    
+    def hash(name, options = {}, &block)
+      @current_inputs[name.to_sym] = HashFilter.new(options, &block)
+    end
+    
+    # Advanced types
+    def model(name, options = {})
+      name_sym = name.to_sym
+      @current_inputs[name_sym] = ModelFilter.new(name_sym, options)
+    end
+    
+    def array(name, options = {}, &block)
+      name_sym = name.to_sym
+      @current_inputs[name.to_sym] = ArrayFilter.new(name_sym, options, &block)
+    end
+    
+    def filter(data)
+      
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+      
+      # Ensure it's a hash
+      return [data, :hash] unless data.is_a?(Hash)
+      
+      # We always want a hash with indiffernet access
+      unless data.is_a?(HashWithIndifferentAccess)
+        data = data.with_indifferent_access
+      end
+      
+      errors = ErrorHash.new
+      filtered_data = HashWithIndifferentAccess.new
+      
+      [[@required_inputs, true], [@optional_inputs, false]].each do |(inputs, is_required)|
+        inputs.each_pair do |key, filterer|
+          data_element = data[key]
+          default_used = false
+          if !data.has_key?(key) && filterer.has_default?
+            data_element = filterer.default
+            default_used = true
+          end
+          
+          if data.has_key?(key) || default_used
+            sub_data, sub_error = filterer.filter(data_element)
+
+            if sub_error.nil?
+              filtered_data[key] = sub_data
+            else
+              sub_error = ErrorAtom.new(key, sub_error) if sub_error.is_a?(Symbol)
+              errors[key] = sub_error
+            end
+          elsif is_required
+            errors[key] = ErrorAtom.new(key, :required)
+          end
+        end
+      end
+      
+      if errors.any?
+        [data, errors]
+      else
+        [filtered_data, nil]     # We win, it's valid!
+      end
+    end
+  end
+end