code_error 0.9.3 → 1.0.0

data/code_error.gemspec

@@ -9,47 +9,44 @@ Gem::Specification.new do |spec|
   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.
+Inherit CodeError::Base to create your own code-based error. You need to assign "error_codes" with 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.'
-          }
+      error_codes({
+        purchase_info_incorrect: {
+          status: :failed,
+          msg: 'Purchase information format is incorrect.'
+        },
+        device_info_incorrect: {
+          status: :failed,
+          msg: 'Device information format is incorrect.'
+        },
+        unknown_store: {
+          status: :failed,
+          msg: 'Unknown store.'
+        },
+        duplicated_request: {
+          status: :duplicated,
+          msg: 'A duplicated IAP request is sent.'
+        },
+        resend_iap: {
+          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)
+    raise MyError.gen(:purchase_info_incorrect)
 
 Rescue and handle it.
 
     begin
       #...
-      raise MyError.new(20001)
+      raise MyError.gen(:purchase_info_incorrect)
       #...
     rescue MyError => e
       raise e if e.internal?
@@ -75,4 +72,5 @@ Please see "README" to get more details.
   spec.files         = `git ls-files`.split($/)
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.add_development_dependency 'minitest', '~> 5.0'
 end

data/lib/code_error.rb

@@ -1,102 +1,161 @@
 module CodeError
 
-  SUCCESS_CODE = 0
+  SUCCESS_CODE = :success
   SUCCESS_STATUS = :success
   SUCCESS_MSG = ''
 
-  INTERNAL_CODE = 99999
+  INTERNAL_CODE = :internal
   INTERNAL_STATUS = :internal
   INTERNAL_MSG = 'An internal error occurs.'
 
-  MASKED_MSG = 'An error occurs.'
+  DEFAULT_MASKED_MSG = 'An error occurs.'
+
+  DEFAULT_POS = :none
+
+  DEFAULT_MASKED = false
 
   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
+    @@global_config = {
+      :success => {
+        :code =>   SUCCESS_CODE,
+        :status => SUCCESS_STATUS,
+        :msg =>    SUCCESS_MSG,
+        :pos =>    DEFAULT_POS,
+        :masked => DEFAULT_MASKED
+      },
+      :internal => {
+        :code =>   INTERNAL_CODE,
+        :status => INTERNAL_STATUS,
+        :msg =>    INTERNAL_MSG,
+        :pos =>    DEFAULT_POS,
+        :masked => DEFAULT_MASKED
+      },
+      :masked_msg => DEFAULT_MASKED_MSG,
+      :pos =>        DEFAULT_POS,
+      :masked =>     DEFAULT_MASKED
+    }
+
+    def self.gen(code = nil, options = {})
+      merge_klass_config
+      @error_codes = {} unless @error_codes
+      new(code, options, @error_codes, @klass_config)
     end
 
-    def message
-      self.data.inspect
+    def self.error_codes(data = {})
+      @error_codes = data
     end
 
-    def data(masked = nil)
-      msg = show_message(@code, @msg, masked)
-      { status: @status, code: @code, msg: msg, info: @info }
+    def self.success(data = {})
+      merge_klass_config( :success => data )
     end
 
-    def msg(masked = nil)
-      show_message(@code, @msg, masked)
+    def self.internal(data = {})
+      merge_klass_config( :internal => data )
     end
 
-    def internal?
-      @status == config[:internal][:status]
+    def self.masked_msg(msg = nil)
+      merge_klass_config( :masked_msg => msg )
     end
 
-    private
+    def self.masked(masked = false)
+      merge_klass_config( :masked => masked )
+    end
+
+    def self.pos(pos = nil)
+      merge_klass_config( :pos => pos )
+    end
 
-    def error_codes
-      raise 'You should implement error_codes method in your code-based class.'
+    def message
+      self.data.inspect
     end
 
-    def config
+    def data(options = {})
       {
-        :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
+        :status => @status,
+        :code => @code,
+        :msg => show_message(@code, @msg, options),
+        :info => @info
       }
     end
 
-    def show_message(code, msg, masked = nil)
-      if masked == nil
-        masked = @masked || false
+    def msg(options = {})
+      show_message(@code, @msg, options)
+    end
+
+    def internal?
+      @status == @internal_status
+    end
+
+    # === private methods ===
+
+    def self.merge_klass_config(new_option = {})
+      unless @klass_config
+        @klass_config = {
+          :success => {},
+          :internal => {},
+          :masked_msg => nil,
+          :pos => nil,
+          :masked => nil
+        }
       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}"
+      @klass_config.merge!(new_option)
+    end
+
+    private_class_method :merge_klass_config
+
+    def initialize(code = nil, options = {}, code_map = {}, klass_config = {})
+      @code =       code
+      @info =       options[:info]
+      @masked_msg = options[:masked_msg] || klass_config[:masked_msg] || @@global_config[:masked_msg]
+      @success_code =    klass_config[:success][:code]    || @@global_config[:success][:code]
+      @internal_code =   klass_config[:internal][:code]   || @@global_config[:internal][:code]
+      @internal_status = klass_config[:internal][:status] || @@global_config[:internal][:status]
+      if code_map.keys.include?(code)
+        @status = code_map[code][:status]
+        @msg =    options[:msg] || code_map[code][:msg] || klass_config[:internal][:msg]  || @@global_config[:internal][:msg]
+        @pos =    nil_next(options[:pos],    nil_next(code_map[code][:pos],    nil_next(klass_config[:pos],    @@global_config[:pos])))
+        @masked = nil_next(options[:masked], nil_next(code_map[code][:masked], nil_next(klass_config[:masked], @@global_config[:masked])))
+      elsif code == @success_code
+        @code = @success_code
+        @status = options[:status] || klass_config[:success][:status] || @@global_config[:success][:status]
+        @msg =    options[:msg]    || klass_config[:success][:msg]    || @@global_config[:success][:msg]
+        @pos =    options[:pos]    || klass_config[:success][:pos]    || @@global_config[:success][:pos]
+        @masked = nil_next(options[:masked], nil_next(klass_config[:success][:masked], @@global_config[:success][:masked]))
+      else
+        # :internal or unknown code
+        if code.is_a?(String)
+          @code = @internal_code
+          @msg = code
+        else
+          @code = code
+          @msg =  options[:msg]    || klass_config[:internal][:msg]    || @@global_config[:internal][:msg]
         end
+        @status = options[:status] || @internal_status
+        @pos =    options[:pos]    || klass_config[:internal][:pos]    || @@global_config[:internal][:pos]
+        @masked = nil_next(options[:masked], nil_next(klass_config[:internal][:masked], @@global_config[:internal][:masked]))
+      end
+    end
+
+    private_class_method :new
+
+    private
+
+    def show_message(code, msg, options = {})
+      masked = nil_next(options[:masked], @masked)
+      pos = nil_next(options[:pos], @pos)
+      display_msg = masked ? @masked_msg : msg
+      case pos
+        when :append then "#{display_msg} (#{code})"
+        when :prepend then "(#{code}) #{display_msg}"
+        else
+          "#{display_msg}"
       end
-      m
+    end
+
+    def nil_next(first, second)
+      (first.nil? ? second : first)
     end
   end
 end

data/lib/code_error/version.rb

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

data/test/test_all.rb

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

data/test/test_config.rb

@@ -1,116 +1,103 @@
-require "test/unit"
+require "minitest/autorun"
 
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"
 require "code_error"
 
-class TestConfig < Test::Unit::TestCase
+class TestConfig < Minitest::Test
 
-  ERROR_CODE_1 = 1
-  ERROR_MSG_1 = 'The error message for code 1.'
-  ERROR_STATUS_1 = :failed
+  CONFIG_ERROR_CODE_1 = :config_code1
+  CONFIG_ERROR_MSG_1 = 'The config error message for code 1.'
+  CONFIG_ERROR_STATUS_1 = :config_failed
 
-  ERROR_CODE_2 = 2
-  ERROR_MSG_2 = 'The error message for code 2.'
-  ERROR_STATUS_2 = :failed
+  CONFIG_ERROR_CODE_2 = :config_code2
+  CONFIG_ERROR_MSG_2 = 'The config error message for code 2.'
+  CONFIG_ERROR_STATUS_2 = :config_failed
 
-  ERROR_CODE_UNDEFINED = 55688
+  CONFIG_ERROR_CODE_UNDEFINED = :config_undefined_code
 
-  MY_SUCCESS_CODE = :my_success_code
-  MY_SUCCESS_MSG = 'My success error message.'
-  MY_SUCCESS_STATUS = :my_success_status
+  MY_SUCCESS_CODE = :my_config_success_code
+  MY_SUCCESS_MSG = 'My config success error message.'
+  MY_SUCCESS_STATUS = :my_config_success_status
 
-  MY_INTERNAL_CODE = :my_internal_code
-  MY_INTERNAL_MSG = 'My internal error message.'
-  MY_INTERNAL_STATUS = :my_internal_status
+  MY_INTERNAL_CODE = :my_config_internal_code
+  MY_INTERNAL_MSG = 'My config internal error message.'
+  MY_INTERNAL_STATUS = :my_config_internal_status
 
-  MY_MASKED_MSG = 'My masked message.'
+  MY_MASKED_MSG = 'My config 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
-        }
+    error_codes({
+      CONFIG_ERROR_CODE_1 => {
+        :status => CONFIG_ERROR_STATUS_1,
+        :msg => CONFIG_ERROR_MSG_1,
+      },
+      CONFIG_ERROR_CODE_2 => {
+        :status => CONFIG_ERROR_STATUS_2,
+        :msg => CONFIG_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
+    })
+
+    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
   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})")
+    e = ConfigError.gen(CONFIG_ERROR_CODE_1)
+    assert(e.code == CONFIG_ERROR_CODE_1)
+    assert(e.status == CONFIG_ERROR_STATUS_1)
+    assert(e.msg == CONFIG_ERROR_MSG_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)
+    e = ConfigError.gen(CONFIG_ERROR_CODE_UNDEFINED)
+    assert(e.code == CONFIG_ERROR_CODE_UNDEFINED)
     assert(e.status == MY_INTERNAL_STATUS)
-    assert(e.msg == "#{MY_INTERNAL_MSG}(#{ERROR_CODE_UNDEFINED})")
+    assert(e.msg == MY_INTERNAL_MSG)
     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)
+    e = ConfigError.gen(msg)
     assert(e.code == MY_INTERNAL_CODE)
     assert(e.status == MY_INTERNAL_STATUS)
-    assert(e.msg == "#{msg}(#{MY_INTERNAL_CODE})")
+    assert(e.msg == msg)
     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)
+    e = ConfigError.gen(MY_SUCCESS_CODE)
     assert(e.code == MY_SUCCESS_CODE)
     assert(e.status == MY_SUCCESS_STATUS)
-    assert(e.msg == "#{MY_SUCCESS_MSG}")
+    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})")
+    e = ConfigError.gen(CONFIG_ERROR_CODE_1, :masked => true)
+    assert(e.code == CONFIG_ERROR_CODE_1)
+    assert(e.status == CONFIG_ERROR_STATUS_1)
+    assert(e.msg == MY_MASKED_MSG)
     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)
+    e = ConfigError.gen(CONFIG_ERROR_CODE_1, :info => info)
     assert(e.info == info)
   end
 end