fanforce-exceptions 0.4.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjVlNGY3MDU0NTYwNGE3OGM4ODE0ZTMwOTU0ZTE5MWM4YmJjYjVmZA==
+  data.tar.gz: !binary |-
+    YjEwMjZhNWE0MTg0NjQwMDM3NGE0M2JhY2JhMGVmYWJlYmEwMjJmYg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MjI4YzgyZWY0ZjUyODgxNDVjNzM1YzNlZGExMTYzNmM1MDQ2M2IyNDQ2MjFl
+    N2JjOGIwMDFhY2ZjODQ4YTY1NzNlMThiYjA1Nzc0NWYzYjU5NDg4MWFmZjE0
+    YWNkYThhZjJhZDcwZGM5ODYwOTE4ZDc4ZWNkMmY5NjFlMmJmODA=
+  data.tar.gz: !binary |-
+    ZDM5ZWFmYTY0Mzc4YzU1NTEwNjk0OTJkODMwNjcwZmU0ZTQ5Yjg0NDYwNGFi
+    MmYwNzBjNmIxZDIwYjgzNDg2ZTYzZWFkYjQ2ZjVlZmZhOTE1NzY1NzhlYWUw
+    ZjZiNmU0MzFkN2Y3ZmM2OTdmYmMxMjZkMjY1ZGQyYjYwYzI0NGM=

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+.DS_Store
+.idea/
+.idea/*
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,4 @@
+fanforce-exceptions
+==
+
+Internal exceptions used by the Fanforce codebase.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'fileutils'
+include FileUtils
+
+# Default Rake task is compile
+#task :default => :compile
+
+########################################################################
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.libs.push "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end

data/fanforce-exceptions.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fanforce/exceptions/version'
+
+Gem::Specification.new do |gem|
+  gem.name        = 'fanforce-exceptions'
+  gem.version     = Fanforce::Exceptions::VERSION
+  gem.date        = Time.now.utc.strftime('%Y-%m-%d')
+  gem.summary     = %q{Internal exceptions used by the Fanforce codebase.}
+  gem.authors     = ['Caleb Clark']
+  gem.email       = ['cclark@fanforce.com']
+  gem.homepage    = 'http://github.com/fanforce/fanforce-exceptions'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'fanforce-utils', '~> 0.3.0'
+end

data/lib/fanforce/errors/_base.rb

@@ -0,0 +1,170 @@
+class Fanforce::Error < StandardError
+  require 'fanforce/utils'
+  include Fanforce::Utils
+
+  attr_reader :public_errors, :env
+
+  def for(*args)
+    self.new(*args)
+  end
+
+  def initialize(*errors)
+    if errors[0].is_a?(String) and errors[1].is_a?(Hash) and is_blank?(errors[1][:message])
+      tmp = errors.shift() and errors[0][:message] = tmp
+    end
+    @public_errors = format_errors(errors)
+    @env = Fanforce.env
+    super("#{@public_errors[0].to_json}")
+  end
+
+  def format_errors(raw_errors)
+    raw_errors.is_a?(Array) ? raw_errors.inject([]) {|errors, e| errors << format_error(e) } : [format_error(raw_errors)]
+  end
+
+  def format_error(raw_error)
+    return {message: is_blank?(raw_error) ? default_message : raw_error.to_s} if !raw_error.is_a?(Hash)
+    raw_error = symbolize_keys(raw_error)
+    error = { message: is_blank?(raw_error[:message]) ? default_message : raw_error[:message].to_s }
+    error[:resource] = raw_error[:resource].to_s if is_present?(raw_error[:resource])
+    error[:code] = (is_blank?(raw_error[:code]) or !valid_error_codes.include? raw_error[:code].to_sym) ? default_error_code : raw_error[:code].to_s
+    error[:field] = raw_error[:field].to_s if is_present?(raw_error[:field])
+    error[:fields] = raw_error[:fields].map {|f| f.to_s } if is_present?(raw_error[:fields])
+    error
+  end
+
+  def curl_command
+    return nil if is_blank?(@env[:request_method]) or is_blank?(@env[:request_url])
+    Fanforce::Utils.curl_command(@env[:request_method], @env[:request_url], @env[:request_params])
+  end
+
+  def code; 500 end
+  def default_message; end
+  def valid_error_codes; [] end
+  def default_error_code; end
+
+end
+
+class Fanforce::Error::BadRequest < Fanforce::Error # Request is missing something or invalid
+  def code; 400 end
+  def default_message; 'Bad Request' end
+  def valid_error_codes; [:blank_field, :missing_field, :invalid_association, :invalid_field] end
+  def default_error_code; :unknown end
+end
+
+class Fanforce::Error::Unauthorized < Fanforce::Error # Could not successfully authenticate
+  def code; 401 end
+  def default_message; 'Unauthorized Request' end
+  def valid_error_codes; [:unauthorized, :unknown_login] end
+  def default_error_code; :unauthorized end
+end
+
+class Fanforce::Error::Forbidden < Fanforce::Error # Current API key does not allow access
+  def code; 403 end
+  def default_message; 'API Key Forbids Access' end
+  def valid_error_codes; [:weak_api_key] end
+  def default_error_code; :weak_api_key end
+end
+
+class Fanforce::Error::NotFound < Fanforce::Error # Method or record could not be found
+  def code; 404 end
+  def default_message; 'Not Found' end
+  def valid_error_codes; [:record_not_found, :method_not_found] end
+  def default_error_code; :unknown end
+  def initialize(*args)
+    if args[0].is_a?(Hash)
+      super(*args)
+    else
+      super(
+          resource: args[0].to_s.demodulize.singularize,
+          message: args[1]
+      )
+    end
+  end
+  def self.for(resource, message=nil)
+    self.new(resource, message)
+  end
+end
+
+class Fanforce::Error::RequestFailed < Fanforce::Error # Request has correct fields but failed for another reason
+  def code; 422 end
+  def default_message; 'Request Failed' end
+  def valid_error_codes; [:invalid_data, :record_already_exists, :maxed_capacity] end
+  def default_error_code; :unknown end
+end
+
+class Fanforce::Error::InternalError < Fanforce::Error
+  def code; 500 end
+  def default_message; 'Request Failed for Internal Reason' end
+  def valid_error_codes; [:internal_error, :invalid_fanforce_auth, :user_tampering, :third_party_error] end
+  def default_error_code; :unknown end
+end
+
+class Fanforce::Error::WebhookFailed < Fanforce::Error  # Parameters were valid but request failed for another reason
+  attr_reader :request_url, :request_params, :response_code, :response_body, :request_curl_command
+  def code; 500 end
+  def default_message; 'Webhook Failed' end
+  def valid_error_codes; [:third_party_error] end
+  def default_error_code; :unknown end
+
+  def initialize(hash)
+    @request_url = hash[:request_url]
+    @request_params = hash[:request_params]
+    @response_code = hash[:response_code]
+    @response_body = hash[:response_body]
+    @request_curl_command = "curl -X POST -d \"#{@request_params.to_param}\" #{@request_url}"
+    super("Callback returned an HTTP response code of #{@response_code} when only 200 and 201 are allowed.")
+  end
+end
+
+class Fanforce::Error::AddonFailed < Fanforce::Error # A 3rd-party addon crapped out
+  attr_reader :plugin_dev_error
+  def default_message; 'Third-Party Plugin Error' end
+  def valid_error_codes; [:third_party_error] end
+  def default_error_code; :third_party_error end
+
+  def initialize(plugin_type, plugin_id, e, msg, &block)
+    plugin_dev_error = {}
+    plugin_dev_error[:problem] = msg
+    if e.is_a?(Fanforce::Errors::WebhookFailed)
+      plugin_dev_error[:request_url] = e.request_url
+      plugin_dev_error[:request_params] = e.request_params
+      plugin_dev_error[:response_code] = e.response_code
+      plugin_dev_error[:response_body] = e.response_body.to_s
+      plugin_dev_error[:curl_command] = "curl -X POST -d \"#{e.request_params.to_param}\" #{e.request_url}"
+    end
+    @plugin_dev_errors = e.respond_to?(:plugin_dev_errors) ? e.plugin_dev_errors : []
+    @plugin_dev_errors << plugin_dev_error
+
+    self.class.handler_blocks.each {|block| block.call(plugin_type, plugin_id, plugin_dev_error,  e.backtrace) }
+    super(msg)
+  end
+
+  def self.handler(&block)
+    handler_blocks << block
+  end
+
+  def self.handler_blocks
+    @handler_blocks ||= []
+  end
+end
+
+module Fanforce::Errors
+  def self.included(base) base.extend(self) end
+
+  BadRequest    = Fanforce::Error::BadRequest    unless defined?(BadRequest)
+  Unauthorized  = Fanforce::Error::Unauthorized  unless defined?(Unauthorized)
+  Forbidden     = Fanforce::Error::Forbidden     unless defined?(Forbidden)
+  NotFound      = Fanforce::Error::NotFound      unless defined?(NotFound)
+  RequestFailed = Fanforce::Error::RequestFailed unless defined?(RequestFailed)
+  InternalError = Fanforce::Error::InternalError unless defined?(InternalError)
+  WebhookFailed = Fanforce::Error::WebhookFailed unless defined?(WebhookFailed)
+  AddonFailed   = Fanforce::Error::AddonFailed   unless defined?(AddonFailed)
+
+  def self.format_admin_details(e, errors=[], additional_options={})
+    admin_details = {error_class: e.class.name, public_response: errors}
+    admin_details[:curl_command] = e.curl_command if e.respond_to?(:curl_command)
+    admin_details[:raw_message] = e.message
+    admin_details.merge(additional_options)
+  end
+
+end

data/lib/fanforce/errors.rb

@@ -0,0 +1,4 @@
+class Fanforce;
+  require_relative 'errors/_base'
+end
+

data/lib/fanforce/exceptions/_base.rb

@@ -0,0 +1,7 @@
+module Fanforce::Exceptions
+  require_relative '../errors'
+  require_relative '../notices'
+
+  include Fanforce::Errors
+  include Fanforce::Notices
+end

data/lib/fanforce/exceptions/version.rb

@@ -0,0 +1,5 @@
+class Fanforce
+  module Exceptions
+    VERSION = '0.4.0'
+  end
+end

data/lib/fanforce/exceptions.rb

@@ -0,0 +1,5 @@
+class Fanforce
+  require_relative 'exceptions/version'
+  require_relative 'exceptions/_base'
+end
+

data/lib/fanforce/notices/_base.rb

@@ -0,0 +1,18 @@
+require_relative '../errors/_base'
+
+class Fanforce::Notice < Fanforce::Error
+  def public_notices
+    @public_errors
+  end
+end
+
+class Fanforce::Notice::ProcessingWebhook < Fanforce::Notice
+  def code; 409 end
+  def default_message; 'Processing Request' end
+end
+
+module Fanforce::Notices
+  def self.included(base) base.extend(self) end
+
+  ProcessingWebhook = Fanforce::Notice::ProcessingWebhook
+end

data/lib/fanforce/notices.rb

@@ -0,0 +1,4 @@
+class Fanforce;
+  require_relative 'notices/_base'
+end
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: fanforce-exceptions
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Caleb Clark
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fanforce-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: 
+email:
+- cclark@fanforce.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- fanforce-exceptions.gemspec
+- lib/fanforce/errors.rb
+- lib/fanforce/errors/_base.rb
+- lib/fanforce/exceptions.rb
+- lib/fanforce/exceptions/_base.rb
+- lib/fanforce/exceptions/version.rb
+- lib/fanforce/notices.rb
+- lib/fanforce/notices/_base.rb
+homepage: http://github.com/fanforce/fanforce-exceptions
+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: Internal exceptions used by the Fanforce codebase.
+test_files: []