error_prone 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c35c189bd7720a73b92c1e9f71286844cc81138
+  data.tar.gz: d12ddc14a3dade563cc49f8f3adb6530a22c3d30
+SHA512:
+  metadata.gz: e1e02a55550ace75ae30e553ff764c10e2688ce5b0ea90b618c468b1055c955cab532550d0449c4fd17c9ea56bd361478c02cd699b7f10556627b16dad63ec9a
+  data.tar.gz: 9726de84a68b951b69ed47cdbf7ce8d37d5685a0548d0bfdca2bbb9b45645935813dbf9f4cec8dfe121fe3573f59bea84710d706b8d0ea41ad61cc16b85dd534

data/CHANGELOG.markdown

@@ -0,0 +1,2 @@
+### 0.1.0
+* Created initial feature set.

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Zee Spencer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,75 @@
+ErrorProne is a dependency free library that puts control of when, how, and
+where you validate your data in your capable hands.
+
+## Usage
+
+ErrorProne has 3 primary modules:
+
+  * {ErrorProne::Model}     - Object to validate
+  * {ErrorProne::Rule}      - Specific rule to determine a field is valid
+  * {ErrorProne::Validator} - Object which collects and applies
+    {ErrorProne::Rule Rules} for a {ErrorProne::Model Model}
+
+These are mixed in to your objects using the `include` method.
+
+### Example
+
+``` ruby
+class Person < Struct.new(:name, :email)
+  include ErrorProne::Model
+end
+
+class ValidEmail
+  include ErrorProne::Rule
+  validates_as :is_email
+
+  def verify!
+    value.include?("@") # WORST. VALIDATION. EVER
+  end
+
+  def message
+    :invalid_email
+  end
+end
+
+include ErrorProne::Validator
+validates :name,  :present
+validates :email, :is_email
+
+good_person = Person.new("Zee", "zee@example.com")
+validate!(good_person)
+p good_person.errors_for(:name) # []
+p good_person.errors_for(:email) # []
+p good_person.valid? # true
+
+bad_person = Person.new(nil, "foo")
+validate!(bad_person)
+p bad_person.valid? # false
+p bad_person.errors_for(:name) # [:missing]
+p bad_person.errors_for(:email) # [:invalid_email]
+```
+
+## Philosophy
+### Simple over Easy
+ErrorProne isn't designed to minimize keystrokes. Instead, it exhibits a
+pythonesque preference for expliciteness and minimal dependencies. This results
+in a library that is powerful, portable, and comprehensible. ErrorProne eschews
+metaprogramming in favor of a relatively boring codebase.
+
+### Supportive over Prescriptive
+We rubyists sometimes prefer beauty of DSL regardless of how it prods users
+towards highly coupled objects or locks them into an architecture that is more
+about the library than the problem they're solving. ErrorProne supports your
+design instead of prescribing it.
+
+## Contributing
+OSS is all about the community. Feel free to submit new features, documentation
+chagnes, and requests for help in the following ways:
+
+1. Submit a [pull request](pulls). Explain how your change meets the ErrorProne
+   [philosophy](#label-Philosophy). Include reasonable tests and rdoc.
+2. Open an [issue](issues). Explain how the proposed change meets the ErrorProne
+   [philosophy](#label-Philosophy).
+3. Ask a question on [Stack
+   Overflow](http://stackoverflow.com/questions/tagged/error-prone) and tweet
+   [@zspencer](http://twitter.com/zspencer) so I can answer it quickly

data/lib/error_prone.rb

@@ -0,0 +1,222 @@
+module ErrorProne
+
+
+  # Mixed in to objects you wish to validate.
+  #
+  # @example
+  #
+  #   class FakeModel < Struct.new(:name)
+  #     include ErrorProne::Model
+  #   end
+  #
+  #   model = FakeModel.new
+  #   model.valid?            # true
+  #   model.add_error(:name, :too_cool)
+  #   model.valid?            # false
+  #   model.errors_for(:name) # [:too_cool]
+
+  module Model
+
+    # @param  [Symbol] field The field to find errors for
+    # @return [Array] the errors for the given field
+    def errors_for(field)
+      errors.for(field)
+    end
+
+    # @return [ErrorProne::Errors]
+    def errors
+      @errors ||= Errors.new
+    end
+
+    # @param [Symbol] field Identifies which field to add an error to
+    # @param [Symbol] error Identifies the type of error that occured
+    # @return [self] The model itself
+    def add_error(field, error)
+      errors.add(field, error)
+      self
+    end
+
+    # @return [Boolean] false if errors had been added. True if no errors.
+    def valid?
+      errors.empty?
+    end
+  end
+
+  # Mixed in to objects that can verify whether an {ErrorProne::Model} is valid
+  # or not.
+  #
+  # @example
+  #   class FakeRule
+  #
+  #     include ErrorProne::Rule
+  #     validates_as :not_nil
+  #
+  #     def verify!
+  #       !value.nil?
+  #     end
+  #
+  #     def message
+  #       :field_nil
+  #     end
+  #   end
+  #
+  module Rule
+    module ClassMethods
+
+      # @param [Symbol] rule_name Name to use when using validates on an {ErrorProne::Validator}
+      def validates_as(rule_name)
+        RuleSet.available_rules[rule_name] = self
+      end
+    end
+
+
+    attr_reader :object, :field, :value
+    # @param [Object] object Object to verify conforms to a rule
+    # @param [Symbol] field Field on the object that must conform to the rule
+    # @param [Hash] options often specific to the the Rule
+    def initialize(object, field, options = {})
+      @object = object
+      @field = field
+      @options = options
+    end
+
+    # Adds error to the object if verify! fails
+    # @return [Boolean]
+    def validate!
+      @value = object.send(field)
+      return true if verify!
+      object.add_error(field, message)
+      false
+    end
+
+    # Message to add when validate! finds an error. Must override in
+    # implementing classes.
+    # @return [Symbol]
+    def message
+      raise "You must set a message for rules to work"
+    end
+
+    # Verifies if the rule is followed. Must override in implementing classes.
+    # @return [Boolean]
+    def verify!
+      raise "You must provide a verify! method for rules to work. verify! should return a boolean"
+    end
+
+    def self.included(klazz)
+      klazz.extend(ClassMethods)
+    end
+  end
+
+  # Mixed in to objects you wish to use to validate other objects
+  #
+  # @example
+  #   class ObjectToValidate < Struct.new(:name)
+  #     include ErrorProne::Model
+  #   end
+  #
+  #   class ObjectValidator
+  #     include ErrorProne::Validator
+  #     validates :name, :present
+  #   end
+  #
+  #   object = ObjectToValidate.new(nil)
+  #   ObjectValidator.new.validate!(object) # false
+  #   object.valid? # false
+  #   object.errors_for(:name) # [:missing]
+
+  module Validator
+
+    module ClassMethods
+      # Contains rules the validator will run when .validate! is called
+      #
+      # @return (ErrorProne::RuleSet)
+      def rules
+        @rules ||= RuleSet.new
+      end
+
+
+      # Adds a rule the validator runs when .validate! is called.
+      #
+      # @param (Symbol) field Method to call on the object to validate
+      # @param (Symbol) rule Name of rule to apply, defined by {ErrorProne::Rule}.validates_as
+      # @param (Hash) options to pass to the {ErrorProne::Rule} when instantiating
+      def validates(field, rule, options={})
+        rules.add(field, rule, options)
+      end
+
+      # Validates all rules against the given object
+      #
+      # @param (Object) object Object to validate each rule against
+      # @return (Boolean) True if all rules are valid, false otherwise.
+      def validate!(object)
+        rules.all_valid_for? object
+      end
+    end
+
+    # Alias for {ErrorProne::Validator}.validate
+    def validate!(object)
+      self.class.validate!(object)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+
+  class RuleSet < Hash
+    def self.available_rules
+      @available_rules ||= {}
+    end
+
+    def available_rules
+      self.class.available_rules
+    end
+
+    def for(field)
+      self[field] ||= []
+    end
+
+    def add(field, rule_name, options = {})
+      raise "rule #{rule_name} is not available" unless available_rules.has_key?(rule_name)
+      self.for(field).push(rule: available_rules[rule_name], options: options)
+      self
+    end
+
+
+    def all_valid_for?(object)
+      all? do |field, rules|
+        rules.all? do |rule_config|
+          rule = rule_config[:rule].new(object, field, rule_config[:options])
+          rule.validate!
+        end
+      end
+    end
+  end
+
+  class PresenceRule
+    include Rule
+    validates_as :present
+
+    def verify!
+      [:nil?, :empty?].select { |method| value.respond_to?(method) }.none? { |method|
+        value.send(method)
+      }
+    end
+
+    def message
+      :missing
+    end
+  end
+
+  class Errors < Hash
+    def add(field, error)
+      self.for(field).push(error)
+      self
+    end
+
+    def for(field)
+      self[field] ||= []
+    end
+  end
+end

data/lib/error_prone/version.rb

@@ -0,0 +1,3 @@
+module ErrorProne
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: error_prone
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Zee Spencer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-21 00:00:00.000000000 Z
+dependencies: []
+description: ErrorProne lets you choose where, when, and how to validate data without
+  tying you to ORMs or application frameworks.
+email:
+- zee@zeespencer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/error_prone/version.rb
+- lib/error_prone.rb
+- LICENSE
+- README.markdown
+- CHANGELOG.markdown
+homepage: http://github.com/zspencer/error_prone
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: The no-frills, dependency-free data validation library
+test_files: []