rescue-dog 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cafa21df2d504ab347d4e9164a227d692dc94096
-  data.tar.gz: 23d90492c087617ea7241c15a9635f7d585d86f0
+  metadata.gz: 0e2a7f7faf7befcd8fb279f982baa669fcf66964
+  data.tar.gz: 21ea12236b212cc34badb3351fe6892bff346f42
 SHA512:
-  metadata.gz: ddf72573ce9f3deab8ee9f0d08ee65b7eea1f94ed6d0d17cc2fc0c8c499b2ae5f540118e386134c803b96c42b61ce1bdc4fa6525863adc61dca1a165d750f5f4
-  data.tar.gz: bbc8b7508ad09d9818d918c690f979f6220efa0d901d3f5dc2126d21330f77317255313d383c7c89b225186bc112912c720f4365e759f42a5c67e46ae1733400
+  metadata.gz: cbfc2e1db3316d00f46c99ebf4a79c2e5b24e0e4cfc16512e2ce095da21b3c2927de1d0caa3ce556e590b3a16845a402782b44ab6be160729c3452654bcbbd89
+  data.tar.gz: b43644434d7c85cc0e5c1835b8a92c3769443a5f4bcafc610640a77b894f2e149ac09efde1d77c5ed32a93a86e27cf160cada1104be73239dc47f26258ad285c

data/README.md

@@ -28,7 +28,7 @@ $ gem install rescue-dog
 
 ## Simple CRUD Actions
 
-1. Include `Rescue::Controller::Static` (or `Rescue::Controller::Dynamic`).
+1. Include `Rescue::Controller` (Rescue::Controller::Static` or `Rescue::Controller::Dynamic`).
 2. Call `rescue_controller` method.
 
 ### Define Actions

data/config/locales/rescue.yml

@@ -1,24 +1,24 @@
 en:
   default:
     flash:
-      success: "default_controller success"
-      error: "default_controller error"
+      success: "default success"
+      error: "default error"
 
   views:
     rescue:
       action:
         flash:
-          success: "rescue_controller success"
-          error: "rescue_controller error"
+          success: "rescue success"
+          error: "rescue error"
       dog:
         action:
           flash:
-            success: "success"
-            error: "error"
+            success: "rescue/dog success"
+            error: "rescue/dog error"
 
     rescue_dog:
       action:
         flash:
-          success: "rescue_dog_controller success"
-          error: "rescue_dog_controller error"
+          success: "rescue_dog success"
+          error: "rescue_dog error"
 

data/lib/rescue/controller.rb

@@ -2,6 +2,24 @@
 module Rescue
   module Controller
 
+    def self.included(base)
+      base.extend Rescue::Controller::ClassMethods
+    end
+
+    def rescue_respond call, params, options = {}
+      begin
+        send(call, params)
+        success_message = options[:success]||Flash.message(self, :success)
+        flash[:success] = success_message unless success_message.blank?
+        instance_exec(&options[:render])
+      rescue => e
+        Rails.logger.debug ([e.message] + e.backtrace).join("\n\t")
+        error_message = options[:error]||Flash.message(self, :error)
+        flash.now[:error] = error_message unless error_message.blank?
+        instance_exec(&options[:rescue])
+      end
+    end
+
     module ClassMethods
 
       def rescue_associate *klasses, &block
@@ -37,54 +55,24 @@ module Rescue
       end
 
       def rescue_controller clazz, *actions
-        options    = actions.extract_options!
-        name       = clazz.name.downcase
-        var_sym    = :"@#{name}"
-        params_sym = :"#{name}_params"
-
-        Parameter.define(self)
-        Action.define(self, clazz, var_sym, params_sym)
+        options      = actions.extract_options!
+        method_names = actions + options.keys
+        name         = clazz.name.downcase
 
-        [:new, :edit, :show, :create, :update, :delete].each do |type|
-          args = options.delete(type) || (actions.delete(type) ? {} : nil)
-          define_action_method(type, args) if args
+        [:show, :edit, :new].each do |type|
+          (options.delete(type)||[]).each do |name|
+            method_names << name
+            options[name] = { type: type }
+          end
         end
-      end
 
-      def define_action_method name, options = {}
-        raise RuntimeError "`name` is already defined." if method_defined?(name)
-        options[:type]  ||= name
-        options[:flash] ||= [:create, :update, :delete].include?(options[:type])
-        call_method = case options[:type]
-          when :show, :edit ; :find_call
-          else ; :"#{options[:type]}_call"
-        end
-        rescue_given    = options[:rescue]||options[:error]||options[:flash]
-        success_message = options[:success]
-        error_message   = options[:error]
-        if options[:flash]
-          success_message ||= Flash.message(self, name, :success)
-          error_message   ||= Flash.message(self, name, :error)
+        [:create, :update, :destroy].each do |type|
+          options[type] ||= {}
+          options[type][:params] ||= :"#{type}_params"
         end
 
-        if rescue_given
-          define_method name do
-            begin
-              send(call_method, &options[:intercept])
-              flash[:success] = success_message unless success_message.blank?
-              instance_exec(&options[:render]) if options[:render]
-            rescue => e
-              Rails.logger.debug(e.backtrace.unshift(e.message).join("\n\t"))
-              flash.now[:error] = error_message unless error_message.blank?
-              instance_exec(&options[:rescue]) if options[:rescue]
-            end
-          end
-        else
-          define_method name do
-            send(call_method)
-            instance_exec(&options[:render]) if options[:render]
-          end
-        end
+        Action.define_call(self, clazz, :"@#{name}")
+        Action.define(self, method_names, options)
       end
 
     end

data/lib/rescue/controllers/action.rb

@@ -3,31 +3,56 @@ module Rescue
   module Controller
     class Action
 
-      def self.define object, clazz, var_sym, params_sym
-        object.send(:define_method, :new_call) do
-          instance_variable_set(var_sym, clazz.new)
+      def self.define_call object, clazz, var_sym
+        object.send(:define_method, :new_call) do |params = {}|
+          instance_variable_set(var_sym, clazz.new(params))
         end
-        object.send(:define_method, :find_call) do
-          id   = find_params[Rescue.config.primary_key]
-          instance_variable_set(var_sym, clazz.find(id))
+        object.send(:define_method, :find_call) do |params = {}|
+          id = (params.empty? ? send(:params) : params).delete(Rescue.config.primary_key)
+          instance_variable_set(var_sym, clazz.where(params).find(id))
         end
-        object.send(:define_method, :create_call) do |&block|
-          instance_variable_set(var_sym, clazz.new(send(params_sym)))
-          instance_exec(&block) if block
+        object.send(:define_method, :create_call) do |params|
+          new_call(params)
           instance_variable_get(var_sym).save!
         end
-        object.send(:define_method, :update_call) do |&block|
+        object.send(:define_method, :update_call) do |params|
           find_call
-          instance_variable_get(var_sym).attributes = send(params_sym)
-          instance_exec(&block) if block
+          instance_variable_get(var_sym).attributes = params
           instance_variable_get(var_sym).save!
         end
-        object.send(:define_method, :delete_call) do |&block|
-          find_call
-          instance_exec(&block) if block
-          instance_variable_get(var_sym).destroy!
+        object.send(:define_method, :destroy_call) do |params|
+          find_call(params)
+          instance_variable_get(var_sym).destroy
+        end
+        object.send(:private, :new_call, :find_call, :create_call, :update_call, :destroy_call)
+      end
+
+      def self.define object, names, args = {}
+        names.each do |name|
+          options = args[name]||{}
+          type    = options[:type]||name
+          raise RuntimeError "`name` is already defined." if object.private_method_defined?(name)
+          case type
+          when :show, :edit
+            object.send(:define_method, name) do
+              send(:find_call)
+              instance_exec(&options[:render]) if options[:render]
+            end
+          when :new
+            object.send(:define_method, name) do
+              params = options[:params] ? send(options[:params]) : {}
+              send(:new_call, params)
+              instance_exec(&options[:render]) if options[:render]
+            end
+          when :create, :update, :destroy
+            object.send(:define_method, name) do
+              params = send(options[:params]||:"#{name}_params")
+              rescue_respond(:"#{type}_call", params, options)
+            end
+          else
+            raise RuntimeError "Undefined action type `#{type}`."
+          end
         end
-        object.send(:private, :new_call, :find_call, :create_call, :update_call, :delete_call)
       end
 
     end

data/lib/rescue/controllers/dynamic.rb

@@ -23,7 +23,7 @@ module Rescue
             end
           end
         end
-        base.extend Rescue::Controller::ClassMethods
+        base.send(:include, Rescue::Controller)
       end
 
     end

data/lib/rescue/controllers/flash.rb

@@ -3,9 +3,11 @@ module Rescue
   module Controller
     class Flash
 
-      def self.message object, action, key 
-        controllers = object.class.name.gsub('Controller', '').split('::').map {|e| e.underscore }
-        scope = ([:views] + controllers) << action << :flash
+      def self.message object, key 
+        scope = [:views]
+        scope += object.controller_path.split('/')
+        scope << object.action_name
+        scope << :flash
         text(key, scope)
       end
 

data/lib/rescue/controllers/static.rb

@@ -10,7 +10,7 @@ module Rescue
             render status: code, file: "#{Rails.root}/public/#{code}", layout: false and return
           end
         end
-        base.extend Rescue::Controller::ClassMethods
+        base.send(:include, Rescue::Controller)
       end
   
     end

data/lib/rescue/version.rb

@@ -1,3 +1,3 @@
 module Rescue
-  VERSION = "0.3.2"
+  VERSION = "0.3.4"
 end

data/lib/rescue-dog.rb

@@ -3,7 +3,6 @@ require 'rescue/controller.rb'
 require "rescue/controllers/static.rb"
 require "rescue/controllers/dynamic.rb"
 require "rescue/controllers/action.rb"
-require "rescue/controllers/parameter.rb"
 require "rescue/controllers/flash.rb"
 require 'rescue/exceptions/application_error.rb'
 require 'rescue/exceptions/respond_error.rb'

data/spec/rescue/controller_spec.rb

@@ -3,74 +3,110 @@ require 'spec_helper'
 
 describe Rescue::Controller do
 
-  describe Rescue::Controller::ClassMethods do
-    let(:object) do
-      Class.new ApplicationController do
-        extend Rescue::Controller::ClassMethods
+  let(:object) do
+    Class.new ApplicationController do
+      include Rescue::Controller
+      rescue_controller RescueModel,
+        show: [:show_action],
+        edit: [:edit_action],
+        new:  [:new_action],
+        create:  { render: lambda { } ,rescue: lambda { } },
+        update:  { render: lambda { } ,rescue: lambda { } },
+        destroy: { render: lambda { } ,rescue: lambda { } },
+        create_action:  { type: :create  ,render: lambda { } ,rescue: lambda { } },
+        update_action:  { type: :update  ,render: lambda { } ,rescue: lambda { } },
+        destroy_action: { type: :destroy ,render: lambda { } ,rescue: lambda { } }
+
+      def customized_create_action
+        rescue_respond(:create_call, create_params,
+          render: lambda { },
+          rescue: lambda { }
+        )
       end
-    end
 
-    [:rescue_associate, :rescue_controller, :define_action_method].each do |name|
-      it "should be able to call method `#{name}`" do
-        expect(object.public_methods.include? name).to be_true
+      def customized_update_action
+        rescue_respond(:update_call, update_params,
+          render: lambda { return true },
+          rescue: lambda { }
+        )
       end
-    end
-  end
 
-  describe "Rescue::Controller#rescue_controller" do
-    let(:object) do
-      Class.new ApplicationController do
-        extend Rescue::Controller::ClassMethods
-        rescue_controller RescueModel, :show, :new, :edit, { create: {}, update: {}, delete: {} }
+      def customized_destroy_action
+        rescue_respond(:destroy_call, destroy_params,
+          render: lambda { },
+          rescue: lambda { }
+        )
       end
     end
+  end
 
-    it "should be defined private method `find_params`" do
-      expect(object.private_instance_methods.include? :find_params).to be_true
+  it "should be defined `rescue_respond`" do
+    expect(object.method_defined? :rescue_respond).to be_true
+  end
+
+  [:rescue_associate, :rescue_controller].each do |name|
+    it "should be able to call method `#{name}`" do
+      expect(object.public_methods.include? name).to be_true
     end
+  end
 
-    [:find_call, :new_call, :create_call, :update_call, :delete_call].each do |name|
-      it "should be defined private method `#{name}`" do
-        expect(object.private_instance_methods.include? name).to be_true
+
+  describe "#rescue_respond" do
+    let(:object) do
+      clazz = Class.new ApplicationController do
+        include Rescue::Controller
       end
+      object = clazz.new
+      object.stub(:flash).and_return({})
+      object.stub(:controller_path).and_return('rescue')
+      object.stub(:action_name).and_return('action')
+      object.stub(:stub_call).with({}).and_return(nil)
+      object
     end
 
-    [:new, :edit, :show, :create, :update, :delete].each do |name|
-      it "should be defined public method `#{name}`" do
-        expect(object.public_instance_methods.include? name).to be_true
-      end
+    it "should be able to render" do
+      expect(
+        object.send(:rescue_respond, :stub_call, {},
+          render: lambda { return 'render' },
+          rescue: lambda { return 'rescue' })
+      ).to eq('render')
     end
 
-    TestCase::Controller::RESCUE_OPTIONS.each do |args|
-      context "when `rescue_controller` is called #{args}" do
-        options = args.extract_options!
-        methods = args + options.keys
+  end
 
-        let(:object) do
-          Class.new ApplicationController do
-            extend Rescue::Controller::ClassMethods
-            rescue_controller RescueModel, *args.dup, options.dup
-          end
-        end
+  describe Rescue::Controller::ClassMethods do
+    describe "#rescue_controller" do
 
-        [:find_call, :new_call, :create_call, :update_call, :delete_call].each do |name|
-          it "should be defined private method `#{name}`" do
-            expect(object.private_instance_methods.include? name).to be_true
-          end
+      let(:object) do
+        Class.new ApplicationController do
+          extend Rescue::Controller::ClassMethods
+          rescue_controller RescueModel,
+            show: [:show_action],
+            edit: [:edit_action],
+            new:  [:new_action],
+            create:  { render: lambda { } ,rescue: lambda { } },
+            update:  { render: lambda { } ,rescue: lambda { } },
+            destroy: { render: lambda { } ,rescue: lambda { } },
+            create_action:  { type: :create  ,render: lambda { } ,rescue: lambda { } },
+            update_action:  { type: :update  ,render: lambda { } ,rescue: lambda { } },
+            destroy_action: { type: :destroy ,render: lambda { } ,rescue: lambda { } }
         end
+      end
 
-        [:index, :new, :edit, :show, :create, :update, :delete].each do |name|
-          if methods.include? name
-            it "should be defined public method `#{name}`" do
-              expect(object.public_instance_methods.include? name).to be_true
-            end
-          else
-            it "should not be defined method `#{name}`" do
-              expect(object.instance_methods.include? name).to be_false
-            end
-          end
+      [:find_call, :new_call, :create_call, :update_call, :destroy_call].each do |name|
+        it "should be defined private method `#{name}`" do
+          expect(object.private_instance_methods.include? name).to be_true
         end
       end
+  
+      [ :new, :edit, :show, :create, :update, :destroy,
+        :show_action, :edit_action, :new_action,
+        :create_action, :update_action, :destroy_action ].each do |name|
+        it "should be defined public method `#{name}`" do
+          expect(object.public_instance_methods.include? name).to be_true
+        end
+      end
+
     end
   end
 

data/spec/rescue/controllers/action_spec.rb

@@ -9,58 +9,41 @@ describe Rescue::Controller::Action do
       object = Object.new
       object.stub(:attributes=).and_return(true)
       object.stub(:save!).and_return(true)
-      object.stub(:destroy!).and_return(true)
+      object.stub(:destroy).and_return(true)
       object
     end
+    clazz.stub(:where).and_return(clazz)
     clazz.stub(:find).and_return(clazz.new)
     clazz
   end
 
-  let(:controller) do # Fake Controller
-    clazz = model
-    Class.new do
-      Rescue::Controller::Action.define self, clazz, :@rescue, :rescue_params
-    end
-  end
-
-  let(:object) do
-    object = controller.new
-    object.stub(:find_params).and_return({})
-    object.stub(:rescue_params).and_return({})
-    object
-  end
-
-  let(:exception) do
-    Class.new(RuntimeError)
-  end
-
   describe "#define" do
-    [:find_call, :new_call, :create_call, :update_call, :delete_call].each do |name|
-      it "should be defined private method `#{name}`" do
-        expect(controller.private_instance_methods.include? name).to be_true
+    let(:controller) do # Fake Controller
+      clazz = model
+      Class.new do
+        Rescue::Controller::Action.define_call self, clazz, :@rescue
       end
     end
-  end
-
-  [:find_call, :new_call].each do |name|
-    describe "##{name}" do
-      it { expect { object.send(name) }.not_to raise_error }
+  
+    let(:object) do
+      object = controller.new
+      object.stub(:rescuemodel_params).and_return({})
+      object.stub(:params).and_return({})
+      object
     end
-  end
-
-  [:create_call, :update_call, :delete_call].each do |name|
-    describe "##{name}" do
-      it { expect { object.send(name) }.not_to raise_error }
-
-      context "with &block" do
-        let(:block) { raise exception }
-
-        it "should execute block-process" do
-          expect { object.send(name, &block) }.to raise_error(exception)
-        end
+  
+    let(:params) { {} }
+  
+    [:find_call, :new_call, :create_call, :update_call, :destroy_call].each do |name|
+      it "should be defined private method `#{name}`" do
+        expect(controller.private_instance_methods.include? name).to be_true
+      end
+      it "should not raise error" do
+        expect { object.send(name, params) }.not_to raise_error
       end
-      
     end
+
   end
 
 end
+

data/spec/rescue/controllers/flash_spec.rb

@@ -3,26 +3,23 @@ require 'spec_helper'
 
 describe Rescue::Controller::Flash do
 
-  before(:all) do
-    TestCase::Controller::FLASHS.each do |name|
-      Object.const_set name, Class.new {}
-    end
-
-    Rescue.const_set :DogController, Class.new {}
-  end
+  describe "#message" do
+    ['default', 'rescue', 'rescue/dog'].each do |name|
+      context "when #{{ controller: name, action: :action }}" do
 
-  describe "Rescue::Controller::Flash#message" do
-    TestCase::Controller::FLASHS.each do |name|
-      [:success, :error].each do |status|
-        it do
-          expect(Rescue::Controller::Flash.message(Object.const_get(name).new, :action, status)).to eq("#{name.to_s.underscore} #{status}")
+        let(:controller) do
+          clazz = Class.new
+          clazz.stub(:controller_path).and_return(name)
+          clazz.stub(:controller_name).and_return(name)
+          clazz.stub(:action_name).and_return(:action)
+          clazz
         end
-      end
-    end
 
-    [:success, :error].each do |status|
-      it do
-        expect(Rescue::Controller::Flash.message(Rescue::DogController.new, :action, status)).to eq(status.to_s)
+        [:success, :error].each do |status|
+          it do
+            expect(Rescue::Controller::Flash.message(controller, status)).to eq("#{name} #{status}")
+          end
+        end
       end
     end
   end

data/spec/test_case.rb

@@ -4,14 +4,6 @@ class TestCase
     ERRORS = { BadRequest: 400, Unauthorized: 401, NotFound: 404, ServerError: 500 }
     FORMATS = [Mime::Type.new("text/html", :html), Mime::Type.new("application/json", :json)]
 
-    RESCUE_OPTIONS = [
-      [],
-      [:show],
-      [:new, :show, :create],
-      [:new, :show, :edit, :create, :update],
-      [:new, :show, :edit, { create: {}, update: {}, delete: {} }],
-    ]
-
     FLASHS = [:DefaultController, :RescueController, :RescueDogController]
   end 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rescue-dog
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - yulii
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-16 00:00:00.000000000 Z
+date: 2013-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -51,7 +51,6 @@ files:
 - lib/rescue/controllers/action.rb
 - lib/rescue/controllers/dynamic.rb
 - lib/rescue/controllers/flash.rb
-- lib/rescue/controllers/parameter.rb
 - lib/rescue/controllers/static.rb
 - lib/rescue/exceptions/application_error.rb
 - lib/rescue/exceptions/respond_error.rb

data/lib/rescue/controllers/parameter.rb

@@ -1,17 +0,0 @@
-# coding: UTF-8
-module Rescue
-  module Controller
-    class Parameter
-
-      def self.define object
-        id = Rescue.config.primary_key
-        object.send(:define_method, :find_params) do
-          params.require(id)
-          params.permit(id)
-        end
-        object.send(:private, :find_params)
-      end
-
-    end
-  end
-end