code_error 0.9.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d3630c871f307f8a79b4c038efac86c2e7f7031
+  data.tar.gz: 9c7b3e960adb94896f0d062e5eebffc45bf77ccd
+SHA512:
+  metadata.gz: 0ffd780bcf90b43be9c7fa2e6c52ff973623a154ce99edeb1962c25805da98aad659e7969a5461087cd5dc5b84fd3ddae09130308c9b5b9c747a7e26931cc073
+  data.tar.gz: 225ab9e1a644db1de28e03d6b3f4518e10a39905f5868d2ab890c174240c18a342f422b8a919b57c754200a67f0f9c44d724212019aac18b4f4942b44cb782e7

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sibevin Wang
+
+MIT License
+
+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,331 @@
+# Code Error
+
+A code-based customized error.
+
+    raise MyError.new(10002)
+
+## Why?
+
+It is a standard error but it provides more.
+
+* All error cases are defined in the same place. Easy to find and reference.
+* Just raising an error with a code, then the corresponding status and message are ready to use.
+* Highly customizable and extendable, you can even re-define the default messages to what you want.
+
+## Usage
+
+### Basic
+
+Inherit CodeError::Base to create your own code-based error. You need to implement the "error_codes" method which provides a hash to define your own error code map.
+
+    class MyError < CodeError::Base
+
+      private
+
+      def error_codes
+        {
+          20001 => {
+            status: :failed,
+            msg: 'Purchase information format is incorrect.'
+          },
+          20002 => {
+            status: :failed,
+            msg: 'Device information format is incorrect.'
+          },
+          20003 => {
+            status: :failed,
+            msg: 'Unknown store.'
+          },
+          20100 => {
+            status: :duplicated,
+            msg: 'A duplicated IAP request is sent.'
+          },
+          20200 => {
+            status: :retry,
+            msg: 'Client should send the IAP request again.'
+          }
+        }
+      end
+    end
+
+Raise an error with a code when you need.
+
+    raise MyError.new(20001)
+
+Rescue and handle it.
+
+    begin
+      #...
+      raise MyError.new(20001)
+      #...
+    rescue MyError => e
+      raise e if e.internal?
+      msg = e.msg
+      code = e.code
+      info = e.info
+      data = e.data
+      case(e.status)
+      when :failed
+        #...
+      when :duplicated
+        #...
+      else
+        #...
+      end
+      #...
+    end
+
+### Customize error code hash
+
+A customized code-based error class need to implement the "error_codes" method which provides a hash like:
+
+    def error_codes
+      {
+        20001 => {
+          status: :failed,
+          msg: 'Purchase information format is incorrect.'
+        },
+        20002 => {
+          status: :failed,
+          msg: 'Device information format is incorrect.'
+        },
+        20003 => {
+          status: :failed,
+          msg: 'Unknown store.'
+        },
+        20100 => {
+          status: :duplicated,
+          msg: 'A duplicated IAP request is sent.',
+          masked: true
+        },
+        20200 => {
+          status: :retry,
+          msg: 'Client should send the IAP request again.'
+        }
+      }
+    end
+
+where keys are the supported codes and each value is an another hash to store the code information corresponding each codes. The code information hash contains the following keys:
+
+* :status - [any type you like] The error status to define the error handling flow. You can get it by calling the "status" method.
+* :msg - [String] The error message. You can get it by calling the "msg" method.
+* :masked - (optional)[Boolean] To define the error message is masked by default or not. The default value is false if no `:masked` is given.
+
+### Raise a code-based error
+
+Once you define the error_codes method, raising a code-based error is easy.
+
+    raise MyError.new(20001)
+
+There are three argments in the new method, `MyError.new(code, msg, info)`. If the given code is defined in the error_codes, the error would contain the corresponding status and msg.
+
+    e = MyError.new(20001)
+    e.code # 20001
+    e.status # :failed
+    e.msg # "Purchase information format is incorrect.(20001)"
+
+You can give another string in "msg" arg to overwrite the original message:
+
+    e = MyError.new(20001, "The another message which would override the original one.")
+    e.code # 20001
+    e.status # :failed
+    e.msg # "The another message which would override the original one.(20001)"
+
+If the given code is unknown, the error would become an internal error, i.e., the status is the `:internal` status.
+
+    e = MyError.new(1111)
+    e.code # 1111
+    e.status # :internal
+    e.msg # "An internal error occurs.(1111)"
+    e.internal? # true
+
+If a string is given, the error is also an internal error, but the "msg" would keep this string.
+
+    e = MyError.new("Invalid input!!")
+    e.code # 99999
+    e.status # :internal
+    e.msg # "Invalid input!!"(99999)
+    e.internal? # true
+
+You can pass anything to the error handling you want through the "info" arg.
+
+    something = 'what you want...'
+    e = MyError.new(20001, nil, something)
+    e.info # 'what you want...'
+
+There is a special code `:success` which used in the success case.
+
+    e = MyError.new(:success)
+    e.code # 0
+    e.status # :success
+    e.msg # ""
+    e.internal? # false
+
+### Handle the code-base error
+
+When you rescue a code-based error, some useful methods are ready to use.
+
+* code - The error code
+* status - The error status
+* msg - The error message
+* info - The error information
+* data - A hash contains the values of code, status, msg, info.
+* internal? - To show this error is an internal error or not.
+
+Here is an example:
+
+    e = MyError.new(20001, nil, 'some information')
+    e.code # 20001
+    e.status # :failed
+    e.msg # "Purchase information format is incorrect.(20001)"
+    e.info # "some information"
+    e.data # { code: 20001, status: :failed, msg: "Purchase information format is incorrect.(20001)", info: 'some information' }
+    e.internal? # false
+
+### Configure your code-base error
+
+You can override the `config` method in your code-based error to customize the default behavior. Here is an example:
+
+    class MyError < CodeError::Base
+
+      private
+
+      def error_codes
+        #...
+      end
+
+      def config
+        super.merge({
+          success: {
+            code: CodeError::SUCCESS_CODE,
+            status: CodeError::SUCCESS_STATUS,
+            msg: "My own success message." 
+          },
+          internal: {
+            code: CodeError::INTERNAL_CODE,
+            status: CodeError::INTERNAL_STATUS,
+            msg: "My own internal error message."
+          },
+          masked_msg: "My own masked message",
+          append_code_in_msg: :none
+        })
+      end
+    end
+
+where the config hash contains the following keys:
+
+* :success - Define the success code, status and message.
+* :internal - Define the internal error code, status and message.
+* :masked_msg - [String] Define the message to replace the masked one.
+* :code_in_msg - [:append/:prepend/:none] Define how to embed code in the message. The default option is :append.
+
+### Mask the error message
+
+You can mask an error message if you don't want to show it. A masked message would be replaced with the default masked message. There are several ways to do it, they are listed below sorted by the precedence.
+
+* Pass `true` to the "masked" arg in the "msg" or "data" method.
+
+    e = MyError.new(20001)
+    e.msg(ture) # "An error occurs.(20001)"
+    e.data(true) # { code: 20001, status: :failed, msg: "An error occurs.(20001)", info: {} }
+
+* Pass the `:masked` to the "msg" arg in the "new" method. 
+
+    e = MyError.new(20001, :masked)
+    e.msg # "An error occurs.(20001)"
+
+* Add `masked: true` in the error_codes hash for particular error. Please see [Customize error code hash].
+
+The default masked message can be customized to your own message by overwriting the `:masked_msg` in your config hash. Please see [Configure your code-base error].
+
+## I18n
+
+We don't support the i18n for simpleness but you can do it yourself. Here is an example:
+
+    class MyError < CodeError::Base
+
+      private
+
+      def error_codes
+        {
+          20001 => {
+            status: :failed,
+            msg: 'code_error.my_error.purchase_info_incorrect' 
+          },
+          20002 => {
+            status: :failed,
+            msg: 'code_error.my_error.device_info_incorrect'
+          },
+          20003 => {
+            status: :failed,
+            msg: 'code_error.my_error.unknown_store'
+          },
+          20100 => {
+            status: :duplicated,
+            msg: 'code_error.my_error.duplicated_request' 
+          },
+          20200 => {
+            status: :retry,
+            msg: 'code_error.my_error.retry'
+          }
+        }
+      end
+
+      def config
+        super.merge({
+          success: {
+            code: CodeError::SUCCESS_CODE,
+            status: CodeError::SUCCESS_STATUS,
+            msg: 'code_error_my_error.success_msg' 
+          },
+          internal: {
+            code: CodeError::INTERNAL_CODE,
+            status: CodeError::INTERNAL_STATUS,
+            msg: 'code_error_my_error.internal_msg' 
+          },
+          masked_msg: 'code_error_my_error.masked_msg',
+          append_code_in_msg: :append
+        })
+      end
+    end
+
+    def show_message(code, msg, masked = false)
+      masked = masked || @masked || false
+      m = masked ? I18n.t(config[:masked_msg]) : I18n.t(msg)
+      code_in_msg = config[:code_in_msg]
+      if code != config[:success][:code]
+        if code_in_message == :append
+          m = I18n.t('code_error.my_error.append_code_msg', msg: m, code: code)
+        elsif code_in_message == :prepand
+          m = I18n.t('code_error.my_error.prepend_code_msg', msg: m, code: code)
+        end
+      end
+      m
+    end
+
+And the i18n yml file is:
+
+    en:
+      code_error:
+        my_error:
+          append_code_msg: "%{msg}(%{code})"
+          prepend_code_msg: "(%{code})%{msg}"
+          purchase_info_invalid: "Purchase information format is incorrect."
+          device_info_invalid: "Device information format is incorrect."
+          unknown_store: "Unknown Store."
+          duplicated_request: "A duplicated IAP request is sent."
+          retry: "Client should send the IAP request again."
+
+## Test
+
+Go to code_error gem folder and run
+
+    ruby ./test/test_all.rb
+
+## Authors
+
+Sibevin Wang
+
+## Copyright
+
+Copyright (c) 2013 Sibevin Wang. Released under the MIT license.

data/code_error.gemspec

@@ -0,0 +1,78 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'code_error/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "code_error"
+  spec.version       = CodeError::VERSION
+  spec.authors       = ["Sibevin Wang"]
+  spec.email         = ["sibevin@gmail.com"]
+  spec.description   = %q{A code-based customized error.}
+  spec.summary       = <<-EOF
+Inherit CodeError::Base to create your own code-based error. You need to implement the "error_codes" method which provides a hash to define your own error code map.
+
+    class MyError < CodeError::Base
+
+      private
+
+      def error_codes
+        {
+          20001 => {
+            status: :failed,
+            msg: 'Purchase information format is incorrect.'
+          },
+          20002 => {
+            status: :failed,
+            msg: 'Device information format is incorrect.'
+          },
+          20003 => {
+            status: :failed,
+            msg: 'Unknown store.'
+          },
+          20100 => {
+            status: :duplicated,
+            msg: 'A duplicated IAP request is sent.'
+          },
+          20200 => {
+            status: :retry,
+            msg: 'Client should send the IAP request again.'
+          }
+        }
+      end
+    end
+
+Raise an error with a code when you need.
+
+    raise MyError.new(20001)
+
+Rescue and handle it.
+
+    begin
+      #...
+      raise MyError.new(20001)
+      #...
+    rescue MyError => e
+      raise e if e.internal?
+      msg = e.msg
+      code = e.code
+      info = e.info
+      data = e.data
+      case(e.status)
+      when :failed
+        #...
+      when :duplicated
+        #...
+      else
+        #...
+      end
+      #...
+    end
+
+Please see "README" to get more details.
+  EOF
+  spec.homepage      = "https://github.com/sibevin/code_error"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+end

data/lib/code_error/random_token_error.rb

@@ -0,0 +1,75 @@
+module RandomToken
+
+  # A customized exception for RandomToken
+  class RandomTokenError < StandardError
+
+    # Errors used in RandomToken
+    ERRORS = {
+      :unknown_seed => {
+        :value => 1,
+        :msg => "Unknown given seed"
+      },
+      :not_support_case => {
+        :value => 2,
+        :msg => "Case feature is not supported in this case, but the case option is given."
+      },
+      :not_support_friendly => {
+        :value => 3,
+        :msg => "Friendly feature is not supported in this case, but the friendly option is true."
+      },
+      :false_friendly_with_given_mask => {
+        :value => 4,
+        :msg => "The mask is given but the friendly option is false."
+      },
+      :invalid_strf_pattern => {
+        :value => 5,
+        :msg => "The given pattern is invalid."
+      },
+      :invalid_gen_arg => {
+        :value => 6,
+        :msg => "The given arg is invalid."
+      },
+      :mask_remove_all_seeds => {
+        :value => 7,
+        :msg => "The friendly mask removes all seeds."
+      },
+      :duplicated_option => {
+        :value => 8,
+        :msg => "The same options are given."
+      },
+      :invalid_option_value => {
+        :value => 9,
+        :msg => "The given option value is invalid."
+      },
+    }
+
+    attr_reader :code, :value, :msg, :info
+
+    # The RandomTokenError constructor.
+    # @param error [Fixnum, String]
+    #   You can give a error number defined in the keys of {RandomToken::RandomTokenError::ERRORS} or a string message for internal usage.
+    # @param info [Hash]
+    #   Anything you want to put in the info attribute of RandomTokenError.
+    def initialize(error, info = {})
+      @code = error
+      @info = info
+      if ERRORS.keys.include?(error)
+        @value = ERRORS[error][:value]
+        @msg = ERRORS[error][:msg]
+      elsif error.class.name == 'String'
+        @code = :internal
+        @value = 90000
+        @msg = error
+      else
+        @code = :internal
+        @value = 99999
+        @msg = "Internal Error"
+      end
+    end
+
+    # Override the message method to show more information in RandomTokenError
+    def message
+      "RandomTokenError(#{@code.to_s}): value = #{@value}, msg = #{@msg}, info = #{@info.inspect}"
+    end
+  end
+end

data/lib/code_error/version.rb

@@ -0,0 +1,3 @@
+module CodeError
+  VERSION = '0.9.3'
+end

data/lib/code_error.rb

@@ -0,0 +1,102 @@
+module CodeError
+
+  SUCCESS_CODE = 0
+  SUCCESS_STATUS = :success
+  SUCCESS_MSG = ''
+
+  INTERNAL_CODE = 99999
+  INTERNAL_STATUS = :internal
+  INTERNAL_MSG = 'An internal error occurs.'
+
+  MASKED_MSG = 'An error occurs.'
+
+  class Base < StandardError
+    attr_reader :code, :status, :info
+
+    def initialize(code = nil, msg = nil, info = {})
+      @code = code
+      @info = info
+      if error_codes.keys.include?(code)
+        @status = error_codes[code][:status]
+        @msg = error_codes[code][:msg]
+        @masked = error_codes[code][:masked] || false
+        if msg == :masked
+          @masked = true
+        elsif msg.is_a?(String)
+          @masked = false
+          @msg = msg
+        end
+      elsif code == config[:success][:code]
+        @code = config[:success][:code]
+        @status = config[:success][:status]
+        @msg = config[:success][:msg]
+      else
+        # unknown code
+        @status = config[:internal][:status]
+        if code.is_a?(String)
+          @code = config[:internal][:code]
+          @msg = code
+        else
+          @code = code || config[:internal][:code]
+          @msg = msg || config[:internal][:msg]
+        end
+      end
+    end
+
+    def message
+      self.data.inspect
+    end
+
+    def data(masked = nil)
+      msg = show_message(@code, @msg, masked)
+      { status: @status, code: @code, msg: msg, info: @info }
+    end
+
+    def msg(masked = nil)
+      show_message(@code, @msg, masked)
+    end
+
+    def internal?
+      @status == config[:internal][:status]
+    end
+
+    private
+
+    def error_codes
+      raise 'You should implement error_codes method in your code-based class.'
+    end
+
+    def config
+      {
+        :success => {
+          :code => SUCCESS_CODE,
+          :status => SUCCESS_STATUS,
+          :msg => SUCCESS_MSG
+        },
+        :internal => {
+          :code => INTERNAL_CODE,
+          :status => INTERNAL_STATUS,
+          :msg => INTERNAL_MSG
+        },
+        :masked_msg => MASKED_MSG,
+        :code_in_msg => :append
+      }
+    end
+
+    def show_message(code, msg, masked = nil)
+      if masked == nil
+        masked = @masked || false
+      end
+      m = masked ? config[:masked_msg] : msg
+      code_in_msg = config[:code_in_msg]
+      if code != config[:success][:code]
+        if code_in_msg == :append
+          m = "#{m}(#{code})"
+        elsif code_in_msg == :prepand
+          m = "(#{code})#{m}"
+        end
+      end
+      m
+    end
+  end
+end

data/test/test_all.rb

@@ -0,0 +1,9 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "code_error"
+require "test_new"
+require "test_config"
+require "test_masked"
+require "test_code_in_msg"

data/test/test_code_in_msg.rb

@@ -0,0 +1,85 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "code_error"
+
+class TestCodeInMsg < Test::Unit::TestCase
+
+  ERROR_CODE_1 = 1
+  ERROR_MSG_1 = 'The error message for code 1.'
+  ERROR_STATUS_1 = :failed
+
+  class AppendError < CodeError::Base
+    def error_codes
+      {
+        ERROR_CODE_1 => {
+          status: ERROR_STATUS_1,
+          msg: ERROR_MSG_1,
+        }
+      }
+    end
+
+    def config
+      super.merge({
+        :code_in_msg => :append
+      })
+    end
+  end
+
+  class PrependError < CodeError::Base
+    def error_codes
+      {
+        ERROR_CODE_1 => {
+          status: ERROR_STATUS_1,
+          msg: ERROR_MSG_1,
+        }
+      }
+    end
+
+    def config
+      super.merge({
+        :code_in_msg => :prepand
+      })
+    end
+  end
+
+  class NoneError < CodeError::Base
+    def error_codes
+      {
+        ERROR_CODE_1 => {
+          status: ERROR_STATUS_1,
+          msg: ERROR_MSG_1,
+        }
+      }
+    end
+
+    def config
+      super.merge({
+        :code_in_msg => :none
+      })
+    end
+  end
+
+  def test_code_in_msg_should_return_a_message_with_the_code_appended_after_it_if_append_config_is_given
+    e = AppendError.new(ERROR_CODE_1)
+    assert(e.msg == "#{ERROR_MSG_1}(#{ERROR_CODE_1})")
+  end
+
+  def test_code_in_msg_should_return_a_message_with_the_code_prepended_before_it_if_prepend_config_is_given
+    e = PrependError.new(ERROR_CODE_1)
+    assert(e.msg == "(#{ERROR_CODE_1})#{ERROR_MSG_1}")
+  end
+
+  def test_code_in_msg_should_return_a_message_without_the_code_if_none_config_is_given
+    e = NoneError.new(ERROR_CODE_1)
+    assert(e.msg == "#{ERROR_MSG_1}")
+  end
+
+  def test_code_in_msg_should_return_a_message_without_the_code_if_it_is_a_success_error
+    e = AppendError.new(CodeError::SUCCESS_CODE)
+    assert(e.msg == "#{CodeError::SUCCESS_MSG}")
+    e = PrependError.new(CodeError::SUCCESS_CODE)
+    assert(e.msg == "#{CodeError::SUCCESS_MSG}")
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,116 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "code_error"
+
+class TestConfig < Test::Unit::TestCase
+
+  ERROR_CODE_1 = 1
+  ERROR_MSG_1 = 'The error message for code 1.'
+  ERROR_STATUS_1 = :failed
+
+  ERROR_CODE_2 = 2
+  ERROR_MSG_2 = 'The error message for code 2.'
+  ERROR_STATUS_2 = :failed
+
+  ERROR_CODE_UNDEFINED = 55688
+
+  MY_SUCCESS_CODE = :my_success_code
+  MY_SUCCESS_MSG = 'My success error message.'
+  MY_SUCCESS_STATUS = :my_success_status
+
+  MY_INTERNAL_CODE = :my_internal_code
+  MY_INTERNAL_MSG = 'My internal error message.'
+  MY_INTERNAL_STATUS = :my_internal_status
+
+  MY_MASKED_MSG = 'My masked message.'
+
+  class ConfigError < CodeError::Base
+    def error_codes
+      {
+        ERROR_CODE_1 => {
+          status: ERROR_STATUS_1,
+          msg: ERROR_MSG_1,
+        },
+        ERROR_CODE_2 => {
+          :status => ERROR_STATUS_2,
+          :msg => ERROR_MSG_2,
+          :masked => true
+        }
+      }
+    end
+
+    def config
+      {
+        :success => {
+          :code => MY_SUCCESS_CODE,
+          :msg => MY_SUCCESS_MSG,
+          :status => MY_SUCCESS_STATUS
+        },
+        :internal => {
+          :code => MY_INTERNAL_CODE,
+          :msg => MY_INTERNAL_MSG,
+          :status => MY_INTERNAL_STATUS
+        },
+        :masked_msg => MY_MASKED_MSG,
+        :code_in_msg => :append
+      }
+    end
+  end
+
+  def test_config_should_return_the_correspond_data_if_given_code_is_defined
+    e = ConfigError.new(ERROR_CODE_1)
+    assert(e.code == ERROR_CODE_1)
+    assert(e.status == ERROR_STATUS_1)
+    assert(e.msg == "#{ERROR_MSG_1}(#{ERROR_CODE_1})")
+    assert(!e.internal?)
+  end
+
+  def test_config_should_return_an_internal_error_with_given_code_if_given_code_is_undefined
+    e = ConfigError.new(ERROR_CODE_UNDEFINED)
+    assert(e.code == ERROR_CODE_UNDEFINED)
+    assert(e.status == MY_INTERNAL_STATUS)
+    assert(e.msg == "#{MY_INTERNAL_MSG}(#{ERROR_CODE_UNDEFINED})")
+    assert(e.internal?)
+  end
+
+  def test_config_should_return_an_internal_error_with_given_msg_if_given_code_is_a_string
+    msg = 'An error message.'
+    e = ConfigError.new(msg)
+    assert(e.code == MY_INTERNAL_CODE)
+    assert(e.status == MY_INTERNAL_STATUS)
+    assert(e.msg == "#{msg}(#{MY_INTERNAL_CODE})")
+    assert(e.internal?)
+  end
+
+  def test_config_should_return_an_success_error_if_given_code_is_a_success_code
+    e = ConfigError.new(MY_SUCCESS_CODE)
+    assert(e.code == MY_SUCCESS_CODE)
+    assert(e.status == MY_SUCCESS_STATUS)
+    assert(e.msg == "#{MY_SUCCESS_MSG}")
+    assert(!e.internal?)
+  end
+
+  def test_config_should_mask_the_msg_if_given_msg_is_masked
+    e = ConfigError.new(ERROR_CODE_1, :masked)
+    assert(e.code == ERROR_CODE_1)
+    assert(e.status == ERROR_STATUS_1)
+    assert(e.msg == "#{MY_MASKED_MSG}(#{ERROR_CODE_1})")
+    assert(!e.internal?)
+  end
+
+  def test_config_should_mask_the_msg_by_default_if_true_masked_config_is_given
+    e = ConfigError.new(ERROR_CODE_2)
+    assert(e.code == ERROR_CODE_2)
+    assert(e.status == ERROR_STATUS_2)
+    assert(e.msg == "#{MY_MASKED_MSG}(#{ERROR_CODE_2})")
+    assert(!e.internal?)
+  end
+
+  def test_config_should_contain_the_info_if_an_info_is_given
+    info = 'some information'
+    e = ConfigError.new(ERROR_CODE_1, nil, info)
+    assert(e.info == info)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1 @@
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")

data/test/test_masked.rb

@@ -0,0 +1,89 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "code_error"
+
+class TestMasked < Test::Unit::TestCase
+
+  ERROR_CODE_1 = 1
+  ERROR_MSG_1 = 'The error message for code 1.'
+  ERROR_STATUS_1 = :failed
+
+  ERROR_CODE_2 = 2
+  ERROR_MSG_2 = 'The error message for code 2.'
+  ERROR_STATUS_2 = :failed
+
+  ERROR_CODE_UNDEFINED = 55688
+
+  class MaskedError < CodeError::Base
+    def error_codes
+      {
+        ERROR_CODE_1 => {
+          :status => ERROR_STATUS_1,
+          :msg => ERROR_MSG_1,
+        },
+        ERROR_CODE_2 => {
+          :status => ERROR_STATUS_2,
+          :msg => ERROR_MSG_2,
+          :masked => true
+        }
+      }
+    end
+  end
+
+  def test_masked_should_mask_the_message_if_the_true_masked_arg_is_given_in_msg_and_data
+    e = MaskedError.new(ERROR_CODE_1)
+    assert(e.msg(true) == "#{CodeError::MASKED_MSG}(#{ERROR_CODE_1})")
+    assert(e.data(true) == { :code => ERROR_CODE_1,
+                             :status => ERROR_STATUS_1,
+                             :msg => "#{CodeError::MASKED_MSG}(#{ERROR_CODE_1})",
+                             :info => {} })
+  end
+
+  def test_masked_should_mask_the_message_if_given_code_is_undefined_but_the_true_masked_arg_is_given_in_msg_and_data
+    e = MaskedError.new(ERROR_CODE_UNDEFINED)
+    assert(e.msg(true) == "#{CodeError::MASKED_MSG}(#{ERROR_CODE_UNDEFINED})")
+    assert(e.data(true) == { :code => ERROR_CODE_UNDEFINED,
+                             :status => CodeError::INTERNAL_STATUS,
+                             :msg => "#{CodeError::MASKED_MSG}(#{ERROR_CODE_UNDEFINED})",
+                             :info => {} })
+  end
+
+  def test_masked_should_mask_the_message_if_given_code_is_a_string_but_the_true_masked_arg_is_given_in_msg_and_data
+    msg = 'An error message.'
+    e = MaskedError.new(msg)
+    assert(e.msg(true) == "#{CodeError::MASKED_MSG}(#{CodeError::INTERNAL_CODE})")
+    assert(e.data(true) == { :code => CodeError::INTERNAL_CODE,
+                             :status => CodeError::INTERNAL_STATUS,
+                             :msg => "#{CodeError::MASKED_MSG}(#{CodeError::INTERNAL_CODE})",
+                             :info => {} })
+  end
+
+  def test_masked_should_mask_the_message_if_given_code_is_a_success_code_but_the_true_masked_arg_is_given_in_msg_and_data
+    e = MaskedError.new(CodeError::SUCCESS_CODE)
+    assert(e.msg(true) == "#{CodeError::MASKED_MSG}")
+    assert(e.data(true) == { :code => CodeError::SUCCESS_CODE,
+                             :status => CodeError::SUCCESS_STATUS,
+                             :msg => "#{CodeError::MASKED_MSG}",
+                             :info => {} })
+  end
+
+  def test_masked_should_unmask_the_message_if_given_msg_is_masked_in_new_but_the_false_masked_arg_is_given_in_msg_and_data
+    e = MaskedError.new(ERROR_CODE_1, :masked)
+    assert(e.msg(false) == "#{ERROR_MSG_1}(#{ERROR_CODE_1})")
+    assert(e.data(false) == { :code => ERROR_CODE_1,
+                              :status => ERROR_STATUS_1,
+                              :msg => "#{ERROR_MSG_1}(#{ERROR_CODE_1})",
+                              :info => {} })
+  end
+
+  def test_masked_should_unmask_the_message_if_true_masked_config_is_given_but_the_false_masked_arg_is_given_in_msg_and_data
+    e = MaskedError.new(ERROR_CODE_2)
+    assert(e.msg(false) == "#{ERROR_MSG_2}(#{ERROR_CODE_2})")
+    assert(e.data(false) == { :code => ERROR_CODE_2,
+                              :status => ERROR_STATUS_2,
+                              :msg => "#{ERROR_MSG_2}(#{ERROR_CODE_2})",
+                              :info => {} })
+  end
+end

data/test/test_new.rb

@@ -0,0 +1,100 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "code_error"
+
+class TestNew < Test::Unit::TestCase
+
+  class InvalidError < CodeError::Base; end;
+
+  ERROR_CODE_1 = 1
+  ERROR_MSG_1 = 'The error message for code 1.'
+  ERROR_STATUS_1 = :failed
+
+  ERROR_CODE_2 = 2
+  ERROR_MSG_2 = 'The error message for code 2.'
+  ERROR_STATUS_2 = :failed
+
+  ERROR_CODE_UNDEFINED = 55688
+
+  class TestError < CodeError::Base
+    def error_codes
+      {
+        ERROR_CODE_1 => {
+          :status => ERROR_STATUS_1,
+          :msg => ERROR_MSG_1,
+        },
+        ERROR_CODE_2 => {
+          :status => ERROR_STATUS_2,
+          :msg => ERROR_MSG_2,
+          :masked => true
+        }
+      }
+    end
+  end
+
+  def test_new_should_raise_an_exception_if_the_error_codes_is_undefined
+    assert_raise(RuntimeError) { InvalidError.new }
+  end
+
+  def test_new_should_return_the_correspond_data_if_given_code_is_defined
+    e = TestError.new(ERROR_CODE_1)
+    assert(e.code == ERROR_CODE_1)
+    assert(e.status == ERROR_STATUS_1)
+    assert(e.msg == "#{ERROR_MSG_1}(#{ERROR_CODE_1})")
+    assert(e.data == { :code => ERROR_CODE_1,
+                       :status => ERROR_STATUS_1,
+                       :msg => "#{ERROR_MSG_1}(#{ERROR_CODE_1})",
+                       :info => {} })
+    assert(e.message == e.data.inspect)
+    assert(!e.internal?)
+  end
+
+  def test_new_should_return_an_internal_error_with_given_code_if_given_code_is_undefined
+    e = TestError.new(ERROR_CODE_UNDEFINED)
+    assert(e.code == ERROR_CODE_UNDEFINED)
+    assert(e.status == CodeError::INTERNAL_STATUS)
+    assert(e.msg == "#{CodeError::INTERNAL_MSG}(#{ERROR_CODE_UNDEFINED})")
+    assert(e.internal?)
+  end
+
+  def test_new_should_return_an_internal_error_with_given_msg_if_given_code_is_a_string
+    msg = 'An error message.'
+    e = TestError.new(msg)
+    assert(e.code == CodeError::INTERNAL_CODE)
+    assert(e.status == CodeError::INTERNAL_STATUS)
+    assert(e.msg == "#{msg}(#{CodeError::INTERNAL_CODE})")
+    assert(e.internal?)
+  end
+
+  def test_new_should_return_an_success_error_if_given_code_is_a_success_code
+    e = TestError.new(CodeError::SUCCESS_CODE)
+    assert(e.code == CodeError::SUCCESS_CODE)
+    assert(e.status == CodeError::SUCCESS_STATUS)
+    assert(e.msg == "#{CodeError::SUCCESS_MSG}")
+    assert(!e.internal?)
+  end
+
+  def test_new_should_mask_the_msg_if_given_msg_is_masked
+    e = TestError.new(ERROR_CODE_1, :masked)
+    assert(e.code == ERROR_CODE_1)
+    assert(e.status == ERROR_STATUS_1)
+    assert(e.msg == "#{CodeError::MASKED_MSG}(#{ERROR_CODE_1})")
+    assert(!e.internal?)
+  end
+
+  def test_new_should_mask_the_msg_by_default_if_true_masked_config_is_given
+    e = TestError.new(ERROR_CODE_2)
+    assert(e.code == ERROR_CODE_2)
+    assert(e.status == ERROR_STATUS_2)
+    assert(e.msg == "#{CodeError::MASKED_MSG}(#{ERROR_CODE_2})")
+    assert(!e.internal?)
+  end
+
+  def test_new_should_contain_the_info_if_an_info_is_given
+    info = 'some information'
+    e = TestError.new(ERROR_CODE_1, nil, info)
+    assert(e.info == info)
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: code_error
+version: !ruby/object:Gem::Version
+  version: 0.9.3
+platform: ruby
+authors:
+- Sibevin Wang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-17 00:00:00.000000000 Z
+dependencies: []
+description: A code-based customized error.
+email:
+- sibevin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- code_error.gemspec
+- lib/code_error.rb
+- lib/code_error/random_token_error.rb
+- lib/code_error/version.rb
+- test/test_all.rb
+- test/test_code_in_msg.rb
+- test/test_config.rb
+- test/test_helper.rb
+- test/test_masked.rb
+- test/test_new.rb
+homepage: https://github.com/sibevin/code_error
+licenses:
+- MIT
+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.6
+signing_key: 
+specification_version: 4
+summary: 'Inherit CodeError::Base to create your own code-based error. You need to
+  implement the "error_codes" method which provides a hash to define your own error
+  code map.  class MyError < CodeError::Base  private  def error_codes { 20001 =>
+  { status: :failed, msg: ''Purchase information format is incorrect.'' }, 20002 =>
+  { status: :failed, msg: ''Device information format is incorrect.'' }, 20003 =>
+  { status: :failed, msg: ''Unknown store.'' }, 20100 => { status: :duplicated, msg:
+  ''A duplicated IAP request is sent.'' }, 20200 => { status: :retry, msg: ''Client
+  should send the IAP request again.'' } } end end  Raise an error with a code when
+  you need.  raise MyError.new(20001)  Rescue and handle it.  begin #... raise MyError.new(20001)
+  #... rescue MyError => e raise e if e.internal? msg = e.msg code = e.code info =
+  e.info data = e.data case(e.status) when :failed #... when :duplicated #... else
+  #... end #... end  Please see "README" to get more details.'
+test_files:
+- test/test_all.rb
+- test/test_code_in_msg.rb
+- test/test_config.rb
+- test/test_helper.rb
+- test/test_masked.rb
+- test/test_new.rb
+has_rdoc: