clone 1.0.0.alpha → 1.0.0.beta

data/module/gems/highline-1.6.19/test/ts_all.rb

@@ -0,0 +1,16 @@
+# ts_all.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+
+require "test/unit"
+
+require "tc_highline"
+require "tc_import"
+require "tc_menu"
+require "tc_style"
+require "tc_color_scheme"
+require "tc_string_highline"
+require "tc_string_extension"

data/samples/blather/restlike/Gemfile

@@ -0,0 +1,4 @@
+### easy XMPP client gem based on EventMachine
+gem 'blather', '~> 0.8.5'
+### JSON
+gem 'json'

data/samples/blather/restlike/cmd.yml

@@ -0,0 +1 @@
+helper: init

data/samples/blather/restlike/lib/blather.rb

@@ -0,0 +1,9 @@
+### Load Blather config
+require_relative_directory File.join "blather","meta"
+### Load the blather extraDSL
+require_relative_directory File.join "blather","dsl"
+### Load the blather Snippet Vendors!
+require_relative_directory File.join "blather","vendors"
+
+### Fire up Blather Engine
+XMPP::Client.start

data/samples/blather/restlike/lib/blather/dsl/api.rb

@@ -0,0 +1,78 @@
+module XMPP
+  class API
+    ### class var
+    begin
+      @@route_path    ||= Array.new.push(nil)
+      @@route_version ||= "v0"
+    end
+    ### syntax sugar
+    begin
+      ### main class dsl
+      begin
+        class << self
+          def version(version)
+            if !version.nil?
+              @@route_version= version.to_s
+            end
+          end
+          def namespace(space,  &block)
+            @@route_path.push space.to_s.downcase
+            index_of_space= (@@route_path.count-1)
+            yield
+            @@route_path.delete_at index_of_space
+            return true
+          end
+          def rout_path(join='/')
+            return @@route_path.join(join)
+          end
+          def route(method, paths, options, &block)
+
+            ### generate method path
+            begin
+              full_path= rout_path('_')
+              if !paths.nil?
+                full_path+= '_'+paths.to_s
+              end
+            end
+
+            ### generate name
+            begin
+              name_hash= Hash.new
+              name_hash['method']=  method.to_s
+              name_hash['path']=    full_path
+              name_hash['version']= @@route_version
+              method_name= XMPP.generate_method_name(name_hash)
+            end
+
+            ### generate new xmpp path/method
+            begin
+              XMPP::Call.create_singleton_method method_name, &block
+            end
+
+          end
+          def get(paths = nil, options = {}, &block); route(:get, paths, options, &block) end
+          def post(paths = nil, options = {}, &block); route(:post, paths, options, &block) end
+          def put(paths = nil, options = {}, &block); route(:put, paths, options, &block) end
+          def head(paths = nil, options = {}, &block); route(:head, paths, options, &block) end
+          def delete(paths = nil, options = {}, &block); route(:delete, paths, options, &block) end
+          def self.inherited(subclass)
+            @classes ||= Array.new
+            @classes.push subclass.name.constantize
+          end
+          def self.classes
+            @classes
+          end
+        end
+      end
+      ### sugar alias
+      begin
+        class << self
+          alias_method :group, :namespace
+          alias_method :resource, :namespace
+          alias_method :resources, :namespace
+          alias_method :segment, :namespace
+        end
+      end
+    end
+  end
+end

data/samples/blather/restlike/lib/blather/dsl/call.rb

@@ -0,0 +1,13 @@
+module XMPP
+  module Call
+    ### meta defs
+    begin
+      def self.create_singleton_method(method,&block)
+        define_singleton_method method, &block
+      end
+      def self.method_missing (method_name)
+        return {:error => "invalid method or version"}
+      end
+    end
+  end
+end

data/samples/blather/restlike/lib/blather/dsl/client.rb

@@ -0,0 +1,58 @@
+module XMPP
+  class Client
+    include Blather::DSL
+    class << self
+      attr_accessor :engine,
+                    :ready,
+                    :answers
+
+      def start
+
+        thread = Thread.new do
+          ### config
+          begin
+            XMPP::Client.engine  ||= XMPP::Client.new
+            XMPP::Client.answers ||= Hash.new
+            jid  = XMPP::CONFIG::JID
+            pwd  = XMPP::CONFIG::PWD
+            host = XMPP::CONFIG::HOST
+            port = XMPP::CONFIG::PORT
+          end
+          ### settings
+          begin
+            XMPP::Client.engine.setup jid,pwd,host,port
+            XMPP::Client.engine.when_ready do
+              XMPP::Client.ready= true
+            end
+            XMPP::Client.engine.subscription :request? do |s|
+              XMPP::Client.engine.write_to_stream s.approve!
+            end
+            XMPP::Client.engine.disconnected do
+              begin
+                EM.run do
+                  XMPP::Client.engine.run
+                end
+              rescue Exception
+                retry
+              end
+            end
+            XMPP::Client.engine.message :chat?, :body do |m|
+              XMPP::Client.engine.say m.from, XMPP.receive(m.body)
+            end
+          end
+          ### launch
+          begin
+            EM.run do
+              XMPP::Client.engine.run
+            end
+          rescue Exception
+            retry
+          end
+        end
+        thread.abort_on_exception = true
+        return true
+      end
+
+    end
+  end
+end

data/samples/blather/restlike/lib/blather/dsl/config.rb

@@ -0,0 +1,11 @@
+module XMPP
+  class CONFIG
+    JID  =      BLATHER_CONFIG['XMPP']['JID']
+    PWD  =      BLATHER_CONFIG['XMPP']['PWD']
+    HOST =      BLATHER_CONFIG['XMPP']['HOST']        || '0.0.0.0'
+    PORT =      BLATHER_CONFIG['XMPP']['PORT']        || '5222'
+    TIMEOUT=    BLATHER_CONFIG['XMPP']['TIMEOUT']     || 30
+    SLEEP_TIME= BLATHER_CONFIG['XMPP']['SLEEP_TIME']  || 0.2
+    MSG=        BLATHER_CONFIG['XMPP']['MSG']         || {'version'=>'v0','path'=>'/default','method'=>'GET'}
+  end
+end

data/samples/blather/restlike/lib/blather/dsl/extraDSL.rb

@@ -0,0 +1,163 @@
+module XMPP
+  ### extraDSL
+  begin
+    class << self
+      def send(to,what)
+        ### hold thread
+        if XMPP::Client.ready.nil? && XMPP::Client.engine.nil?
+          timeout= 30
+          while XMPP::Client.ready.nil?
+            sleep 1
+            timeout-= 1
+            if timeout <= 0
+              break
+            end
+          end
+        end
+        XMPP::Client.engine.say to, what
+        return true
+      end
+      def ask(to,what)
+        ### wait for engine
+        begin
+          if XMPP::Client.ready.nil? && XMPP::Client.engine.nil?
+            timeout= 30
+            while XMPP::Client.ready.nil?
+              sleep 1
+              timeout-= 1
+              if timeout <= 0
+                break
+              end
+            end
+          end
+        end
+        ### generate sample form
+        begin
+          ### check msg structure
+          begin
+            if what['body'].nil?
+              tmp_hash= Hash.new
+              begin
+                XMPP::CONFIG::MSG.each do |key,value|
+                  if !what[key].nil?
+                    tmp_hash[key]= what[key]
+                    what.delete key
+                  else
+                    tmp_hash[key]= value
+                  end
+                end
+              end
+              tmp_hash['body']=  what
+              tmp_hash['token']= self.token
+              what= tmp_hash
+            else
+              begin
+                XMPP::CONFIG::MSG.each do |key,value|
+                  if what[key].nil?
+                    what[key]= value
+                  end
+                end
+              end
+              what['token']= self.token
+            end
+          end
+        end
+        ### mark token
+        begin
+          XMPP::Client.answers[what['token']]=nil
+        end
+        ### send msg
+        begin
+          XMPP::Client.engine.say to, what.to_json
+        rescue Exception
+          XMPP::Client.engine.say to, what
+        end
+        ### after msg
+        begin
+          ### hold process
+          begin
+            sleep_time= XMPP::CONFIG::SLEEP_TIME
+            timeout   = XMPP::CONFIG::TIMEOUT.to_f / sleep_time
+            while XMPP::Client.answers[what['token']].nil?
+              sleep sleep_time
+              timeout -= 1
+              if timeout <= 0
+                #logger
+                puts "time is out for the answer"
+                break
+              end
+            end
+          end
+          ### finis process with answer
+          begin
+            answer_msg = XMPP::Client.answers[what['token']]
+            XMPP::Client.answers.delete what['token']
+          end
+          ### return answer
+          begin
+            return answer_msg
+          end
+        end
+      end
+      def receive(msg)
+        if XMPP.json? msg
+          message= JSON.parse(msg)
+          XMPP::CONFIG::MSG.each do |key,value|
+            if message[key].nil?
+              message[key]= value
+            end
+          end
+          if XMPP::Client.answers.keys.include?(message['token'])
+            XMPP::Client.answers[message['token']]= message['body']
+          else
+            call_method= XMPP.generate_method_name(message)
+            message['body']= XMPP::Call.__send__(call_method,message['body'])
+            return message.to_json
+          end
+        end
+      end
+      def token
+        begin
+          token_string= Time.now.to_s
+          [' ',':','-','+'].each do |one_sym|
+            token_string.gsub!(one_sym,'')
+          end
+          token_string+= Random.srand(Time.now.to_i).to_s
+          token_string+= XMPP::CONFIG::JID.to_s.gsub('@','').gsub('.','').upcase
+        end
+        return token_string
+      end
+      def json? json
+        begin
+          JSON.parse(json)
+          return true
+        rescue Exception => e
+          return false
+        end
+      end
+      def routes
+        XMPP::Call.singleton_methods - [:create_singleton_method,:method_missing]
+      end
+      def generate_method_name(hash)
+
+        call_method= String.new
+        call_method+= hash['method'].to_s.downcase
+        call_method+= '_'
+        call_method+= hash['version']
+        call_method+= '_'
+        if hash['path'].include? '/'
+          call_method+= hash['path'].to_s.gsub('/','_')
+        elsif  hash['path'].include? '\\'
+          call_method+= hash['path'].to_s.gsub('\\','_')
+        elsif  hash['path'].include? '.'
+          call_method+= hash['path'].to_s.gsub('.','_')
+        else
+          call_method+= hash['path']
+        end
+
+        return call_method
+
+      end
+    end
+  end
+end

data/samples/blather/restlike/lib/blather/meta/require.rb

@@ -0,0 +1,8 @@
+yml_file = (Dir.entries(File.join(File.dirname(__FILE__))).reject{|x| x[-4,4] != ".yml"})[0].to_s
+BLATHER_CONFIG = YAML.load_file(File.expand_path(File.join(File.dirname(__FILE__),yml_file)))
+
+module XMPP
+  ### require
+  require 'blather/client/dsl'
+  require 'json'
+end

data/samples/blather/restlike/lib/blather/meta/xmpp.yml

@@ -0,0 +1,5 @@
+XMPP:
+  JID: arthur@wonderland.lit
+  PWD: secr3t
+  HOST: 0.0.0.0
+  PORT: 5222

data/samples/blather/restlike/lib/blather/vendors/xmpp_default.rb

@@ -0,0 +1,27 @@
+module Vendors
+  class Default < XMPP::API
+
+    #version :prototype  #> default is v0
+
+    resource :default do
+
+      get    do |params|
+
+      end
+
+      post   do |params|
+
+      end
+
+      put    do |params|
+
+      end
+
+      delete do |params|
+
+      end
+
+
+    end
+  end
+end

data/samples/blather/restlike/readme

@@ -0,0 +1,2 @@
+this is a RESTlike (grape)  XMPP client based on blather dsl pkg
+main format is JSON

data/samples/grape/init/Gemfile

@@ -0,0 +1,2 @@
+#A Ruby framework for rapid API development with great conventions.
+gem "grape"

data/samples/grape/init/cmd.yml

@@ -0,0 +1,3 @@
+helper: init
+rack: init
+grape: vendor

data/samples/grape/init/config.ru

@@ -0,0 +1,2 @@
+###load_Grape_API
+Rack::Handler::Thin.run REST::API,:Port => get_port(THIN_CONFIG['tcp']['min'],THIN_CONFIG['tcp']['max'])

data/samples/grape/init/docs/grape/documentation.txt

@@ -0,0 +1,939 @@
+Grape is a REST-like API micro-framework for Ruby.
+It's designed to run on Rack or complement
+existing web application frameworks such as Rails
+and Sinatra by providing a simple DSL to easily develop RESTful APIs.
+It has built-in support for common conventions,
+including multiple formats, subdomain/prefix restriction,
+content negotiation, versioning and much more.
+
+Grape APIs are Rack applications that are created by
+subclassing Grape::API.
+
+Below is a simple example showing some
+of the more common features of Grape in
+the context of recreating parts of the Twitter API.
+
+   module Twitter
+     class API < Grape::API
+
+       version 'v1', using: :header, vendor: 'twitter'
+       format :json
+
+       helpers do
+         def current_user
+           @current_user ||= User.authorize!(env)
+         end
+
+         def authenticate!
+           error!('401 Unauthorized', 401) unless current_user
+         end
+       end
+
+       resource :statuses do
+
+         desc "Return a public timeline."
+         get :public_timeline do
+           Status.limit(20)
+         end
+
+         desc "Return a personal timeline."
+         get :home_timeline do
+           authenticate!
+           current_user.statuses.limit(20)
+         end
+
+         desc "Return a status."
+         params do
+           requires :id, type: Integer, desc: "Status id."
+         end
+         route_param :id do
+           get do
+             Status.find(params[:id])
+           end
+         end
+
+         desc "Create a status."
+         params do
+           requires :status, type: String, desc: "Your status."
+         end
+         post do
+           authenticate!
+           Status.create!({
+             user: current_user,
+             text: params[:status]
+           })
+         end
+
+         desc "Update a status."
+         params do
+           requires :id, type: String, desc: "Status ID."
+           requires :status, type: String, desc: "Your status."
+         end
+         put ':id' do
+           authenticate!
+           current_user.statuses.find(params[:id]).update({
+             user: current_user,
+             text: params[:status]
+           })
+         end
+
+         desc "Delete a status."
+         params do
+           requires :id, type: String, desc: "Status ID."
+         end
+         delete ':id' do
+           authenticate!
+           current_user.statuses.find(params[:id]).destroy
+         end
+
+       end
+     end
+   end
+
+
+   Mounting
+
+   Rack
+
+   The above sample creates a Rack application that can be run from a rackup config.ru file with rackup:
+   run Twitter::API
+
+
+   And would respond to the following routes:
+   GET /statuses/public_timeline(.json)
+   GET /statuses/home_timeline(.json)
+   GET /statuses/:id(.json)
+   POST /statuses(.json)
+   PUT /statuses/:id(.json)
+   DELETE /statuses/:id(.json)
+
+
+   Grape will also automatically respond to HEAD and OPTIONS for all GET, and just OPTIONS for all other routes.
+
+   Alongside Sinatra (or other frameworks)
+
+   If you wish to mount Grape alongside another Rack framework such as Sinatra, you can do so easily using Rack::Cascade:
+   # Example config.ru
+
+   require 'sinatra'
+   require 'grape'
+
+   class API < Grape::API
+     get :hello do
+       {hello: "world"}
+     end
+   end
+
+   class Web < Sinatra::Base
+     get '/' do
+       "Hello world."
+     end
+   end
+
+   use Rack::Session::Cookie
+   run Rack::Cascade.new [API, Web]
+
+
+   Rails
+
+   Place API files into app/api and modify application.rb.
+   config.paths.add "app/api", glob: "**/*.rb"
+   config.autoload_paths += Dir["#{Rails.root}/app/api/*"]
+
+
+   Modify config/routes:
+   mount Twitter::API => '/'
+
+
+   See below for additional code that enables reloading of API changes in development.
+
+   Modules
+
+   You can mount multiple API implementations inside another one. These don't have to be different versions, but may be components of the same API.
+   class Twitter::API < Grape::API
+     mount Twitter::APIv1
+     mount Twitter::APIv2
+   end
+
+
+   You can also mount on a path, which is similar to using prefix inside the mounted API itself.
+   class Twitter::API < Grape::API
+     mount Twitter::APIv1 => '/v1'
+   end
+
+
+   Versioning
+
+   There are four strategies in which clients can reach your API's endpoints: :path, :header, :accept_version_header and :param. The default strategy is :path.
+
+   Path
+   version 'v1', using: :path
+
+
+   Using this versioning strategy, clients should pass the desired version in the URL.
+   curl -H http://localhost:9292/v1/statuses/public_timeline
+
+
+   Header
+   version 'v1', using: :header, vendor: 'twitter'
+
+
+   Using this versioning strategy, clients should pass the desired version in the HTTP Accept head.
+   curl -H Accept=application/vnd.twitter-v1+json http://localhost:9292/statuses/public_timeline
+
+
+   By default, the first matching version is used when no Accept header is supplied. This behavior is similar to routing in Rails. To circumvent this default behavior, one could use the :strict option. When this option is set to true, a 406 Not Acceptable error is returned when no correct Accept header is supplied.
+
+   Accept-Version Header
+   version 'v1', using: :accept_version_header
+
+
+   Using this versioning strategy, clients should pass the desired version in the HTTP Accept-Version header.
+   curl -H "Accept-Version=v1" http://localhost:9292/statuses/public_timeline
+
+
+   By default, the first matching version is used when no Accept-Version header is supplied. This behavior is similar to routing in Rails. To circumvent this default behavior, one could use the :strict option. When this option is set to true, a 406 Not Acceptable error is returned when no correct Accept header is supplied.
+
+   Param
+   version 'v1', using: :param
+
+
+   Using this versioning strategy, clients should pass the desired version as a request parameter, either in the URL query string or in the request body.
+   curl -H http://localhost:9292/statuses/public_timeline?apiver=v1
+
+
+   The default name for the query parameter is 'apiver' but can be specified using the :parameter option.
+   version 'v1', using: :param, parameter: "v"
+
+   curl -H http://localhost:9292/statuses/public_timeline?v=v1
+
+
+   Describing Methods
+
+   You can add a description to API methods and namespaces.
+   desc "Returns your public timeline."
+   get :public_timeline do
+     Status.limit(20)
+   end
+
+
+   Parameters
+
+   Request parameters are available through the params hash object. This includes GET, POST and PUT parameters, along with any named parameters you specify in your route strings.
+   get :public_timeline do
+     Status.order(params[:sort_by])
+   end
+
+
+   Parameters are automatically populated from the request body on POST and PUT for form input, JSON and XML content-types.
+
+   The request:
+   curl -d '{"text": "140 characters"}' 'http://localhost:9292/statuses' -H Content-Type:application/json -v
+
+
+   The Grape endpoint:
+   post '/statuses' do
+     Status.create!({ text: params[:text] })
+   end
+
+
+   Multipart POSTs and PUTs are supported as well.
+
+   The request:
+   curl --form image_file=image.jpg http://localhost:9292/upload
+
+
+   The Grape endpoint:
+   post "upload" do
+     # file in params[:image_file]
+   end
+
+
+   Parameter Validation and Coercion
+
+   You can define validations and coercion options for your parameters using a params block.
+   params do
+     requires :id, type: Integer
+     optional :text, type: String, regexp: /^[a-z]+$/
+     group :media do
+       requires :url
+     end
+   end
+   put ':id' do
+     # params[:id] is an Integer
+   end
+
+
+   When a type is specified an implicit validation is done after the coercion to ensure the output type is the one declared.
+
+   Optional parameters can have a default value.
+   params do
+     optional :color, type: String, default: 'blue'
+   end
+
+
+   Parameters can be nested using group. In the above example, this means params[:media][:url] is required along with params[:id].
+
+   Namespace Validation and Coercion
+
+   Namespaces allow parameter definitions and apply to every method within the namespace.
+   namespace :statuses do
+     params do
+       requires :user_id, type: Integer, desc: "A user ID."
+     end
+     namespace ":user_id" do
+       desc "Retrieve a user's status."
+       params do
+         requires :status_id, type: Integer, desc: "A status ID."
+       end
+       get ":status_id" do
+         User.find(params[:user_id]).statuses.find(params[:status_id])
+       end
+     end
+   end
+
+
+   The namespace method has a number of aliases, including: group, resource, resources, and segment. Use whichever reads the best for your API.
+
+   Custom Validators
+   class AlphaNumeric < Grape::Validations::Validator
+     def validate_param!(attr_name, params)
+       unless params[attr_name] =~ /^[[:alnum:]]+$/
+         throw :error, status: 400, message: "#{attr_name}: must consist of alpha-numeric characters"
+       end
+     end
+   end
+
+   params do
+     requires :text, alpha_numeric: true
+   end
+
+
+   You can also create custom classes that take parameters.
+   class Length < Grape::Validations::SingleOptionValidator
+     def validate_param!(attr_name, params)
+       unless params[attr_name].length <= @option
+         throw :error, status: 400, message: "#{attr_name}: must be at the most #{@option} characters long"
+       end
+     end
+   end
+
+   params do
+     requires :text, length: 140
+   end
+
+
+   Validation Errors
+
+   When validation and coercion errors occur an exception of type Grape::Exceptions::Validation is raised. If the exception goes uncaught it will respond with a status of 400 and an error message. You can rescue a Grape::Exceptions::Validation and respond with a custom response.
+   rescue_from Grape::Exceptions::Validation do |e|
+       Rack::Response.new({
+           'status' => e.status,
+           'message' => e.message,
+           'param' => e.param
+       }.to_json, e.status)
+   end
+
+
+   Headers
+
+   Request headers are available through the headers helper or from env in their original form.
+   get do
+     error!('Unauthorized', 401) unless headers['Secret-Password'] == 'swordfish'
+   end
+
+   get do
+     error!('Unauthorized', 401) unless env['HTTP_SECRET_PASSWORD'] == 'swordfish'
+   end
+
+
+   You can set a response header with header inside an API.
+   header "X-Robots-Tag", "noindex"
+
+
+   Routes
+
+   Optionally, you can define requirements for your named route parameters using regular expressions on namespace or endpoint. The route will match only if all requirements are met.
+   get ':id', requirements: { id: /[0-9]*/ } do
+     Status.find(params[:id])
+   end
+
+   namespace :outer, requirements: { id: /[0-9]*/ } do
+     get :id do
+     end
+
+     get ":id/edit" do
+     end
+   end
+
+
+   Helpers
+
+   You can define helper methods that your endpoints can use with the helpers macro by either giving a block or a module.
+   module StatusHelpers
+     def user_info(user)
+       "#{user} has statused #{user.statuses} status(s)"
+     end
+   end
+
+   class API < Grape::API
+     # define helpers with a block
+     helpers do
+       def current_user
+         User.find(params[:user_id])
+       end
+     end
+
+     # or mix in a module
+     helpers StatusHelpers
+
+     get 'info' do
+       # helpers available in your endpoint and filters
+       user_info(current_user)
+     end
+   end
+
+
+   Cookies
+
+   You can set, get and delete your cookies very simply using cookies method.
+   class API < Grape::API
+
+     get 'status_count' do
+       cookies[:status_count] ||= 0
+       cookies[:status_count] += 1
+       { status_count: cookies[:status_count] }
+     end
+
+     delete 'status_count' do
+       { status_count: cookies.delete(:status_count) }
+     end
+
+   end
+
+
+   Use a hash-based syntax to set more than one value.
+   cookies[:status_count] = {
+       value: 0,
+       expires: Time.tomorrow,
+       domain: '.twitter.com',
+       path: '/'
+   }
+
+   cookies[:status_count][:value] +=1
+
+
+   Delete a cookie with delete.
+   cookies.delete :status_count
+
+
+   Specify an optional path.
+   cookies.delete :status_count, path: '/'
+
+
+   Redirecting
+
+   You can redirect to a new url temporarily (302) or permanently (301).
+   redirect "/statuses"
+
+   redirect "/statuses", permanent: true
+
+
+   Allowed Methods
+
+   When you add a GET route for a resource, a route for the HEAD method will also be added automatically. You can disable this behavior with do_not_route_head!.
+   class API < Grape::API
+
+     do_not_route_head!
+
+     get '/example' do
+       # only responds to GET
+     end
+
+   end
+
+
+   When you add a route for a resource, a route for the OPTIONS method will also be added. The response to an OPTIONS request will include an "Allow" header listing the supported methods.
+   class API < Grape::API
+
+     get '/rt_count' do
+       { rt_count: current_user.rt_count }
+     end
+
+     params do
+       requires :value, type: Integer, desc: 'Value to add to the rt count.'
+     end
+     put '/rt_count' do
+       current_user.rt_count += params[:value].to_i
+       { rt_count: current_user.rt_count }
+     end
+
+   end
+
+   curl -v -X OPTIONS http://localhost:3000/rt_count
+
+   > OPTIONS /rt_count HTTP/1.1
+   >
+   < HTTP/1.1 204 No Content
+   < Allow: OPTIONS, GET, PUT
+
+
+   You can disable this behavior with do_not_route_options!.
+
+   If a request for a resource is made with an unsupported HTTP method, an HTTP 405 (Method Not Allowed) response will be returned.
+   curl -X DELETE -v http://localhost:3000/rt_count/
+
+   > DELETE /rt_count/ HTTP/1.1
+   > Host: localhost:3000
+   >
+   < HTTP/1.1 405 Method Not Allowed
+   < Allow: OPTIONS, GET, PUT
+
+
+   Raising Exceptions
+
+   You can abort the execution of an API method by raising errors with error!.
+   error! "Access Denied", 401
+
+
+   You can also return JSON formatted objects by raising error! and passing a hash instead of a message.
+   error! { "error" => "unexpected error", "detail" => "missing widget" }, 500
+
+
+   Exception Handling
+
+   Grape can be told to rescue all exceptions and return them in the API format.
+   class Twitter::API < Grape::API
+     rescue_from :all
+   end
+
+
+   You can also rescue specific exceptions.
+   class Twitter::API < Grape::API
+     rescue_from ArgumentError, NotImplementedError
+   end
+
+
+   The error format will match the request format. See "Content-Types" below.
+
+   Custom error formatters for existing and additional types can be defined with a proc.
+   class Twitter::API < Grape::API
+     error_formatter :txt, lambda { |message, backtrace, options, env|
+       "error: #{message} from #{backtrace}"
+     }
+   end
+
+
+   You can also use a module or class.
+   module CustomFormatter
+     def self.call(message, backtrace, options, env)
+       { message: message, backtrace: backtrace }
+     end
+   end
+
+   class Twitter::API < Grape::API
+     error_formatter :custom, CustomFormatter
+   end
+
+
+   You can rescue all exceptions with a code block. The rack_response wrapper automatically sets the default error code and content-type.
+   class Twitter::API < Grape::API
+     rescue_from :all do |e|
+       rack_response({ message: "rescued from #{e.class.name}" })
+     end
+   end
+
+
+   You can also rescue specific exceptions with a code block and handle the Rack response at the lowest level.
+   class Twitter::API < Grape::API
+     rescue_from :all do |e|
+       Rack::Response.new([ e.message ], 500, { "Content-type" => "text/error" }).finish
+     end
+   end
+
+
+   Or rescue specific exceptions.
+   class Twitter::API < Grape::API
+     rescue_from ArgumentError do |e|
+       Rack::Response.new([ "ArgumentError: #{e.message}" ], 500)
+     end
+     rescue_from NotImplementedError do |e|
+       Rack::Response.new([ "NotImplementedError: #{e.message}" ], 500)
+     end
+   end
+
+
+   Rails 3.x
+
+   When mounted inside containers, such as Rails 3.x, errors like "404 Not Found" or "406 Not Acceptable" will likely be handled and rendered by Rails handlers. For instance, accessing a nonexistent route "/api/foo" raises a 404, which inside rails will ultimately be translated to an ActionController::RoutingError, which most likely will get rendered to a HTML error page.
+
+   Most APIs will enjoy preventing downstream handlers from handling errors. You may set the :cascade option to false for the entire API or separately on specific version definitions, which will remove the X-Cascade: true header from API responses.
+   cascade false
+
+   version 'v1', using: :header, vendor: 'twitter', cascade: false
+
+
+   Logging
+
+   Grape::API provides a logger method which by default will return an instance of the Logger class from Ruby's standard library.
+
+   To log messages from within an endpoint, you need to define a helper to make the logger available in the endpoint context.
+   class API < Grape::API
+     helpers do
+       def logger
+         API.logger
+       end
+     end
+     post '/statuses' do
+       # ...
+       logger.info "#{current_user} has statused"
+     end
+   end
+
+
+   You can also set your own logger.
+   class MyLogger
+     def warning(message)
+       puts "this is a warning: #{message}"
+     end
+   end
+
+   class API < Grape::API
+     logger MyLogger.new
+     helpers do
+       def logger
+         API.logger
+       end
+     end
+     get '/statuses' do
+       logger.warning "#{current_user} has statused"
+     end
+   end
+
+
+   API Formats
+
+   By default, Grape supports XML, JSON, and TXT content-types. The default format is :txt.
+
+   Serialization takes place automatically. For example, you do not have to call to_json in each JSON API implementation.
+
+   Your API can declare which types to support by using content_type. Response format is determined by the request's extension, an explicit format parameter in the query string, or Accept header.
+
+   The following API will only respond to the JSON content-type and will not parse any other input than application/json, application/x-www-form-urlencoded, multipart/form-data, multipart/related and multipart/mixed. All other requests will fail with an HTTP 406 error code.
+   class Twitter::API < Grape::API
+     format :json
+   end
+
+
+   When the content-type is omitted, Grape will return a 406 error code unless default_format is specified. The following API will try to parse any data without a content-type using a JSON parser.
+   class Twitter::API < Grape::API
+     format :json
+     default_format :json
+   end
+
+
+   If you combine format with rescue_from :all, errors will be rendered using the same format. If you do not want this behavior, set the default error formatter with default_error_formatter.
+   class Twitter::API < Grape::API
+     format :json
+     content_type :txt, "text/plain"
+     default_error_formatter :txt
+   end
+
+
+   Custom formatters for existing and additional types can be defined with a proc.
+   class Twitter::API < Grape::API
+     content_type :xls, "application/vnd.ms-excel"
+     formatter :xls, lambda { |object, env| object.to_xls }
+   end
+
+
+   You can also use a module or class.
+   module XlsFormatter
+     def self.call(object, env)
+       object.to_xls
+     end
+   end
+
+   class Twitter::API < Grape::API
+     content_type :xls, "application/vnd.ms-excel"
+     formatter :xls, XlsFormatter
+   end
+
+
+   Built-in formats are the following.
+   •:json: use object's to_json when available, otherwise call MultiJson.dump
+   •:xml: use object's to_xml when available, usually via MultiXml, otherwise call to_s
+   •:txt: use object's to_txt when available, otherwise to_s
+   •:serializable_hash: use object's serializable_hash when available, otherwise fallback to :json
+
+   Use default_format to set the fallback format when the format could not be determined from the Accept header. See below for the order for choosing the API format.
+   class Twitter::API < Grape::API
+     default_format :json
+   end
+
+
+   The order for choosing the format is the following.
+   •Use the file extension, if specified. If the file is .json, choose the JSON format.
+   •Use the value of the format parameter in the query string, if specified.
+   •Use the format set by the format option, if specified.
+   •Attempt to find an acceptable format from the Accept header.
+   •Use the default format, if specified by the default_format option.
+   •Default to :txt.
+
+   JSONP
+
+   Grape suports JSONP via Rack::JSONP, part of the rack-contrib gem. Add rack-contrib to your Gemfile.
+   require 'rack/contrib'
+
+   class API < Grape::API
+     use Rack::JSONP
+     format :json
+     get '/' do
+       'Hello World'
+     end
+   end
+
+
+   CORS
+
+   Grape supports CORS via Rack::CORS, part of the rack-cors gem. Add rack-cors to your Gemfile, then use the middleware in your config.ru file.
+   require 'rack/cors'
+
+   use Rack::Cors do
+     allow do
+       origins '*'
+       resource '*', headers: :any, methods: :get
+     end
+   end
+
+   run Twitter::API
+
+
+
+   Content-type
+
+   Content-type is set by the formatter. You can override the content-type of the response at runtime by setting the Content-Type header.
+   class API < Grape::API
+     get '/home_timeline_js' do
+       content_type "application/javascript"
+       "var statuses = ...;"
+     end
+   end
+
+
+   API Data Formats
+
+   Grape accepts and parses input data sent with the POST and PUT methods as described in the Parameters section above. It also supports custom data formats. You must declare additional content-types via content_type and optionally supply a parser via parser unless a parser is already available within Grape to enable a custom format. Such a parser can be a function or a class.
+
+   With a parser, parsed data is available "as-is" in env['api.request.body']. Without a parser, data is available "as-is" and in env['api.request.input'].
+
+   The following example is a trivial parser that will assign any input with the "text/custom" content-type to :value. The parameter will be available via params[:value] inside the API call.
+   module CustomParser
+     def self.call(object, env)
+       { value: object.to_s }
+     end
+   end
+
+   content_type :txt, "text/plain"
+   content_type :custom, "text/custom"
+   parser :custom, CustomParser
+
+   put "value" do
+     params[:value]
+   end
+
+
+   You can invoke the above API as follows.
+   curl -X PUT -d 'data' 'http://localhost:9292/value' -H Content-Type:text/custom -v
+
+
+   You can disable parsing for a content-type with nil. For example, parser :json, nil will disable JSON parsing altogether. The request data is then available as-is in env['api.request.body'].
+
+   RESTful Model Representations
+
+   Grape supports a range of ways to present your data with some help from a generic present method, which accepts two arguments: the object to be presented and the options associated with it. The options hash may include :with, which defines the entity to expose.
+
+   Grape Entities
+
+   Add the grape-entity gem to your Gemfile. Please refer to the grape-entity documentation for more details.
+
+   The following example exposes statuses.
+   module API
+
+     module Entities
+       class Status < Grape::Entity
+         expose :user_name
+         expose :text, documentation: { type: "string", desc: "Status update text." }
+         expose :ip, if: { type: :full }
+         expose :user_type, user_id, if: lambda{ |status, options| status.user.public? }
+         expose :digest { |status, options| Digest::MD5.hexdigest(status.txt) }
+         expose :replies, using: API::Status, as: :replies
+       end
+     end
+
+     class Statuses < Grape::API
+       version 'v1'
+
+       desc 'Statuses index', {
+         object_fields: API::Entities::Status.documentation
+       }
+       get '/statuses' do
+         statuses = Status.all
+         type = current_user.admin? ? :full : :default
+         present statuses, with: API::Entities::Status, type: type
+       end
+     end
+   end
+
+
+   You can present with multiple entities using an optional Symbol argument.
+     get '/statuses' do
+       statuses = Status.all.page(1).per(20)
+       present :total_page, 10
+       present :per_page, 20
+       present :statuses, statuses, with: API::Entities::Status
+     end
+
+
+   The response will be
+     {
+       total_page: 10,
+       per_page: 20,
+       statuses: []
+     }
+
+
+   In addition to separately organizing entities, it may be useful to put them as namespaced classes underneath the model they represent.
+   class Status
+     def entity
+       Status.new(self)
+     end
+
+     class Entity < Grape::Entity
+       expose :text, :user_id
+     end
+   end
+
+
+   If you organize your entities this way, Grape will automatically detect the Entity class and use it to present your models. In this example, if you added present Status.new to your endpoint, Grape will automatically detect that there is a Status::Entity class and use that as the representative entity. This can still be overridden by using the :with option or an explicit represents call.
+
+   Hypermedia
+
+   You can use any Hypermedia representer, including Roar. Roar renders JSON and works with the built-in Grape JSON formatter. Add Roar::Representer::JSON into your models or call to_json explicitly in your API implementation.
+
+   Rabl
+
+   You can use Rabl templates with the help of the grape-rabl gem, which defines a custom Grape Rabl formatter.
+
+   Authentication
+
+   Basic and Digest Auth
+
+   Grape has built-in Basic and Digest authentication.
+   http_basic do |username, password|
+     # verify user's password here
+     { 'test' => 'password1' }[username] == password
+   end
+
+   http_digest({ realm: 'Test Api', opaque: 'app secret' }) do |username|
+     # lookup the user's password here
+     { 'user1' => 'password1' }[username]
+   end
+
+
+   Use warden-oauth2 or rack-oauth2 for OAuth2 support.
+
+   Describing and Inspecting an API
+
+   Grape routes can be reflected at runtime. This can notably be useful for generating documentation.
+
+   Grape exposes arrays of API versions and compiled routes. Each route contains a route_prefix, route_version, route_namespace, route_method, route_path and route_params. The description and the optional hash that follows the API path may contain any number of keys and its values are also accessible via dynamically-generated route_[name] functions.
+   TwitterAPI::versions # yields [ 'v1', 'v2' ]
+   TwitterAPI::routes # yields an array of Grape::Route objects
+   TwitterAPI::routes[0].route_version # yields 'v1'
+   TwitterAPI::routes[0].route_description # etc.
+
+
+   Current Route and Endpoint
+
+   It's possible to retrieve the information about the current route from within an API call with route.
+   class MyAPI < Grape::API
+     desc "Returns a description of a parameter."
+     params do
+       requires :id, type: Integer, desc: "Identity."
+     end
+     get "params/:id" do
+       route.route_params[params[:id]] # yields the parameter description
+     end
+   end
+
+
+   The current endpoint responding to the request is self within the API block or env['api.endpoint'] elsewhere. The endpoint has some interesting properties, such as source which gives you access to the original code block of the API implementation. This can be particularly useful for building a logger middleware.
+   class ApiLogger < Grape::Middleware::Base
+     def before
+       file = env['api.endpoint'].source.source_location[0]
+       line = env['api.endpoint'].source.source_location[1]
+       logger.debug "[api] #{file}:#{line}"
+     end
+   end
+
+
+   Before and After
+
+   Execute a block before or after every API call with before and after.
+   before do
+     header "X-Robots-Tag", "noindex"
+   end
+
+
+   Anchoring
+
+   Grape by default anchors all request paths, which means that the request URL should match from start to end to match, otherwise a 404 Not Found is returned. However, this is sometimes not what you want, because it is not always known upfront what can be expected from the call. This is because Rack-mount by default anchors requests to match from the start to the end, or not at all. Rails solves this problem by using a anchor: false option in your routes. In Grape this option can be used as well when a method is defined.
+
+   For instance when you're API needs to get part of an URL, for instance:
+   class TwitterAPI < Grape::API
+     namespace :statuses do
+       get '/(*:status)', anchor: false do
+
+       end
+     end
+   end
+
+
+   This will match all paths starting with '/statuses/'. There is one caveat though: the params[:status] parameter only holds the first part of the request url. Luckily this can be circumvented by using the described above syntax for path specification and using the PATH_INFO Rack environment variable, using env["PATH_INFO"]. This will hold everything that comes after the '/statuses/' part.
+
+   Writing Tests
+
+   You can test a Grape API with RSpec by making HTTP requests and examining the response.
+
+   Writing Tests with Rack
+
+   Use rack-test and define your API as app.
+   require 'spec_helper'
+
+   describe Twitter::API do
+     include Rack::Test::Methods
+
+     def app
+       Twitter::API
+     end
+
+     describe Twitter::API do
+       describe "GET /api/v1/statuses" do
+         it "returns an empty array of statuses" do
+           get "/api/v1/statuses"
+           last_response.status.should == 200
+           JSON.parse(last_response.body).should == []
+         end
+       end
+       describe "GET /api/v1/statuses/:id" do
+         it "returns a status by id" do
+           status = Status.create!
+           get "/api/v1/statuses/#{status.id}"
+           last_response.body.should == status.to_json
+         end
+       end
+     end
+   end
+
+