kinetic_cafe_error 1.11 → 1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e59520ae4c59e3bd05ea5222fd800317d735457
-  data.tar.gz: f7e38457bc7b25ec96c4201a7859b55169100a4d
+  metadata.gz: ac74dac14f83a0930ff010ec22ee5f38779bc0fb
+  data.tar.gz: 2d538e50f54639617655dc5e3d8486bdb66730f2
 SHA512:
-  metadata.gz: 2653e7d7e1e214028c91eb1e4ed9ab9249b1cf06f6a24f3fd8f831f07aa942c9259db0a121ac114939705c8eaa0ef21fd752300fd14e1b03109f4018591a09a8
-  data.tar.gz: 398211ce16cfa01a58dd9a105d025ac7c96b4011d9f0caf2b1451afc3a12240da7cfa31367c76d7b38a02dc8bf1b0a08331bbe562f730c27601a86e737945996
+  metadata.gz: a2475041b6851c65005929b3640abd492f625dcee28dee0e7d7c8f57e79c2a0bda44731540a48b483e2e438b65be789381a743c21b06d80c90420e60a800ed77
+  data.tar.gz: 8098e1494dc7c9c12c201e71d8cce5cd7ad3d48ae8602e144ddc83026d8f1c384cf9766a8b52f10e54fcf404a4a518d3fd1b6560e23530f7fec36d37e3e7a105

data/History.md

@@ -1,3 +1,28 @@
+### 1.12 / 2016-05-27
+
+*   4 major enhancements:
+
+    *   Replace the use of ObjectSpace with a custom system to get a list of the
+        children of StandardError. This makes the provided rake tasks compatible
+        with JRuby.
+
+    *   Refactor rake tasks into methods and add tests for those methods.
+
+    *   Errors can now be declared in a severity block where their default_severity
+        will be different from the default of :error.
+
+    *   Error-declarations can accept a block with other error-declaratons in them,
+        allowing for nested error hierarchies.
+
+*   1 bug fix:
+
+    *   Use String#new when we need mutable strings.
+
+*   1 minor enhancement:
+
+    *   If the controller instance does not respond to the 'respond_to' method,
+        then we default to rendering a JSON response.
+
 ### 1.11 / 2016-05-24
 
 *   1 minor enhancement:

data/Manifest.txt

@@ -27,6 +27,7 @@ lib/kinetic_cafe/error_rspec.rb
 lib/kinetic_cafe/error_tasks.rake
 lib/kinetic_cafe/error_tasks.rb
 lib/kinetic_cafe_error.rb
+test/test_error_tasks.rb
 test/test_helper.rb
 test/test_kinetic_cafe_error.rb
 test/test_kinetic_cafe_error_dsl.rb

data/lib/kinetic_cafe/error.rb

@@ -26,7 +26,7 @@ module KineticCafe # :nodoc:
   # rescue clause and handled there, as is shown in the included
   # KineticCafe::ErrorHandler controller concern for Rails.
   class Error < ::StandardError
-    VERSION = '1.11' # :nodoc:
+    VERSION = '1.12' # :nodoc:
 
     # Get the KineticCafe::Error functionality.
     include KineticCafe::ErrorModule
@@ -175,4 +175,4 @@ end
 
 require_relative 'error_dsl'
 require_relative 'error_engine' if defined?(::Rails)
-require_relative 'error_tasks' if defined?(::Rake::DSL)
+require_relative 'error_tasks' if defined?(::Rake)

data/lib/kinetic_cafe/error_dsl.rb

@@ -1,7 +1,9 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
+
+##
 module KineticCafe
   # Make defining new children of KineticCafe::Error easy. Adds the
-  # #define_error method.
+  # #define_error method and #severity block modifier.
   #
   # If using when Rack is present, useful variant methodss are provided
   # matching Rack status symbol codes. These set the default status to the Rack
@@ -78,7 +80,10 @@ module KineticCafe
     # +i18n_params+:: An array of parameter names that are expected to be
     #                 provided for translation. This helps document the
     #                 expected translations.
-    def define_error(options)
+    #
+    # If a +block+ is provided, errors may be defined as subclasses of the error
+    # defined here.
+    def define_error(options, &block)
       fail ArgumentError, 'invalid options' unless options.kind_of?(Hash)
       fail ArgumentError, 'define what error?' if options.empty?
 
@@ -91,10 +96,12 @@ module KineticCafe
         fail ArgumentError, ":key conflicts with class:#{klass}" if options.key?(:key)
 
         key = if status.kind_of?(Symbol) || status.kind_of?(String)
-                "#{klass}_#{KineticCafe::ErrorDSL.namify(status)}"
-              else
-                "#{klass}_#{KineticCafe::ErrorDSL.namify(name)}"
-              end
+          "#{klass}_#{KineticCafe::ErrorDSL.namify(status)}"
+        else
+          "#{klass}_#{KineticCafe::ErrorDSL.namify(name)}"
+        end
+
+        key = String.new(key)
       else
         key = options.fetch(:key) {
           fail ArgumentError, 'one of :key or :class must be provided'
@@ -115,7 +122,7 @@ module KineticCafe
       i18n_key = "#{i18n_key_base}.#{key}"
 
       if const_defined?(error_name)
-        message = "key:#{key} already exists as #{error_name}"
+        message = String.new("key:#{key} already exists as #{error_name}")
         message << " with class:#{klass}" if klass
         fail ArgumentError, message
       end
@@ -141,27 +148,52 @@ module KineticCafe
       status ||= defined?(Rack::Utils) && :bad_request || 400
       status.freeze
 
-      severity ||= :error
+      if status
+        error.send :define_method, :default_status, -> { status }
+        error.send :private, :default_status
+        error.send :define_singleton_method, :default_status, -> { status }
+      end
+
+      severity ||= @severity || :error
       severity.freeze
 
-      error.send :define_method, :default_status, -> { status } if status
-      error.send :define_method, :default_severity, -> { severity } if severity
-      error.send :private, :default_status
+      if severity
+        error.send :define_method, :default_severity, -> { severity }
+        error.send :define_singleton_method, :default_severity, -> { severity }
+      end
+
+      error.instance_exec(&block) if block
 
       const_set(error_name, error)
     end
 
-    ##
-    def self.included(_mod)
+    # Temporarily override the default severity with +value+ for errors defined in
+    # the provided +block+.
+    def severity(value, &block)
+      old_severity, @severity = @severity, value
+      fail 'Severity must have a block' unless block
+      instance_exec(&block)
+    ensure
+      @severity = old_severity
+    end
+
+    # Keep track of subclasses of errors using ErrorDSL.
+    def inherited(subclass) #:nodoc:
+      super
+      KineticCafe::ErrorDSL.inheritors << subclass
+    end
+
+    def self.included(_mod) # :nodoc:
       fail "#{self} cannot be included"
     end
 
-    ##
-    def self.extended(base)
+    def self.extended(base) # :nodoc:
       unless base < ::StandardError
         fail "#{self} cannot extend #{base} (not a StandardError)"
       end
 
+      inheritors << base
+
       rack_status = base.__rack_status if base.respond_to?(:__rack_status)
 
       case rack_status
@@ -178,8 +210,8 @@ module KineticCafe
           # Make the Rack names safe to use
           name = name.to_s.gsub(/[^[:word:]]/, '_').squeeze('_').to_sym
           if rack_status.fetch(:methods, true)
-            base.singleton_class.send :define_method, name do |options = {}|
-              define_error(options.merge(status: name))
+            base.singleton_class.send :define_method, name do |options = {}, &block|
+              define_error(options.merge(status: name), &block)
             end
           end
 
@@ -189,5 +221,9 @@ module KineticCafe
         end
       end
     end
+
+    def self.inheritors # :nodoc:
+      @inheritors ||= []
+    end
   end
 end

data/lib/kinetic_cafe/error_tasks.rb

@@ -1,102 +1,144 @@
 # frozen_string_literal: true
 
+require 'kinetic_cafe_error'
+
 module KineticCafe
   # Tasks to assist with managing kinetic_cafe_error classes in Rake.
   module ErrorTasks #:nodoc:
-    extend Rake::DSL
+    require 'rake' unless defined?(::Rake)
+
+    extend ::Rake::DSL
   end
 end
 
-##
-module KineticCafe::ErrorTasks #:nodoc:
-  require 'kinetic_cafe_error'
-
-  namespace :kcerror do
-    desc 'Show defined errors.'
-    task :defined, [ :params ] => 'kcerror:find' do |_, args|
-      display = ->(root, prefix: '', show_params: false) {
-        line = "#{prefix}- #{root}"
-
-        if !root.i18n_params.empty? && show_params
-          line << ' (' << root.i18n_params.join(', ') << ')'
-        end
-
-        puts line
-
-        if @descendants[root]
-          sorted = @descendants[root].sort_by(&:to_s)
-          sorted.each do |child|
-            s = (child == sorted.last) ? '`' : '|'
-            display.(
-              child,
-              prefix: "#{prefix.tr('|`', ' ')}  #{s}",
-              show_params: show_params
-            )
-          end
-        end
+class << KineticCafe::ErrorTasks
+  def print_defined(descendants = @descendants, output: $stdout, params: false)
+    if descendants[::StandardError].nil? || descendants[::StandardError].empty?
+      output.puts 'No defined errors.'
+    else
+      descendants[::StandardError].sort_by(&:to_s).each { |d|
+        display_error_class(descendants, d, output: output, params: params)
       }
+    end
+  end
 
-      show_params = args.params =~ /^y/i
+  def print_translation_yaml(descendants = @descendants, output: $stdout)
+    output.puts build_translation_yaml(descendants)
+  end
 
-      if @descendants[StandardError]
-        @descendants[StandardError].sort_by(&:to_s).each { |d|
-          display.(d, show_params: show_params)
-        }
-      else
-        puts 'No defined errors.'
+  private
+
+  def display_error_class(descendants, root, output: $stdout, prefix: '', params: false)
+    line = String.new("#{prefix}- #{root}")
+
+    if !root.i18n_params.empty? && params
+      line << ' (' << root.i18n_params.join(', ') << ')'
+    end
+
+    output.puts line
+
+    if descendants[root]
+      sorted = descendants[root].sort_by(&:to_s)
+      sorted.each do |child|
+        s = (child == sorted.last) ? '`' : '|'
+        display_error_class(
+          descendants,
+          child,
+          output: output,
+          prefix: "#{prefix.tr('|`', ' ')}  #{s}",
+          params: params
+        )
       end
     end
+  end
 
-    desc 'Generate a sample translation key file.'
-    task :translations, [ :output ] => 'kcerror:find' do |_, args|
-      translations = {}
-      traverse = ->(root) {
-        translation = (translations[root.i18n_key_base] ||= {})
-        name = KineticCafe::ErrorDSL.namify(root)
-
-        params = root.i18n_params.map { |param| "%{#{param}}" }.join(' ')
-
-        if params.empty?
-          translation[name] = "Translation for #{name} with no params."
-        else
-          translation[name] = "Translation for #{name} with #{params}."
-        end
-
-        if @descendants[root]
-          @descendants[root].sort_by(&:to_s).each { |child| traverse.(child) }
-        end
-      }
+  def build_error_hierarchy(error_class_list)
+    Hash.new { |h, k| h[k] = [] }.tap do |hierarchy|
+      error_class_list.each do |error_class|
+        hierarchy[error_class.superclass] << error_class
+      end
+
+      hierarchy[::StandardError].push(
+        *(
+          hierarchy.keys.select { |r| r.superclass == ::StandardError } -
+          hierarchy[::StandardError]
+        )
+      )
+    end
+  end
+
+  def find_with_error_dsl_inheritors
+    @descendants = build_error_hierarchy(KineticCafe::ErrorDSL.inheritors)
+  end
 
-      if @descendants[StandardError]
-        @descendants[StandardError].sort_by(&:to_s).each do |d| traverse.(d) end
+  def collect_translations(descendants, translations, root)
+    translation = (translations[root.i18n_key_base] ||= {})
+    name = KineticCafe::ErrorDSL.namify(root)
 
-        # Normal YAML dump does not match the pattern that we want to compare
-        # against. Therefore, we are going to write this file manually.
-        text = 'kc:'
+    params = root.i18n_params.map { |param| "%{#{param}}" }.join(' ')
 
-        translations.keys.sort.each do |group|
-          text << "\n  #{group}:"
+    translation[name] = if params.empty?
+                          "Translation for #{name} with no params."
+                        else
+                          "Translation for #{name} with #{params}."
+                        end
 
-          translations[group].keys.sort.each { |k|
-            text << "\n    #{k}: >-\n      #{translations[group][k]}"
-          }
-        end
+    if descendants[root]
+      descendants[root].sort_by(&:to_s).each do |child|
+        collect_translations(descendants, translations, child)
+      end
+    end
+  end
 
-        if args.output
-          File.open(args.output, 'w') { |f| f.puts text }
-        else
-          puts text
-        end
+  def find_translations(descendants)
+    {}.tap do |translations|
+      descendants[::StandardError].sort_by(&:to_s).each do |d|
+        collect_translations(descendants, translations, d)
       end
     end
+  end
 
-    task :find do
-      @descendants = {}
-      ObjectSpace.each_object(Class) do |k|
-        next unless k.singleton_class < KineticCafe::ErrorDSL
+  def build_translation_yaml(descendants)
+    translations = find_translations(descendants)
+    return if translations.empty?
+
+    # Normal YAML dump does not match the pattern that we want to compare
+    # against. Therefore, we are going to write this file manually.
+    String.new('kc:').tap do |text|
+      translations.keys.sort.each do |group|
+        text << "\n  #{group}:"
 
-        (@descendants[k.superclass] ||= []) << k
+        translations[group].keys.sort.each { |k|
+          text << "\n    #{k}: >-\n      #{translations[group][k]}"
+        }
       end
     end
   end
+
+  def save_translation_yaml(filename, descendants = @descendants)
+    File.open(filename, 'w') { |f| print_translation_yaml(descendants, output: f) }
+  end
+end
+
+##
+module KineticCafe::ErrorTasks #:nodoc:
+  namespace :kcerror do
+    desc 'Show defined errors.'
+    task :defined, [ :params ] => 'kcerror:find' do |_, args|
+      print_defined(params: args.params =~ /^y/i)
+    end
+
+    desc 'Generate a sample translation key file.'
+    task :translations, [ :output ] => 'kcerror:find' do |_, args|
+      if args.output
+        save_translation_yaml(args.output)
+      else
+        print_translation_yaml
+      end
+    end
+
+    task :find do
+      find_with_error_dsl_inheritors
+    end
+  end
 end

data/test/test_error_tasks.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'kinetic_cafe/error_tasks'
+
+describe KineticCafe::ErrorTasks do
+  def setup
+    Object.const_set(:My, Module.new)
+    KineticCafe::Error.hierarchy(class: :Base, namespace: My, rack_status: { errors: false }) do
+      define_error class: :child, status: :not_found, i18n_params: %i(query)
+      define_error key: :other_child, status: :bad_request do
+        define_error key: :sub_child, status: :im_a_teapot
+      end
+    end
+  end
+
+  def teardown
+    Object.send(:remove_const, :My)
+  end
+
+  describe '.print_defined' do
+    describe 'when no StandardError descendants' do
+      it 'prints no defined errors' do
+        io = StringIO.new
+        KineticCafe::ErrorTasks.print_defined({}, { output: io })
+
+        assert_match(/No defined errors./, io.string)
+      end
+    end
+
+    describe 'when data' do
+      it 'prints out the classes involved, sorted' do
+        io = StringIO.new
+
+        classes = [
+          My::Base,
+          My::Base::ChildNotFound, My::Base::OtherChild,
+          My::Base::OtherChild::SubChild
+        ]
+        descendants = KineticCafe::ErrorTasks.send(:build_error_hierarchy, classes)
+        KineticCafe::ErrorTasks.print_defined(descendants, output: io)
+
+        expected = [
+          'KineticCafe::Error',
+          'My::Base',
+          'My::Base::ChildNotFound',
+          'My::Base::OtherChild',
+          'My::Base::OtherChild::SubChild'
+        ]
+        actual = io.string.scan(/ \w.+\n/).map(&:strip)
+
+        assert_equal expected, actual
+      end
+    end
+  end
+
+  describe '.print_translation_yaml' do
+    describe 'when no StandardError descendant' do
+      it 'prints no defined errors' do
+        io = StringIO.new
+        KineticCafe::ErrorTasks.print_defined({}, { output: io })
+
+        assert_match(/No defined errors./, io.string)
+      end
+    end
+
+    describe 'when data' do
+      it 'prints the correct data in YAML format' do
+        io = StringIO.new
+
+        classes = [
+          My::Base,
+          My::Base::ChildNotFound, My::Base::OtherChild,
+          My::Base::OtherChild::SubChild
+        ]
+        descendants = KineticCafe::ErrorTasks.send(:build_error_hierarchy, classes)
+        KineticCafe::ErrorTasks.print_translation_yaml(descendants, output: io)
+
+        expected = { 'kc' =>
+                    { 'kcerrors' =>
+                     {
+                       'base' => 'Translation for base with no params.',
+                       'child_not_found' => 'Translation for child_not_found with %{query}.',
+                       'error' => 'Translation for error with no params.',
+                       'other_child' => 'Translation for other_child with no params.',
+                       'sub_child' => 'Translation for sub_child with no params.'
+                     } } }
+
+        actual = YAML.load(io.string)
+
+        assert_equal expected, actual
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -8,6 +8,7 @@ require 'minitest/moar'
 require 'minitest/stub_const'
 require 'minitest-bonus-assertions'
 require 'rack/test'
+require 'yaml'
 require 'kinetic_cafe_error'
 
 puts "Testing with Rack.release #{Rack.release}"

data/test/test_kinetic_cafe_error_dsl.rb

@@ -36,6 +36,34 @@ describe KineticCafe::ErrorDSL do
       assert base.respond_to?(:define_error)
     end
 
+    describe '#severity' do
+      describe 'fails when' do
+        it 'is not passed a block' do
+          ex = assert_raises RuntimeError do
+            base.severity(:foo)
+          end
+
+          assert_match(/must have a block/, ex.message)
+        end
+      end
+
+      it 'creates any errors in its block with the given severity, then reverts to old severity' do
+        severity = :test_level
+
+        base.severity(severity) do
+          not_found key: :foo
+          not_found key: :bar
+        end
+
+        assert_equal severity, base::Foo.default_severity
+        assert_equal severity, base::Bar.default_severity
+
+        base.define_error key: :child
+
+        refute_equal severity, base::Child.default_severity
+      end
+    end
+
     describe '#define_error' do
       describe 'fails when' do
         it 'given bad options' do
@@ -113,6 +141,18 @@ describe KineticCafe::ErrorDSL do
         end
       end
 
+      describe 'when nested definitions' do
+        it 'creates a nested error' do
+          base.define_error(key: :child) do
+            not_found key: :foo
+          end
+
+          assert base::Child::Foo < base::Child
+
+          assert base::Child::Foo.respond_to?(:default_severity)
+        end
+      end
+
       describe 'class-based definition' do
         describe 'without status' do
           before do

data/test/test_kinetic_cafe_error_hierarchy.rb

@@ -84,6 +84,10 @@ describe KineticCafe::Error, '.hierarchy' do
         KineticCafe::Error.hierarchy(class: My)
       end
 
+      it 'does not subclass KineticCafe::Error' do
+        refute My < KineticCafe::Error
+      end
+
       it 'has been extended with KineticCafe::ErrorDSL' do
         assert My.singleton_class < KineticCafe::ErrorDSL
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kinetic_cafe_error
 version: !ruby/object:Gem::Version
-  version: '1.11'
+  version: '1.12'
 platform: ruby
 authors:
 - Austin Ziegler
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-24 00:00:00.000000000 Z
+date: 2016-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -364,6 +364,7 @@ files:
 - lib/kinetic_cafe/error_tasks.rake
 - lib/kinetic_cafe/error_tasks.rb
 - lib/kinetic_cafe_error.rb
+- test/test_error_tasks.rb
 - test/test_helper.rb
 - test/test_kinetic_cafe_error.rb
 - test/test_kinetic_cafe_error_dsl.rb
@@ -390,7 +391,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: kinetic_cafe_error provides an API-smart error base class and a DSL for defining