instructure-active_model-better_errors 1.6.3.rails2

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/rails"]
+	path = vendor/rails
+	url = git://github.com/rails/rails.git

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+gem "activerecord", "~> 2.3.11"
+
+group :development, :test do
+  gem "rake"
+  gem "rspec", "~> 2.12.0"
+  gem "pry"
+  gem "yard"
+  gem "rdoc"
+  gem "bundler"
+  gem "jeweler"
+  gem "simplecov"
+  gem 'bcrypt-ruby', '~> 3.0.0'
+  gem 'mocha', '>= 0.12.1'
+  gem 'sqlite3'
+  gem 'debugger'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Aaron Qian
+
+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.md

@@ -0,0 +1,183 @@
+# ActiveModel Better Errors
+
+[![Gem Version](https://badge.fury.io/rb/active_model-better_errors.png)](http://badge.fury.io/rb/active_model-better_errors)
+[![Build Status](https://travis-ci.org/aq1018/active_model-better_errors.png?branch=master)](https://travis-ci.org/aq1018/active_model-better_errors)
+[![Dependency Status](https://gemnasium.com/aq1018/active_model-better_errors.png)](https://gemnasium.com/aq1018/active_model-better_errors)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/aq1018/active_model-better_errors)
+
+`active_model-better_errors` is a `ActiveModel::Errors` compatible library to help you
+customize the presentation of your error messages.
+
+## Why Better Errors
+
+In `ActiveModel::Errors`, when an error is added, it is pre translated into human readable string.
+However, this becomes less ideal when output error messages in JSON or XML in your API.
+Most of the times, we want error codes instead of human readable strings. This will allow
+API consumers to translate them in their own application and provide more flexibility for your
+API.
+
+## How Better Errors Work
+
+`active_model-better_errors` works by sperating the concerns of error message storage and presentation.
+`ActiveModel::Errors` really handles four tasks in a single class:
+
+* error data storage
+* presenting human readable errors using `#full_messages`
+* presenting errors in Array / XML format with `#to_a` and `#to_xml`
+* presenting errors in Hash / JSON format with `#to_hash` and `#as_json`
+
+This gem seperates these concerns and allows users to plugin various reporters for different presentation needs.
+
+## Setup
+
+### With Bundler
+
+```ruby
+# in Gemfile
+gem 'active_model-better_errors', '>= 1.4.0'
+```
+
+```
+# in console
+bundle install
+```
+
+### With RubyGems
+
+```
+gem install active_model-better_errors
+```
+
+## Configure
+
+By default, `active_model-better_errors` is a drop-in replacement for `ActiveModel::Errors`
+and will mostly function without modifications. This is because the default reporters are set like the following:
+
+```ruby
+ActiveModel::ErrorCollecting.set_reporter :message,  :human
+ActiveModel::ErrorCollecting.set_reporter :array,    :human
+ActiveModel::ErrorCollecting.set_reporter :hash,     :human
+```
+
+If you want to output API friendly JSON / XML by default, you can use the following config.
+
+```ruby
+ActiveModel::ErrorCollecting.set_reporter :message,  :human
+ActiveModel::ErrorCollecting.set_reporter :array,    :machine
+ActiveModel::ErrorCollecting.set_reporter :hash,     :machine
+```
+
+Note: The configurations above determines *default* reporters to use, you can always switch to
+any reporters you want during runtime by invoking `errors.set_reporter`
+
+## Usage
+
+```ruby
+user.errors # returns an instance of ActiveModel::ErrorCollecting::Errors
+
+# Use MachineArrayReporter to output API friendly error messages
+user.errors.set_reporter(:array, :machine)
+user.errors.to_a   # API Friendly
+user.errors.to_xml # API Friendly
+
+# Use HumanArrayReporter to output Human friendly error messages.
+# This is ActiveModel::Errors behavior
+user.errors.set_reporter(:array, :human)
+user.errors.to_a   # Human Friendly
+user.errors.to_xml # Human Friendly
+
+# Use MachineHashReporter to output API friendly error messages
+user.errors.set_reporter(:hash, :machine)
+user.errors.to_hash # API Friendly
+user.errors.as_json # API Friendly
+user.errors.to_json # API Friendly
+
+
+# Use HumanHashReporter to output Human friendly error messages.
+# This is ActiveModel::Errors behavior
+user.errors.set_reporter(:hash, :human)
+user.errors.to_hash # Human Friendly
+user.errors.as_json # Human Friendly
+user.errors.to_json # Human Friendly
+
+# Use MyHashReporter to output Human friendly error messages.
+# This is ActiveModel::Errors behavior
+user.errors.set_reporter(:hash, MyHashReporter)
+user.errors.to_hash # custom behavior
+user.errors.as_json # custom behavior
+user.errors.to_json # custom behavior
+
+```
+
+## In Depth
+
+This library creates three types of reporters to take care of
+some presentation aspects of `ActiveModel::Errors`, and they are:
+
+**Message Reporters**
+
+This is responsible for handling the following methods in `ActiveModel::Errors`
+
+* `#full_messages`
+* `#full_message`
+* `#generate_message`
+
+Due to the conventional use of these methods, they are mostly intended for human consumption.
+
+This library implements the following reporters of this type:
+
+* `HumanMessageReporter`
+
+**Array Reporters**
+
+This is responsible for handling the following methods in `ActiveModel::Errors`
+
+* `#to_a`
+
+This library implements the following reporters of this type:
+
+* `HumanArrayReporter`
+* `MachineArrayReporter`
+
+**Hash Reporters**
+
+This is responsible for handling the following methods in `ActiveModel::Errors`
+
+* `#to_hash`
+
+This library implements the following reporters of this type:
+
+* `HumanHashReporter`
+* `MachineHashReporter`
+
+
+## Creating Custom Reporters
+
+Creating a custom reporter is easy. Here is an example to create a hash reporter
+
+```ruby
+class MyHashReporter < ActiveModel::ErrorCollecting::HashReporter
+  def to_hash
+    # you have access to #collection and #base
+  end
+end
+
+# set it to use it.
+ActiveModel::ErrorCollecting.set_reporter :hash, MyHashReporter
+```
+
+## Contributing to active_model-better_errors
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2013 Aaron Qian. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "instructure-active_model-better_errors"
+  gem.homepage = "http://github.com/codekitchen/active_model-better_errors"
+  gem.license = "MIT"
+  gem.summary = %Q{API consumable error messages with ActiveModel::Errors drop-in compatibility.}
+  gem.description = %Q{ActiveModel::Errors class is not designed for API consumption. This gem allows for that while keeping compatibility with existing rails API.}
+  gem.email = ["aq1018@gmail.com", "byronanderson32@gmail.com", "brianp@instructure.com"]
+  gem.authors = ["Aaron Qian", "Byron Anderson", "Brian Palmer"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+dir = File.dirname(__FILE__)
+
+require 'rake/testtask'
+
+test_files = []
+test_files << "test/integration"
+test_files += Dir.glob("#{dir}/vendor/rails/activemodel/test/cases/**/*_test.rb").sort
+
+Rake::TestTask.new("test:integration") do |t|
+  t.libs << "vendor/rails/activemodel/test"
+  t.test_files = test_files
+  t.warning = true
+end
+
+
+task :default => [ :spec ]
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+1.6.3.rails2

data/active_model-better_errors.gemspec

@@ -0,0 +1,110 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "instructure-active_model-better_errors"
+  s.version = "1.6.3.rails2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Qian", "Byron Anderson", "Brian Palmer"]
+  s.date = "2013-11-08"
+  s.description = "ActiveModel::Errors class is not designed for API consumption. This gem allows for that while keeping compatibility with existing rails API."
+  s.email = ["aq1018@gmail.com", "byronanderson32@gmail.com", "brianp@instructure.com"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".gitmodules",
+    ".rspec",
+    ".travis.yml",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "active_model-better_errors.gemspec",
+    "lib/active_model/better_errors.rb",
+    "lib/active_model/error_collecting.rb",
+    "lib/active_model/error_collecting/array_reporter.rb",
+    "lib/active_model/error_collecting/core_ext.rb",
+    "lib/active_model/error_collecting/emulation.rb",
+    "lib/active_model/error_collecting/error_collection.rb",
+    "lib/active_model/error_collecting/error_message.rb",
+    "lib/active_model/error_collecting/error_message_set.rb",
+    "lib/active_model/error_collecting/errors.rb",
+    "lib/active_model/error_collecting/hash_reporter.rb",
+    "lib/active_model/error_collecting/human_array_reporter.rb",
+    "lib/active_model/error_collecting/human_hash_reporter.rb",
+    "lib/active_model/error_collecting/human_message_formatter.rb",
+    "lib/active_model/error_collecting/human_message_reporter.rb",
+    "lib/active_model/error_collecting/machine_array_reporter.rb",
+    "lib/active_model/error_collecting/machine_hash_reporter.rb",
+    "lib/active_model/error_collecting/message_reporter.rb",
+    "lib/active_model/error_collecting/reporter.rb",
+    "spec/lib/active_model/better_errors_spec.rb",
+    "spec/lib/active_model/error_collecting/emulation_spec.rb",
+    "spec/lib/active_model/error_collecting/error_collection_spec.rb",
+    "spec/lib/active_model/error_collecting/error_message_set_spec.rb",
+    "spec/lib/active_model/error_collecting/error_message_spec.rb",
+    "spec/lib/active_model/error_collecting/errors_spec.rb",
+    "spec/lib/active_model/error_collecting/human_array_reporter_spec.rb",
+    "spec/lib/active_model/error_collecting/human_hash_reporter_spec.rb",
+    "spec/lib/active_model/error_collecting/human_message_formatter_spec.rb",
+    "spec/lib/active_model/error_collecting/human_message_reporter_spec.rb",
+    "spec/lib/active_model/error_collecting/machine_array_reporter_spec.rb",
+    "spec/lib/active_model/error_collecting/machine_hash_reporter_spec.rb",
+    "spec/lib/active_model/error_collecting_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/models.rb",
+    "test/integration.rb"
+  ]
+  s.homepage = "http://github.com/codekitchen/active_model-better_errors"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "API consumable error messages with ActiveModel::Errors drop-in compatibility."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.12.0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<bcrypt-ruby>, ["~> 3.0.0"])
+      s.add_development_dependency(%q<mocha>, [">= 0.12.1"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.12.0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<bcrypt-ruby>, ["~> 3.0.0"])
+      s.add_dependency(%q<mocha>, [">= 0.12.1"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.12.0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<bcrypt-ruby>, ["~> 3.0.0"])
+    s.add_dependency(%q<mocha>, [">= 0.12.1"])
+  end
+end
+

data/lib/active_model/better_errors.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+
+require 'active_support/core_ext'
+
+require 'active_model/error_collecting'
+
+require 'active_record'
+require 'active_record/base'
+require 'active_record/validations'
+
+module ActiveRecord
+  module Validations
+    def errors
+      @errors ||= ActiveModel::ErrorCollecting::Errors.new(self)
+    end
+  end
+end

data/lib/active_model/error_collecting/array_reporter.rb

@@ -0,0 +1,9 @@
+module ActiveModel
+  module ErrorCollecting
+    class ArrayReporter < Reporter
+      def to_a
+        raise "abstract method"
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/core_ext.rb

@@ -0,0 +1,6 @@
+class String
+  def ==(other)
+    return super other.to_s if other.is_a? ActiveModel::ErrorCollecting::ErrorMessage
+    super
+  end
+end

data/lib/active_model/error_collecting/emulation.rb

@@ -0,0 +1,65 @@
+#
+# Allows included class to emulate ActiveModel::Errors class
+# by defining a set of methods to delegate to facilities
+# in this gem.
+#
+module ActiveModel
+  module ErrorCollecting
+    module Emulation
+      MODEL_METHODS = [
+        :clear, :include?, :get, :set, :delete, :[], :[]=,
+        :each, :size, :values, :keys, :count, :empty?, :any?,
+        :added?, :entries
+      ]
+
+      MESSAGE_REPORTER_METHODS = [
+        :full_messages, :full_message, :generate_message
+      ]
+
+      def self.included(base)
+        base.class_eval do
+          extend Forwardable
+          def_delegators :error_collection, *MODEL_METHODS
+          def_delegators :message_reporter, *MESSAGE_REPORTER_METHODS
+          def_delegators :hash_reporter,    :to_hash
+          def_delegators :array_reporter,   :to_a
+
+          alias_method :blank?, :empty?
+          alias_method :has_key?, :include?
+        end
+      end
+
+      def add_on_empty(attributes, options = {})
+        [attributes].flatten.each do |attribute|
+          value = @base.send(:read_attribute, attribute)
+          is_empty = value.respond_to?(:empty?) ? value.empty? : false
+          add(attribute, :empty, options) if value.nil? || is_empty
+        end
+      end
+
+      def add_on_blank(attributes, options = {})
+        [attributes].flatten.each do |attribute|
+          value = @base.send(:read_attribute, attribute)
+          add(attribute, :blank, options) if value.blank?
+        end
+      end
+
+      def add(attribute, message=nil, options = {})
+        if options[:strict]
+          error   = ErrorMessage.build(attribute, message, options)
+          message = HumanMessageFormatter.new(@base, error).format_message
+          raise ActiveModel::StrictValidationFailed, full_message(attribute, message)
+        end
+        error_collection.add attribute, message, options
+      end
+
+      def to_xml(options={})
+        to_a.to_xml options.reverse_merge(:root => "errors", :skip_types => true)
+      end
+
+      def as_json(options=nil)
+        to_hash
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/error_collection.rb

@@ -0,0 +1,86 @@
+module ActiveModel
+  module ErrorCollecting
+    class ErrorCollection
+      include Enumerable
+
+      attr_reader :base
+      def initialize(base)
+        @base = base
+        @collection = {}
+      end
+
+      def clear
+        @collection.clear
+      end
+
+      def include?(attribute)
+        ( v = @collection[attribute] ) && v.any?
+      end
+
+      def get(attribute)
+        @collection[attribute]
+      end
+
+      def set(attribute, errors)
+        return delete attribute if errors.nil?
+        @collection[attribute] = ErrorMessageSet.new(base, attribute, errors)
+      end
+
+      def delete(attribute)
+        @collection.delete attribute
+      end
+
+      def [](attribute)
+        get(attribute.to_sym) || set(attribute.to_sym, [])
+      end
+
+      def []=(attribute, error)
+        self[attribute] << error
+      end
+
+      def each
+        @collection.each_key do |attribute|
+          self[attribute].each { |error_message| yield attribute, error_message }
+        end
+      end
+
+      def size
+        values.inject(0){ |sum, set| sum += set.size }
+      end
+      alias_method :count, :size
+
+      def values
+        @collection.values
+      end
+
+      def keys
+        @collection.keys
+      end
+
+      def to_a
+        array = []
+        @collection.each_key do |attribute|
+          self[attribute].each { |error_message| array << error_message }
+        end
+
+        array
+      end
+
+      def to_hash
+        @collection.dup
+      end
+
+      def empty?
+        size == 0
+      end
+
+      def add(attribute, message, options = {})
+        self[attribute] << [ message, options ]
+      end
+
+      def added?(attribute, message = nil, options = {})
+        self[attribute].include? ErrorMessage.build(base, attribute, message, options)
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/error_message.rb

@@ -0,0 +1,88 @@
+module ActiveModel
+  module ErrorCollecting
+    class ErrorMessage
+      include Comparable
+      CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
+
+      # return the message either as nil, symbol, or string
+      def self.normalize(message)
+        case message
+        when nil
+          nil
+        when Symbol
+          message
+        when Proc
+          message.call
+        else
+          message.to_s
+        end
+      end
+
+      def self.identify(message, override)
+        symbol = string = nil
+
+        message   = normalize message
+        override  = normalize override
+
+        symbol = message if message.is_a?(Symbol)
+        symbol = override if override.is_a?(Symbol)
+
+        string = message if message.is_a?(String)
+        string = override if override.is_a?(String)
+
+        string = nil if string.blank?
+
+        [symbol, string]
+      end
+
+      def self.build(base, attribute, message, options=nil)
+        options   = options ? options : {}
+        options   = options.except(*CALLBACKS_OPTIONS)
+
+        symbol, string = identify message, options.delete(:message)
+
+        new(base, attribute, symbol, string, options)
+      end
+
+      attr_reader :base, :attribute, :type, :message, :options
+
+      def initialize(base, attribute, type, message, options = {})
+        @base       = base
+        @attribute  = attribute
+        @type       = type
+        @message    = message
+        @options    = options
+      end
+
+      def <=> (other)
+        to_hash <=> other.to_hash
+      end
+
+      def to_hash
+        {
+          attribute: attribute,
+          type:      type,
+          message:   message,
+          options:   options
+        }
+      end
+
+      def hash
+        to_hash.hash
+      end
+
+      def to_s
+        HumanMessageFormatter.new(base, self).format_message
+      end
+
+      def inspect
+        to_s.inspect
+      end
+
+      def ==(other)
+        return type == other if other.is_a?(Symbol)
+        to_s == other.to_s
+      end
+    end
+  end
+end