padrino-response 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 340112ce19798bc835b91a04a1d96fab55b38419
+  data.tar.gz: 6cd6de2f37d5ff9c56f0a5fc3a3362010c685d5d
+SHA512:
+  metadata.gz: c128575feb849a70d38cc1920e220946ca0d78d35d8a727f021aa45095232909a030a0818fe2bf3ed67d40fa1f1559c6d2bba99f75b0f00824751efd29c9a039
+  data.tar.gz: 70cae9051a7be7e27f7da5a3fa83bca631fa839a198d518df7101b4149d4272b18a98b1b88c93231a8601576e30e6bf8dd5d8415c67d517036b3dcc42f81699b

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,12 @@
+lang: ruby
+before_install: gem install bundler --pre
+install:
+  - gem update --system
+  - bundle update
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode-1.7.4
+branches:
+  only:
+    - master

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 K-2052
+
+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,84 @@
+# padrino-response
+
+Eliminates the repetitive response code in your [Padrino](http://www.padrinorb.com/) controllers
+
+## Installation
+
+Via rubygems:
+
+    $ gem install padrino-responders
+
+Or add add the following to your Gemfile:
+
+    gem 'padrino-response'
+
+Now register it in your application:
+
+```ruby
+class App < Padrino::Application
+  register Padrino::Response
+end
+```
+
+## Usage Examples
+
+Basic:
+
+```ruby
+get :user, map: '/user' do
+  respond @user
+end
+```
+
+With a status code:
+
+```ruby
+post :unauthorized_user, map: => '/unauthurized-user' do
+  respond :unauthorized
+end
+```
+
+Skip the object:
+
+```ruby
+get :not_found, map: '/not-found' do
+  respond :not_found 
+end
+```
+
+### Customizing the responder:
+
+Via options:
+
+```ruby
+class CustomResponder < Padrino::Responders::Default
+end
+
+get :custom_responder, map: '/custom-responder' do
+  respond responder: "CustomResponder"
+end
+```
+
+Specify a responder for the controller:
+
+```ruby
+class Padrino::Responders::Main < Padrino::Responders::Default
+end
+```
+
+# Five Second Contributions Guide
+
+  - Fork
+  - Make changes in a branch
+  - Write tests
+  - Commit
+  - Pull Request
+
+# Copyright 
+
+This started out as a fork of nu7hatch's [padrino-responders](https://github.com/k2052/padrino-responders); my fork
+diverged enough that I felt it was best to make an entirely new gem. I cant thank nu7hatch enough for the original code
+.
+
+Licensed under MIT
+

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require 'padrino-core/cli/rake'
+
+PadrinoTasks.use(:database)
+PadrinoTasks.init

data/lib/padrino-response.rb

@@ -0,0 +1,34 @@
+require 'padrino-core'
+require 'padrino-gen'
+
+FileSet.glob_require('padrino-response/*.rb', __FILE__)
+FileSet.glob_require('padrino-response/{helpers,notifiers,responders}/*.rb', __FILE__)
+
+module Padrino
+  ##
+  # This component is used to create slim controllers without unnecessery
+  # and repetitive code.
+  #
+  module Response
+    ##
+    # Method used by Padrino::Application when we register the extension
+    #
+    class << self
+      def registered(app)
+        app.enable :sessions
+        app.enable :flash
+        app.helpers Padrino::Response::Helpers::Controller
+        app.helpers Padrino::Response::Helpers::Simple
+        app.set :notifier, Padrino::Response::Notifiers::FlashNotifier
+        app.send :include, Padrino::Response::Respond
+      end
+      alias :included :registered
+    end
+  end
+end
+
+##
+# Load our Padrino::Response locales
+#
+I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-response/locale/**/*.yml"]
+

data/lib/padrino-response/helpers/controller.rb

@@ -0,0 +1,92 @@
+module Padrino
+  module Response
+    module Helpers
+      module Controller
+        ## 
+        # A request from a non-browser user. Could be ajax, via curl etc.
+        #
+        def api_request
+          (request.xhr? or content_type == :json or mime_type(:json) == request.preferred_type.to_s)
+        end 
+
+        ##
+        # Shortcut for <code>notifier.say</code> method.
+        #
+        def notify(kind, message, *args, &block)
+          settings.notifier.say(self, kind, message, *args, &block) if settings.notifier
+        end
+
+        ##
+        # Trys to render and then falls back to to_format
+        #
+        def try_render(object, detour_name=nil, responder)
+          begin             
+            if responder.layout 
+              render "#{controller_name}/#{detour_name || action_name}", :layout => responder.layout, :strict_format => true  
+            else 
+              render "#{controller_name}/#{detour_name || action_name}", :strict_format => true
+            end 
+          rescue Exception => e
+            if api_request
+              if responder.jsend? && object.respond_to?(:attributes)
+                {:status => (responder.options.include?(:status) ? responder.options[:status] : 200), 
+                 :data   => {responder.human_model_name.to_sym => object.attributes}}.to_json
+              else
+                return object.to_json if object.respond_to?(:to_json)
+              end
+            end
+
+            if content_type == :xml or mime_type(:xml) == request.preferred_type
+              return object.to_xml if object.respond_to?(:to_xml)
+            end
+
+            # raise ::Padrino::Responder::ResponderError, e.message
+          end
+        end
+
+        ##
+        # Returns name of current action
+        #
+        def action_name
+          if request.respond_to? :action
+            action = request.action
+          else
+            action, parameters = Padrino.mounted_apps[0].app_obj.recognize_path request.path_info
+            action = action.to_s
+            action.gsub!(/^#{controller_name}_?/, '')
+          end
+          action = 'index' if action == ''
+          action
+        end
+
+        ##
+        # Returns name of current controller
+        #
+        def controller_name
+          request.controller
+        end
+
+        ##
+        # Returns translated, human readable name for specified model.
+        #
+        def human_model_name(object)
+          if object.class.respond_to?(:human)
+            object.class.human
+          elsif object.class.respond_to?(:human_name)
+            object.class.human_name
+          else
+            I18n.translate("models.#{object.class.to_s.underscore}", :default => object.class.to_s.humanize)
+          end
+        end
+
+        ##
+        # Returns url
+        #
+        def back_or_default(default)
+          return_to = session.delete(:return_to)
+          return_to || default
+        end
+      end 
+    end 
+  end
+end 

data/lib/padrino-response/helpers/simple.rb

@@ -0,0 +1,34 @@
+module Padrino
+  module Response
+    module Helpers
+      module Simple
+        def error_resp(obj, message=nil)
+          status 400        
+          if api_request
+            content_type 'application/json'
+            @resp ||= {}
+            @resp[:success] = false
+            @resp[:errors]  = obj.errors if message == nil
+            @resp[:message] = message if message   
+            halt 400, @resp.to_json    
+          else 
+            flash[:warning] = obj.errors.full_messages if message == nil   
+            flash[:warning] = message if message
+          end
+        end 
+
+        def success_resp(obj, message=nil)    
+          if api_request
+            content_type 'application/json'
+            @resp ||= {}
+            @resp[:success] = true
+            @resp[:message] = message if message  
+            halt 200, @resp.to_json    
+          else 
+            flash[:notice] = message
+          end       
+        end       
+      end
+    end  
+  end
+end

data/lib/padrino-response/locale/en.yml

@@ -0,0 +1,7 @@
+en:
+  responder:
+    messages:
+      default:
+        destroy: "%{model} has been successfully deleted."
+        create: "%{model} has been successfully created."
+        update: "%{model} has been successfully updated."

data/lib/padrino-response/locale/pl.yml

@@ -0,0 +1,7 @@
+en:
+  responder:
+    messages:
+      default:
+        destroy: "%{model} został poprawnie usunięty."
+        create: "%{model} został poprawnie dodany."
+        update: "%{model} został poprawnie zapisany."

data/lib/padrino-response/notifiers/flash_notifier.rb

@@ -0,0 +1,20 @@
+module Padrino
+  module Response
+    module Notifiers
+      module FlashNotifier
+        ##
+        # Saves specified message as flash notification with specified type. 
+        #
+        # ==== Examples
+        #
+        #   notifier.say(self, :error, "Something went wrong")
+        # 
+        # ... will save message to <code>flash[:notice]</code>
+        #
+        def self.say(app, kind, message, *args, &block)
+          app.flash[kind.to_sym] = message
+        end
+      end 
+    end
+  end 
+end 

data/lib/padrino-response/respond.rb

@@ -0,0 +1,25 @@
+module Padrino
+  module Response
+    module Respond   
+      def respond(*options)  
+        if ::Padrino::Responders.constants.include?("#{controller_name.capitalize}")
+          responder = ::Padrino::Responders.const_get("#{controller_name.capitalize}").new        
+        elsif options.include?(:responder)
+          responder = ::Padrino::Responders.const_get("#{options[:responder]}").new
+        else
+          responder = Padrino::Responders::Default.new
+        end
+        
+        responder.object = options.shift if !options.first.is_a?(Hash)
+        options = options.extract_options!
+        responder.object = options.delete(:object) if options.include?(:object)
+        responder.object ||= {}
+        responder.options[:location] = options.shift if options.first.is_a?(String)             
+        responder.options.merge!(options)
+        responder.class   = self
+        return responder.respond    
+      end
+      alias :resp :respond
+    end
+  end
+end 

data/lib/padrino-response/responders/default.rb

@@ -0,0 +1,165 @@
+module Padrino
+  module Responders
+    class ResponderError < RuntimeError
+    end
+    class Default
+      include Padrino::Response::StatusCodes
+      attr_accessor :options, :object, :class
+
+      def initialize
+        @options = {}
+      end
+      
+      # Jsend format?
+      def jsend?
+        return false
+      end
+
+      def respond
+       set_status
+
+        if self.class.request.put?
+          put
+        elsif self.class.request.post?
+          post
+        elsif self.class.request.delete?
+          delete
+        else
+          default
+        end
+      end
+
+      def put_or_post(message_type, error_detour)
+        message = message(message_type)
+
+        if valid?
+          if location
+            if api_request
+              content = try_render
+              redirect location, content
+            else
+              notify(:notice, message)
+              redirect location
+            end
+          end
+        else
+          set_status 400
+          if api_request
+            return object.errors.to_json
+          else
+            notify(:error, message)
+            try_render error_detour
+          end
+        end
+      end
+
+      def put
+        put_or_post :update, 'edit'
+      end
+
+      def post
+        put_or_post :create, 'new'
+      end
+
+      def delete
+        message = message(:destroy)
+
+        if location
+          if api_request
+            redirect location, {:message => message}.to_json
+          else
+            notify(:notice, message)
+            redirect location
+          end
+        else
+          try_render
+        end
+      end
+
+      def default
+        if location
+          redirect location
+        else
+          try_render
+        end
+      end
+
+      def message(type)
+        return @options[:message]         if @options[:message]
+        return @options[:error_message]   if @options[:error_message] and !valid
+        return @options[:success_message] if @options[:success_message] and valid
+  
+        return object.errors.full_messages if !valid?
+
+        object_notice      = "responder.messages.#{controller_name}.#{type}"
+        alternative_notice = "responder.messages.default.#{type}"
+
+        object_notice      = I18n.translate(object_notice, :model => human_model_name)
+        alternative_notice = I18n.translate(alternative_notice, :model => human_model_name)
+
+        return object_notice      unless object_notice.blank?
+        return alternative_notice unless alternative_notice.blank?
+
+        return 'No message found in locale'
+      end
+
+      def valid?
+        valid = true
+        # `valid?` method may override existing errors, so check for those first
+        valid &&= object.valid? if object.respond_to?(:valid?)
+        valid &&= (object.errors.count == 0) if object.respond_to?(:errors)
+        return valid
+      end
+
+      def request
+        self.class.request
+      end
+
+      def notify(kind, message, *args, &block)
+        self.class.notify(kind, message, *args, &block)
+      end
+
+      def try_render(detour_name=nil)
+        self.class.try_render(object, detour_name, self)
+      end
+
+      def redirect(*args)
+        self.class.redirect(*args)
+      end
+
+      def api_request
+        self.class.api_request
+      end
+
+      def human_model_name
+        self.class.human_model_name(object)
+      end
+
+      def controller_name
+        self.class.controller_name
+      end
+
+      def action_name
+        self.class.action_name
+      end
+
+      def location
+        @options[:location]
+      end  
+      
+      def layout
+        return @options[:layout] if @options.include?(:layout)   
+      end
+
+      def set_status(status=nil)
+        if status.is_a?(Integer)
+          self.class.status status
+        elsif status.is_a?(String)
+          self.class.status SYMBOL_TO_STATUS_CODE[status]
+        else
+          self.class.status SYMBOL_TO_STATUS_CODE[@options[:status]] if @options[:status]
+        end
+      end
+    end
+  end
+end

data/lib/padrino-response/responders/jsend.rb

@@ -0,0 +1,92 @@
+module Padrino
+  module Responders
+    class Jsend < Default
+      include Padrino::Response::StatusCodes
+      attr_accessor :options, :object, :class
+
+      def initialize
+        @options = {}
+      end
+
+      def jsend?
+        return true
+      end
+
+      def put_or_post(message_type, error_detour)
+        message = message( message_type )
+        if valid?
+          if request.xhr?
+            ajax_obj = {
+              :status => :success,
+              :data => {
+                object.class.to_s.singularize.downcase => object
+              }
+            }
+          end
+          if location
+            if request.xhr?
+              ajax_obj[:data][:redirect] = location
+              return ajax_obj.to_json
+            else
+              notify(:notice, message)
+              redirect location
+            end
+          else
+            try_render
+          end
+        else
+          if request.xhr?
+            ajax_obj = {
+              :status => :fail,
+              :data => {
+                :errors => object.errors
+              }
+            }
+            ajax_obj[:data][:redirect] = location if location
+            return ajax_obj.to_json
+          else
+            notify(:error, message)
+            try_render error_detour
+          end
+        end
+      end
+
+      def delete
+        message = message(:destroy)
+
+        if request.xhr?
+          ajax_obj = {
+            :status => :success,
+            :data => {
+              :message => message
+            }
+          }
+        end
+
+        if location
+          if request.xhr?
+            ajax_obj[:data][:redirect] = location
+            return ajax_obj.to_json
+          else
+            notify(:notice, message)
+            redirect location
+          end
+        else
+          try_render
+        end
+      end
+
+      def default
+        if location
+          if request.xhr?
+            {:status => :success, :data => { :redirect => location } }.to_json
+          else
+            redirect location
+          end
+        else
+          try_render
+        end
+      end
+    end
+  end
+end

data/lib/padrino-response/status_codes.rb

@@ -0,0 +1,88 @@
+module Padrino
+  module Response 
+    module StatusCodes
+      # Defines the standard HTTP status codes, by integer, with their
+      # corresponding default message texts.
+      # Source: http://www.iana.org/assignments/http-status-codes
+      STATUS_CODES = {
+        100 => "Continue",
+        101 => "Switching Protocols",
+        102 => "Processing",
+
+        200 => "OK",
+        201 => "Created",
+        202 => "Accepted",
+        203 => "Non-Authoritative Information",
+        204 => "No Content",
+        205 => "Reset Content",
+        206 => "Partial Content",
+        207 => "Multi-Status",
+        226 => "IM Used",
+
+        300 => "Multiple Choices",
+        301 => "Moved Permanently",
+        302 => "Found",
+        303 => "See Other",
+        304 => "Not Modified",
+        305 => "Use Proxy",
+        307 => "Temporary Redirect",
+
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        402 => "Payment Required",
+        403 => "Forbidden",
+        404 => "Not Found",
+        405 => "Method Not Allowed",
+        406 => "Not Acceptable",
+        407 => "Proxy Authentication Required",
+        408 => "Request Timeout",
+        409 => "Conflict",
+        410 => "Gone",
+        411 => "Length Required",
+        412 => "Precondition Failed",
+        413 => "Request Entity Too Large",
+        414 => "Request-URI Too Long",
+        415 => "Unsupported Media Type",
+        416 => "Requested Range Not Satisfiable",
+        417 => "Expectation Failed",
+        422 => "Unprocessable Entity",
+        423 => "Locked",
+        424 => "Failed Dependency",
+        426 => "Upgrade Required",
+
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        502 => "Bad Gateway",
+        503 => "Service Unavailable",
+        504 => "Gateway Timeout",
+        505 => "HTTP Version Not Supported",
+        507 => "Insufficient Storage",
+        510 => "Not Extended"
+      }
+
+      # Provides a symbol-to-fixnum lookup for converting a symbol (like
+      # :created or :not_implemented) into its corresponding HTTP status
+      # code (like 200 or 501).
+      SYMBOL_TO_STATUS_CODE = STATUS_CODES.inject({}) do |hash, (code, message)|
+        hash[message.gsub(/ /, "").underscore.to_sym] = code
+        hash
+      end
+
+      # Given a status parameter, determine whether it needs to be converted
+      # to a string. If it is a fixnum, use the STATUS_CODES hash to lookup
+      # the default message. If it is a symbol, use the SYMBOL_TO_STATUS_CODE
+      # hash to convert it.
+      def interpret_status(status)
+        case status
+        when Fixnum then
+          STATUS_CODES[status]
+        when Symbol then
+          interpret_status(SYMBOL_TO_STATUS_CODE[status] ||
+            "500 Unknown Status #{status.inspect}")
+        else
+          status.to_s
+        end
+      end  
+    end
+  end
+end

data/lib/padrino-response/version.rb

@@ -0,0 +1,5 @@
+module Padrino
+  module Response
+    VERSION = "0.0.1"
+  end
+end

data/padrino-response.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "padrino-response/version"
+
+Gem::Specification.new do |s|
+  s.name        = "padrino-response"
+  s.version     = Padrino::Response::VERSION
+  s.authors     = ["K-2052"]
+  s.email       = ["k@2052.me"]
+  s.homepage    = "https://github.com/k2052/padrino-response"
+  s.summary     = %q{Eliminates the repetitive response code in your Padrino controllers}
+  s.description = %q{Eliminates the repetitive response code in your Padrino controllers}
+
+  s.rubyforge_project = "padrino-response"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "adapter"
+  s.add_development_dependency "toystore"
+  s.add_development_dependency "rack-test"
+  s.add_dependency "padrino", ">= 0.10.7"
+  s.add_dependency "rake"
+  s.add_dependency "sinatra-flash", ">= 0.3.0"
+end

data/spec/all_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
+  
+describe 'Main Controller' do
+	before do
+		header 'Accept', 'application/json'
+	end
+
+  it 'should return an error resp' do
+  	get '/error'
+  	last_response.status.should eq 400
+  	resp = MultiJson.load last_response.body
+  	resp['success'].should eq false
+  	resp['message'].should eq 'Error'
+  end
+  
+  it 'should return a success resp' do
+  	get '/success'
+  	last_response.status.should eq 200
+  	resp = MultiJson.load last_response.body
+  	resp['success'].should eq true
+  end
+ 
+  it 'should return a 404' do
+  	get '/not-found'
+		last_response.status.should eq 404
+	end
+
+  it 'should return no-content' do
+  	get '/no-content'
+  	last_response.status.should eq 204
+  end
+
+	it 'should create a new human' do
+	  post '/new', human: {name: 'Bob'}
+		last_response.status.should eq 302
+		resp = MultiJson.load last_response.body
+		resp['human']['name'].should eq 'Bob'
+	end
+
+	it 'should fail to update a human' do
+	  put '/fail-update', human: {name: 'Bob'}
+		last_response.status.should eq 400
+	end
+
+	it 'should fail to create a human' do
+	  post '/fail-create', human: {name: 'Bob'}
+		last_response.status.should eq 400
+	 end
+end

data/spec/fixtures/app.rb

@@ -0,0 +1,62 @@
+require 'i18n'
+require 'padrino'
+require 'padrino-response'
+require 'adapter/memory' 
+require 'toystore'
+
+class Human
+	include Toy::Store
+	adapter :memory, {}
+
+	attribute :name, String
+	attribute :dont_set, String
+	validate :dont_set_should_be_blank
+
+	def dont_set_should_be_blank
+		unless self[:dont_set].blank?
+			errors.add :base, "Don't set that!"
+		end
+	end
+end
+
+class App < Padrino::Application
+  register Padrino::Response
+  register Padrino::Helpers::TranslationHelpers
+  
+  controllers :main do
+  	get :error, map: '/error' do
+			error_resp Human.new, 'Error'
+  	end
+
+  	get :success, map: '/success' do
+	  	success_resp Human.new name: 'Bob'
+	  end
+
+	  get :not_found, map: '/not-found' do
+			resp status: :not_found
+	  end
+
+	  get :no_content, map: '/no-content' do
+	  	resp status: :no_content
+	  end
+
+	  post :create, map: '/new' do
+	  	@human = Human.create name: 'Bob'
+	  	resp @human, location: '/success'
+	  end
+
+	  put :fail_update, map: '/fail-update' do
+	  	@human = Human.create name: 'Bob'
+	  	@human.update_attributes dont_set: 'Cats'
+	  	resp @human
+	  end
+
+	  post :fail_create, map: '/fail-create' do
+	  	@human = Human.create name: 'Bob', dont_set: 'Cats'
+	  	resp @human
+	  end
+  end
+end
+
+Padrino.load!
+Padrino.mount(App).to('/')

data/spec/spec.rake

@@ -0,0 +1,17 @@
+begin
+  require 'rspec/core/rake_task'
+
+  spec_tasks = Dir['spec/*/'].map { |d| File.basename(d) }
+ 
+  spec_tasks.each do |folder|
+    RSpec::Core::RakeTask.new("spec:#{folder}") do |t|
+      t.pattern = "./spec/#{folder}/**/*_spec.rb"
+      t.rspec_opts = %w(-fs --color)
+    end
+  end
+
+  desc "Run complete application spec suite"
+  task 'spec' => spec_tasks.map { |f| "spec:#{f}" }
+rescue LoadError
+  puts "RSpec is not part of this bundle, skip specs."
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+PADRINO_ENV = 'test' unless defined?(PADRINO_ENV)
+require File.expand_path(File.dirname(__FILE__) + "/fixtures/app.rb")
+require 'rack/test'
+
+RSpec.configure do |conf|
+  conf.include Rack::Test::Methods
+end
+
+def app(app = nil, &blk)
+  @app ||= block_given? ? app.instance_eval(&blk) : app
+  @app ||= Padrino.application
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: padrino-response
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- K-2052
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: toystore
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: padrino
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-flash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: Eliminates the repetitive response code in your Padrino controllers
+email:
+- k@2052.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/padrino-response.rb
+- lib/padrino-response/helpers/controller.rb
+- lib/padrino-response/helpers/simple.rb
+- lib/padrino-response/locale/en.yml
+- lib/padrino-response/locale/pl.yml
+- lib/padrino-response/notifiers/flash_notifier.rb
+- lib/padrino-response/respond.rb
+- lib/padrino-response/responders/default.rb
+- lib/padrino-response/responders/jsend.rb
+- lib/padrino-response/status_codes.rb
+- lib/padrino-response/version.rb
+- padrino-response.gemspec
+- spec/all_spec.rb
+- spec/fixtures/app.rb
+- spec/spec.rake
+- spec/spec_helper.rb
+homepage: https://github.com/k2052/padrino-response
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: padrino-response
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Eliminates the repetitive response code in your Padrino controllers
+test_files: []