api_hammer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 00317bcabfb56b81ee77f410ce7526af594a229f
+  data.tar.gz: 1defdb0648ee78e474e14490c233995156868254
+SHA512:
+  metadata.gz: 31451099bc9e3ec9ed17f73d16089598c9d1c1bf63f882c2baa80b375ae8714f4da936b60a489a13b08ae8487840bdbe904e6cb4ff867daba92e66766161bfbe
+  data.tar.gz: cf0e2d1a2a81d49465d15d9cce424ec2566d49a5710e3672a957e1e22a7979b964a000604eacac68d0e0c81a62895a0fcdd94d8c3acd1ad1ba52941c6cab017a

data/.simplecov

@@ -0,0 +1 @@
+SimpleCov.start

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ethan
+
+MIT License
+
+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,3 @@
+# ApiHammer
+
+An API Tool

data/Rakefile.rb

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.name = 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+task 'default' => 'test'
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+end

data/lib/api_hammer/check_required_params.rb

@@ -0,0 +1,58 @@
+module ApiHammer::Rails
+  # halts with a 422 Unprocessable Entity and an appropriate error body if required params are missing 
+  #
+  # simple:
+  #
+  #     check_required_params(:id, :name)
+  #
+  # - `params[:id]` must be present
+  # - `params[:name]` must be present
+  #
+  # less simple:
+  #
+  #     check_required_params(:id, :person => [:name, :height], :lucky_numbers => Array)
+  #
+  # - `params[:id]` must be present
+  # - `params[:person]` must be present and be a hash
+  # - `params[:person][:name]` must be present
+  # - `params[:person][:height]` must be present
+  # - `params[:lucky_numbers]` must be present and be an array
+  def check_required_params(*checks)
+    errors = Hash.new { |h,k| h[k] = [] }
+    check_required_params_helper(checks, params, errors, [])
+    halt_unprocessable_entity(errors) if errors.any?
+  end
+
+  private
+  # helper 
+  def check_required_params_helper(check, subparams, errors, parents)
+    key = parents.join('#')
+    add_error = proc { |message| errors[key] << message unless errors[key].include?(message) }
+    if subparams.nil?
+      add_error.call("is required but was not provided")
+    elsif check
+      case check
+      when Array
+        check.each { |subcheck| check_required_params_helper(subcheck, subparams, errors, parents) }
+      when Hash
+        if subparams.is_a?(Hash)
+          check.each do |key, subcheck|
+            check_required_params_helper(subcheck, subparams[key], errors, parents + [key])
+          end
+        else
+          add_error.call("must be a Hash")
+        end
+      when Class
+        unless subparams.is_a?(check)
+          add_error.call("must be a #{check.name}")
+        end
+      else
+        if subparams.is_a?(Hash)
+          check_required_params_helper(nil, subparams[check], errors, parents + [check])
+        else
+          add_error.call("must be a Hash")
+        end
+      end
+    end
+  end
+end

data/lib/api_hammer/halt.rb

@@ -0,0 +1,403 @@
+# the contents of this file are to let you halt a controller in its processing without having to have a 
+# return in the actual action. this lets helper methods which do things like parameter validation halt.
+#
+# it is desgined to function similarly to Sinatra's handling of throw(:halt), but is based around exceptions 
+# because rails doesn't catch anything, just rescues. 
+
+module ApiHammer
+  # an exception raised to stop processing an action and render the body given as the 'body' argument 
+  # (which is expected to be a JSON-able object)
+  class Halt < StandardError
+    def initialize(message, body, render_options={})
+      super(message)
+      @body = body
+      @render_options = render_options
+    end
+
+    attr_reader :body, :render_options
+  end
+end
+
+module ApiHammer::Rails
+  unless instance_variables.any? { |iv| iv.to_s == '@halt_included' }
+    @halt_included = proc do |controller_class|
+      controller_class.send(:rescue_from, ApiHammer::Halt, :with => :handle_halt)
+    end
+    (@on_included ||= Set.new) << @halt_included
+  end
+
+  # handle a raised ApiHammer::Halt or subclass and render it
+  def handle_halt(halt)
+    render_options = halt.render_options ? halt.render_options.dup : {}
+    # rocket pants does not have a render method, just render_json 
+    if respond_to?(:render_json, true)
+      render_json(halt.body || {}, render_options)
+    else
+      render_options[:json] = halt.body || {}
+      render(render_options)
+    end
+  end
+
+  # halt and render the given body 
+  def halt(status, body, render_options = {})
+    raise(ApiHammer::Halt.new(body.inspect, body, render_options.merge(:status => status)))
+  end
+
+  # halt and render the given errors in the body on the 'errors' key 
+  def halt_error(status, errors, render_options = {})
+    halt(status, {'errors' => errors}, render_options)
+  end
+
+  module HaltMethods
+=begin
+# these methods are generated with the following script
+
+require 'nokogiri'
+require 'faraday'
+wpcodes = Nokogiri::HTML(Faraday.get('https://en.wikipedia.org/wiki/List_of_HTTP_status_codes').body)
+dts = wpcodes.css('dt')
+puts(dts.map do |dt|
+  if dt.text =~ /\A\s*(\d+)\s+([a-z0-9 \-']+)/i
+    status = $1.to_i
+    name = $2.strip
+    underscore = name.split(/[\s-]/).map{|word| word.downcase.gsub(/\W/, '') }.join('_')
+    if ([100..199, 490..499, 520..599].map(&:to_a).inject([], &:+) + [306, 420, 440, 449, 450]).include?(status)
+      # exclude these. 1xx isn't really a thing that makes sense at this level and the others are 
+      # nonstandard or particular particular web servers or such 
+      nil
+    elsif [204, 205, 304].include?(status)
+      # ones with no body
+%Q(
+  # halt with status #{status} #{name}
+  def halt_#{underscore}(render_options = {})
+    halt(#{status}, '', render_options)
+  end
+)
+    elsif (400..599).include?(status)
+      # body goes on an errors object
+%Q(
+  # halt with status #{status} #{name}, responding with the given errors object on the 'errors' key
+  def halt_#{underscore}(errors, render_options = {})
+    halt_error(#{status}, errors, render_options)
+  end
+)
+    else
+%Q(
+  # halt with status #{status} #{name}, responding with the given body object 
+  def halt_#{underscore}(body, render_options = {})
+    halt(#{status}, body, render_options)
+  end
+)
+    end
+  end
+end.compact.join)
+
+=end
+    # halt with status 200 OK, responding with the given body object 
+    def halt_ok(body, render_options = {})
+      halt(200, body, render_options)
+    end
+
+    # halt with status 201 Created, responding with the given body object 
+    def halt_created(body, render_options = {})
+      halt(201, body, render_options)
+    end
+
+    # halt with status 202 Accepted, responding with the given body object 
+    def halt_accepted(body, render_options = {})
+      halt(202, body, render_options)
+    end
+
+    # halt with status 203 Non-Authoritative Information, responding with the given body object 
+    def halt_non_authoritative_information(body, render_options = {})
+      halt(203, body, render_options)
+    end
+
+    # halt with status 204 No Content
+    def halt_no_content(render_options = {})
+      halt(204, '', render_options)
+    end
+
+    # halt with status 205 Reset Content
+    def halt_reset_content(render_options = {})
+      halt(205, '', render_options)
+    end
+
+    # halt with status 206 Partial Content, responding with the given body object 
+    def halt_partial_content(body, render_options = {})
+      halt(206, body, render_options)
+    end
+
+    # halt with status 207 Multi-Status, responding with the given body object 
+    def halt_multi_status(body, render_options = {})
+      halt(207, body, render_options)
+    end
+
+    # halt with status 208 Already Reported, responding with the given body object 
+    def halt_already_reported(body, render_options = {})
+      halt(208, body, render_options)
+    end
+
+    # halt with status 226 IM Used, responding with the given body object 
+    def halt_im_used(body, render_options = {})
+      halt(226, body, render_options)
+    end
+
+    # halt with status 300 Multiple Choices, responding with the given body object 
+    def halt_multiple_choices(body, render_options = {})
+      halt(300, body, render_options)
+    end
+
+    # halt with status 301 Moved Permanently, responding with the given body object 
+    def halt_moved_permanently(body, render_options = {})
+      halt(301, body, render_options)
+    end
+
+    # halt with status 302 Found, responding with the given body object 
+    def halt_found(body, render_options = {})
+      halt(302, body, render_options)
+    end
+
+    # halt with status 303 See Other, responding with the given body object 
+    def halt_see_other(body, render_options = {})
+      halt(303, body, render_options)
+    end
+
+    # halt with status 304 Not Modified
+    def halt_not_modified(render_options = {})
+      halt(304, '', render_options)
+    end
+
+    # halt with status 305 Use Proxy, responding with the given body object 
+    def halt_use_proxy(body, render_options = {})
+      halt(305, body, render_options)
+    end
+
+    # halt with status 307 Temporary Redirect, responding with the given body object 
+    def halt_temporary_redirect(body, render_options = {})
+      halt(307, body, render_options)
+    end
+
+    # halt with status 308 Permanent Redirect, responding with the given body object 
+    def halt_permanent_redirect(body, render_options = {})
+      halt(308, body, render_options)
+    end
+
+    # halt with status 400 Bad Request, responding with the given errors object on the 'errors' key
+    def halt_bad_request(errors, render_options = {})
+      halt_error(400, errors, render_options)
+    end
+
+    # halt with status 401 Unauthorized, responding with the given errors object on the 'errors' key
+    def halt_unauthorized(errors, render_options = {})
+      halt_error(401, errors, render_options)
+    end
+
+    # halt with status 402 Payment Required, responding with the given errors object on the 'errors' key
+    def halt_payment_required(errors, render_options = {})
+      halt_error(402, errors, render_options)
+    end
+
+    # halt with status 403 Forbidden, responding with the given errors object on the 'errors' key
+    def halt_forbidden(errors, render_options = {})
+      halt_error(403, errors, render_options)
+    end
+
+    # halt with status 404 Not Found, responding with the given errors object on the 'errors' key
+    def halt_not_found(errors, render_options = {})
+      halt_error(404, errors, render_options)
+    end
+
+    # halt with status 405 Method Not Allowed, responding with the given errors object on the 'errors' key
+    def halt_method_not_allowed(errors, render_options = {})
+      halt_error(405, errors, render_options)
+    end
+
+    # halt with status 406 Not Acceptable, responding with the given errors object on the 'errors' key
+    def halt_not_acceptable(errors, render_options = {})
+      halt_error(406, errors, render_options)
+    end
+
+    # halt with status 407 Proxy Authentication Required, responding with the given errors object on the 'errors' key
+    def halt_proxy_authentication_required(errors, render_options = {})
+      halt_error(407, errors, render_options)
+    end
+
+    # halt with status 408 Request Timeout, responding with the given errors object on the 'errors' key
+    def halt_request_timeout(errors, render_options = {})
+      halt_error(408, errors, render_options)
+    end
+
+    # halt with status 409 Conflict, responding with the given errors object on the 'errors' key
+    def halt_conflict(errors, render_options = {})
+      halt_error(409, errors, render_options)
+    end
+
+    # halt with status 410 Gone, responding with the given errors object on the 'errors' key
+    def halt_gone(errors, render_options = {})
+      halt_error(410, errors, render_options)
+    end
+
+    # halt with status 411 Length Required, responding with the given errors object on the 'errors' key
+    def halt_length_required(errors, render_options = {})
+      halt_error(411, errors, render_options)
+    end
+
+    # halt with status 412 Precondition Failed, responding with the given errors object on the 'errors' key
+    def halt_precondition_failed(errors, render_options = {})
+      halt_error(412, errors, render_options)
+    end
+
+    # halt with status 413 Request Entity Too Large, responding with the given errors object on the 'errors' key
+    def halt_request_entity_too_large(errors, render_options = {})
+      halt_error(413, errors, render_options)
+    end
+
+    # halt with status 414 Request-URI Too Long, responding with the given errors object on the 'errors' key
+    def halt_request_uri_too_long(errors, render_options = {})
+      halt_error(414, errors, render_options)
+    end
+
+    # halt with status 415 Unsupported Media Type, responding with the given errors object on the 'errors' key
+    def halt_unsupported_media_type(errors, render_options = {})
+      halt_error(415, errors, render_options)
+    end
+
+    # halt with status 416 Requested Range Not Satisfiable, responding with the given errors object on the 'errors' key
+    def halt_requested_range_not_satisfiable(errors, render_options = {})
+      halt_error(416, errors, render_options)
+    end
+
+    # halt with status 417 Expectation Failed, responding with the given errors object on the 'errors' key
+    def halt_expectation_failed(errors, render_options = {})
+      halt_error(417, errors, render_options)
+    end
+
+    # halt with status 418 I'm a teapot, responding with the given errors object on the 'errors' key
+    def halt_im_a_teapot(errors, render_options = {})
+      halt_error(418, errors, render_options)
+    end
+
+    # halt with status 419 Authentication Timeout, responding with the given errors object on the 'errors' key
+    def halt_authentication_timeout(errors, render_options = {})
+      halt_error(419, errors, render_options)
+    end
+
+    # halt with status 422 Unprocessable Entity, responding with the given errors object on the 'errors' key
+    def halt_unprocessable_entity(errors, render_options = {})
+      halt_error(422, errors, render_options)
+    end
+
+    # halt with status 423 Locked, responding with the given errors object on the 'errors' key
+    def halt_locked(errors, render_options = {})
+      halt_error(423, errors, render_options)
+    end
+
+    # halt with status 424 Failed Dependency, responding with the given errors object on the 'errors' key
+    def halt_failed_dependency(errors, render_options = {})
+      halt_error(424, errors, render_options)
+    end
+
+    # halt with status 425 Unordered Collection, responding with the given errors object on the 'errors' key
+    def halt_unordered_collection(errors, render_options = {})
+      halt_error(425, errors, render_options)
+    end
+
+    # halt with status 426 Upgrade Required, responding with the given errors object on the 'errors' key
+    def halt_upgrade_required(errors, render_options = {})
+      halt_error(426, errors, render_options)
+    end
+
+    # halt with status 428 Precondition Required, responding with the given errors object on the 'errors' key
+    def halt_precondition_required(errors, render_options = {})
+      halt_error(428, errors, render_options)
+    end
+
+    # halt with status 429 Too Many Requests, responding with the given errors object on the 'errors' key
+    def halt_too_many_requests(errors, render_options = {})
+      halt_error(429, errors, render_options)
+    end
+
+    # halt with status 431 Request Header Fields Too Large, responding with the given errors object on the 'errors' key
+    def halt_request_header_fields_too_large(errors, render_options = {})
+      halt_error(431, errors, render_options)
+    end
+
+    # halt with status 444 No Response, responding with the given errors object on the 'errors' key
+    def halt_no_response(errors, render_options = {})
+      halt_error(444, errors, render_options)
+    end
+
+    # halt with status 451 Unavailable For Legal Reasons, responding with the given errors object on the 'errors' key
+    def halt_unavailable_for_legal_reasons(errors, render_options = {})
+      halt_error(451, errors, render_options)
+    end
+
+    # halt with status 451 Redirect, responding with the given errors object on the 'errors' key
+    def halt_redirect(errors, render_options = {})
+      halt_error(451, errors, render_options)
+    end
+
+    # halt with status 500 Internal Server Error, responding with the given errors object on the 'errors' key
+    def halt_internal_server_error(errors, render_options = {})
+      halt_error(500, errors, render_options)
+    end
+
+    # halt with status 501 Not Implemented, responding with the given errors object on the 'errors' key
+    def halt_not_implemented(errors, render_options = {})
+      halt_error(501, errors, render_options)
+    end
+
+    # halt with status 502 Bad Gateway, responding with the given errors object on the 'errors' key
+    def halt_bad_gateway(errors, render_options = {})
+      halt_error(502, errors, render_options)
+    end
+
+    # halt with status 503 Service Unavailable, responding with the given errors object on the 'errors' key
+    def halt_service_unavailable(errors, render_options = {})
+      halt_error(503, errors, render_options)
+    end
+
+    # halt with status 504 Gateway Timeout, responding with the given errors object on the 'errors' key
+    def halt_gateway_timeout(errors, render_options = {})
+      halt_error(504, errors, render_options)
+    end
+
+    # halt with status 505 HTTP Version Not Supported, responding with the given errors object on the 'errors' key
+    def halt_http_version_not_supported(errors, render_options = {})
+      halt_error(505, errors, render_options)
+    end
+
+    # halt with status 506 Variant Also Negotiates, responding with the given errors object on the 'errors' key
+    def halt_variant_also_negotiates(errors, render_options = {})
+      halt_error(506, errors, render_options)
+    end
+
+    # halt with status 507 Insufficient Storage, responding with the given errors object on the 'errors' key
+    def halt_insufficient_storage(errors, render_options = {})
+      halt_error(507, errors, render_options)
+    end
+
+    # halt with status 508 Loop Detected, responding with the given errors object on the 'errors' key
+    def halt_loop_detected(errors, render_options = {})
+      halt_error(508, errors, render_options)
+    end
+
+    # halt with status 509 Bandwidth Limit Exceeded, responding with the given errors object on the 'errors' key
+    def halt_bandwidth_limit_exceeded(errors, render_options = {})
+      halt_error(509, errors, render_options)
+    end
+
+    # halt with status 510 Not Extended, responding with the given errors object on the 'errors' key
+    def halt_not_extended(errors, render_options = {})
+      halt_error(510, errors, render_options)
+    end
+
+    # halt with status 511 Network Authentication Required, responding with the given errors object on the 'errors' key
+    def halt_network_authentication_required(errors, render_options = {})
+      halt_error(511, errors, render_options)
+    end
+  end
+
+  include HaltMethods
+end

data/lib/api_hammer/rails.rb

@@ -0,0 +1,10 @@
+require 'api_hammer/halt'
+require 'api_hammer/check_required_params'
+
+module ApiHammer::Rails
+  def self.included(klass)
+    (@on_included || []).each do |included_proc|
+      included_proc.call(klass)
+    end
+  end
+end

data/lib/api_hammer/request_logger.rb

@@ -0,0 +1,81 @@
+require 'rack'
+require 'term/ansicolor'
+require 'json'
+require 'addressable/uri'
+
+module ApiHammer
+  # Rack middleware for logging. much like Rack::CommonLogger but with a log message that isn't an unreadable 
+  # mess of dashes and unlabeled numbers. 
+  #
+  # two lines:
+  #
+  # - an info line, colored prettily to show a brief summary of the request and response
+  # - a debug line of json to record all relevant info. this is a lot of stuff jammed into one line, not 
+  #   pretty, but informative.
+  class RequestLogger < Rack::CommonLogger
+    include Term::ANSIColor
+
+    def call(env)
+      began_at = Time.now
+
+      # this is closed after the app is called, so read it before 
+      env["rack.input"].rewind
+      @request_body = env["rack.input"].read
+      env["rack.input"].rewind
+
+      status, header, body = @app.call(env)
+      header = ::Rack::Utils::HeaderHash.new(header)
+      body_proxy = ::Rack::BodyProxy.new(body) { log(env, status, header, began_at, body) }
+      [status, header, body_proxy]
+    end
+
+    def log(env, status, headers, began_at, body)
+      now = Time.now
+
+      request = Rack::Request.new(env)
+      response = Rack::Response.new('', status, headers)
+
+      request_uri = Addressable::URI.new(
+        :scheme => request.scheme,
+        :host => request.host,
+        :port => request.port,
+        :path => request.path,
+        :query => (request.query_string unless request.query_string.empty?)
+      )
+      status_color = case status.to_i
+      when 200..299
+        :intense_green
+      when 400..499
+        :intense_yellow
+      when 500..599
+        :intense_red
+      else
+        :white
+      end
+      status_s = bold(send(status_color, status.to_s))
+      @logger.info "#{status_s} : #{bold(intense_cyan(request.request_method))} #{intense_cyan(request_uri.normalize)}"
+      data = {
+        'request' => {
+          'method' => request.request_method,
+          'uri' => request_uri.normalize.to_s,
+          'length' => request.content_length,
+          'Content-Type' => request.content_type,
+          'remote_addr' => env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"],
+          'User-Agent' => request.user_agent,
+          'body' => @request_body,
+        }.reject{|k,v| v.nil? },
+        'response' => {
+          'status' => status,
+          'length' => headers['Content-Length'] || body.to_enum.map(&::Rack::Utils.method(:bytesize)).inject(0, &:+),
+          'Location' => response.location,
+          'Content-Type' => response.content_type,
+        }.reject{|k,v| v.nil? },
+        'began_at' => began_at.utc.to_i,
+        'duration' => now - began_at,
+      }
+      json_data = JSON.dump(data)
+      @logger.debug json_data
+      $ZMQ_LOGGER.log json_data if defined?($ZMQ_LOGGER)
+    end
+  end
+end

data/lib/api_hammer/show_text_exceptions.rb

@@ -0,0 +1,33 @@
+module ApiHammer
+  # Rack middleware to rescue any exceptions and return an appropriate message for the current 
+  # environment, with a nice concise bit of text for errors. 
+  #
+  # ideally this should be placed as close to the application itself as possible (last middleware 
+  # used) so that the exception will not bubble past other middleware, skipping it. 
+  # 
+  # like Sinatra::ShowExceptions or Rack::ShowExceptions, but not a huge blob of html. (note:
+  # those middlewares have a #prefers_plain_text? method which makes them behave like this, but 
+  # it's simpler and more reliable to roll our own than monkey-patch those) 
+  class ShowTextExceptions
+    def initialize(app, options)
+      @app=app
+      @options = options
+    end
+    def call(env)
+      begin
+        @app.call(env)
+      rescue Exception => e
+        full_error_message = (["#{e.class}: #{e.message}"] + e.backtrace.map{|l| "  #{l}" }).join("\n")
+        if @options[:logger]
+          @options[:logger].error(full_error_message)
+        end
+        if @options[:full_error]
+          body = full_error_message
+        else
+          body = "Internal Server Error\n"
+        end
+        [500, {'Content-Type' => 'text/plain'}, [body]]
+      end
+    end
+  end
+end

data/lib/api_hammer/tasks/gem_available_updates.rb

@@ -0,0 +1,19 @@
+namespace :gem do
+  desc 'informs you of available gem updates, newer than the gem versions in your Gemfile or Gemfile.lock'
+  task :available_updates do
+    require 'bundler'
+    Bundler.definition.dependencies.each do |dependency|
+      lock_version = Bundler.definition.specs.detect { |spec| spec.name == dependency.name }.version
+      remote_specs = Gem::SpecFetcher.fetcher.detect(:latest) { |name_tuple| name_tuple.name == dependency.name }
+      remote_specs.reject! do |(remote_spec, source)|
+        remote_spec.version <= lock_version
+      end
+      if remote_specs.any?
+        puts "LOCAL #{dependency.name} #{dependency.requirement} (locked at #{lock_version})"
+        remote_specs.each do |(remote_spec, source)|
+          puts "\tREMOTE AVAILABLE: #{remote_spec.name} #{remote_spec.version} #{remote_spec.platform}"
+        end
+      end
+    end
+  end
+end

data/lib/api_hammer/trailing_newline.rb

@@ -0,0 +1,38 @@
+require 'rack'
+
+module ApiHammer
+  # Rack middleware which adds a trailing newline to any responses which do not include one. 
+  #
+  # one effect of this is to make curl more readable, as without this, the prompt that follows the 
+  # request will be on the same line. 
+  #
+  # does not add a newline to blank responses.
+  class TrailingNewline
+    def initialize(app)
+      @app=app
+    end
+    class TNLBodyProxy < Rack::BodyProxy
+      def each
+        last_has_newline = false
+        blank = true
+        @body.each do |e|
+          last_has_newline = e =~ /\n\z/m
+          blank = false if e != ''
+          yield e
+        end
+        yield "\n" unless blank || last_has_newline
+      end
+      include Enumerable
+    end
+    def call(env)
+      status, headers, body = *@app.call(env)
+      if env['REQUEST_METHOD'].downcase != 'head'
+        body = TNLBodyProxy.new(body){}
+        if headers["Content-Length"]
+          headers["Content-Length"] = body.map(&Rack::Utils.method(:bytesize)).inject(0, &:+).to_s
+        end
+      end
+      [status, headers, body]
+    end
+  end
+end

data/lib/api_hammer/version.rb

@@ -0,0 +1,3 @@
+module ApiHammer
+  VERSION = "0.0.1"
+end

data/lib/api_hammer/weblink.rb

@@ -0,0 +1,110 @@
+require 'addressable/uri'
+
+module ApiHammer
+  # a RFC5988 Web Link 
+  #
+  # https://tools.ietf.org/html/rfc5988
+  class Weblink
+    # Weblink::Error, base class for all errors of the Weblink class
+    class Error < StandardError; end
+    # error parsing a Weblink
+    class ParseError < Error; end
+    # error when attempting an operation that requires a context URI which was not provided 
+    class NoContextError < Error; end
+
+    # parses an array of Web Links from the value an HTTP Link header, as described in 
+    # https://tools.ietf.org/html/rfc5988#section-5
+    #
+    # returns an Array of Weblink objects
+    def self.parse_link_value(link_value, context_uri=nil)
+      links = []
+
+      return links unless link_value
+
+      attr_char = /[a-zA-Z0-9!#\$&+\-.^_`|~]/ # defined in https://tools.ietf.org/html/rfc5987#section-3.2.1
+      ptoken = %r([a-zA-Z0-9!#\$%&'()*+\-./:<=>?@\[\]^_`{|}~])
+      quoted_string = /"([^"]*)"/
+
+      require 'strscan'
+      ss = StringScanner.new(link_value)
+      parse_fail = proc do
+        raise ParseError, "Unable to parse link value: #{link_value} " +
+          "around character #{ss.pos}: #{ss.peek(link_value.length - ss.pos)}"
+      end
+
+      while !ss.eos?
+        # get the target_uri, within some angle brackets 
+        ss.scan(/\s*<([^>]+)>/) || parse_fail.call
+        target_uri = ss[1]
+        attributes = {}
+        # get the attributes: semicolon, some attr_chars, an optional asterisk, equals, and a quoted 
+        # string or series of unquoted ptokens 
+        while ss.scan(/\s*;\s*(#{attr_char.source}+\*?)\s*=\s*(?:#{quoted_string.source}|(#{ptoken.source}+))\s*/)
+          attributes[ss[1]] = ss[2] || ss[3]
+        end
+        links << new(target_uri, attributes, context_uri)
+        unless ss.eos?
+          # either the string ends or has a comma followed by another link 
+          ss.scan(/\s*,\s*/) || parse_fail.call
+        end
+      end
+      links
+    end
+
+    def initialize(target_uri, attributes, context_uri=nil)
+      @target_uri = to_addressable_uri(target_uri)
+      @attributes = attributes
+      @context_uri = to_addressable_uri(context_uri)
+    end
+
+    # the context uri of the link, as an Addressable URI. this URI must be absolute, and the target_uri 
+    # may be resolved against it. this is most typically the request URI of a request to a service 
+    attr_reader :context_uri
+
+    # RFC 5988 calls it IRI, but nobody else does. we'll throw in an alias. 
+    alias_method :context_iri, :context_uri
+
+    # returns the target URI as an Addressable::URI
+    attr_reader :target_uri
+    # RFC 5988 calls it IRI, but nobody else does. we'll throw in an alias. 
+    alias_method :target_iri, :target_uri
+
+    # attempts to make target_uri absolute, using context_uri if available. raises if 
+    # there is not information available to make an absolute target URI 
+    def absolute_target_uri
+      if target_uri.absolute?
+        target_uri
+      elsif context_uri
+        context_uri + target_uri
+      else
+        raise NoContextError, "Target URI is relative but no Context URI given - cannot determine absolute target URI"
+      end
+    end
+
+    # link attributes
+    attr_reader :attributes
+
+    # subscript returns an attribute of this Link, if defined, otherwise nil 
+    def [](attribute_key)
+      @attributes[attribute_key]
+    end
+
+    # link rel attribute
+    def rel
+      self['rel']
+    end
+    alias_method :relation_type, :rel
+
+    # compares relation types in a case-insensitive manner as mandated in 
+    # https://tools.ietf.org/html/rfc5988#section-4.1
+    def rel?(other_rel)
+      rel && other_rel && rel.downcase == other_rel.downcase
+    end
+
+    private
+    # if uri is nil, returns nil; otherwise, tries to return a Addressable::URI 
+    def to_addressable_uri(uri)
+      uri.nil? || uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri)
+    end
+  end
+end

data/lib/api_hammer.rb

@@ -0,0 +1,9 @@
+require 'api_hammer/version'
+
+module ApiHammer
+  autoload :Rails, 'api_hammer/rails'
+  autoload :RequestLogger, 'api_hammer/request_logger.rb'
+  autoload :ShowTextExceptions, 'api_hammer/show_text_exceptions.rb'
+  autoload :TrailingNewline, 'api_hammer/trailing_newline.rb'
+  autoload :Weblink, 'api_hammer/weblink.rb'
+end

data/test/check_required_params_test.rb

@@ -0,0 +1,67 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+
+class FakeController
+  def self.rescue_from(*args)
+  end
+  
+  include(ApiHammer::Rails)
+  attr_accessor :params
+end
+
+describe 'ApiHammer::Rails#check_required_params' do
+  def controller_with_params(params)
+    FakeController.new.tap { |c| c.params = params }
+  end
+
+  describe 'a moderately complex set of checks' do
+    let(:checks) { [:id, :person => [:name, :height], :lucky_numbers => Array] }
+  
+    it 'passes with a moderately complex example' do
+      c = controller_with_params(:id => '99', :person => {:name => 'hammer', :height => '3'}, :lucky_numbers => ['2'])
+      c.check_required_params(checks)
+    end
+
+    it 'is missing id' do
+      c = controller_with_params(:person => {:name => 'hammer', :height => '3'}, :lucky_numbers => ['2'])
+      err = assert_raises(ApiHammer::Halt) { c.check_required_params(checks) }
+      assert_equal({'errors' => {'id' => ['is required but was not provided']}}, err.body)
+    end
+
+    it 'is missing person' do
+      c = controller_with_params(:id => '99', :lucky_numbers => ['2'])
+      err = assert_raises(ApiHammer::Halt) { c.check_required_params(checks) }
+      assert_equal({'errors' => {'person' => ['is required but was not provided']}}, err.body)
+    end
+
+    it 'is has the wrong type for person' do
+      c = controller_with_params(:id => '99', :person => ['hammer', '3'], :lucky_numbers => ['2'])
+      err = assert_raises(ApiHammer::Halt) { c.check_required_params(checks) }
+      assert_equal({'errors' => {'person' => ['must be a Hash']}}, err.body)
+    end
+
+    it 'is missing person#name' do
+      c = controller_with_params(:id => '99', :person => {:height => '3'}, :lucky_numbers => ['2'])
+      err = assert_raises(ApiHammer::Halt) { c.check_required_params(checks) }
+      assert_equal({'errors' => {'person#name' => ['is required but was not provided']}}, err.body)
+    end
+
+    it 'is missing lucky_numbers' do
+      c = controller_with_params(:id => '99', :person => {:name => 'hammer', :height => '3'})
+      err = assert_raises(ApiHammer::Halt) { c.check_required_params(checks) }
+      assert_equal({'errors' => {'lucky_numbers' => ['is required but was not provided']}}, err.body)
+    end
+
+    it 'has the wrong type for lucky_numbers' do
+      c = controller_with_params(:id => '99', :person => {:name => 'hammer', :height => '3'}, :lucky_numbers => '2')
+      err = assert_raises(ApiHammer::Halt) { c.check_required_params(checks) }
+      assert_equal({'errors' => {'lucky_numbers' => ['must be a Array']}}, err.body)
+    end
+
+    it 'has multiple problems' do
+      c = controller_with_params({})
+      err = assert_raises(ApiHammer::Halt) { c.check_required_params(checks) }
+      assert_equal({'errors' => {'id' => ['is required but was not provided'], 'person' => ['is required but was not provided'], 'lucky_numbers' => ['is required but was not provided']}}, err.body)
+    end
+  end
+end

data/test/halt_test.rb

@@ -0,0 +1,44 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+
+class FakeController
+  def self.rescue_from(*args)
+  end
+  
+  include(ApiHammer::Rails)
+
+  attr_reader :rendered
+  def render(opts)
+    @rendered = opts
+  end
+end
+
+describe 'ApiHammer::Rails#halt' do
+  it 'raises ApiHammer::Halt' do
+    haltex = assert_raises(ApiHammer::Halt) { FakeController.new.halt(200, {}) }
+    assert_equal({}, haltex.body)
+    assert_equal(200, haltex.render_options[:status])
+  end
+  describe 'status-specific halts' do
+    it 'halts ok' do
+      haltex = assert_raises(ApiHammer::Halt) { FakeController.new.halt_ok({}) }
+      assert_equal({}, haltex.body)
+      assert_equal(200, haltex.render_options[:status])
+    end
+    it 'halts unprocessable entity' do
+      haltex = assert_raises(ApiHammer::Halt) { FakeController.new.halt_unprocessable_entity({}) }
+      assert_equal({'errors' => {}}, haltex.body)
+      assert_equal(422, haltex.render_options[:status])
+    end
+  end
+end
+
+describe 'ApiHammer::Rails#handle_halt' do
+  it 'renders the things from the error' do
+    controller = FakeController.new
+    haltex = (FakeController.new.halt_unprocessable_entity({}) rescue $!)
+    controller.handle_halt(haltex)
+    assert_equal(422, controller.rendered[:status])
+    assert_equal({'errors' => {}}, controller.rendered[:json])
+  end
+end

data/test/helper.rb

@@ -0,0 +1,12 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'simplecov'
+
+# NO EXPECTATIONS 
+ENV["MT_NO_EXPECTATIONS"] = ''
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+require 'api_hammer'

data/test/request_logger_test.rb

@@ -0,0 +1,23 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+require 'logger'
+require 'stringio'
+
+describe ApiHammer::RequestLogger do
+  let(:logio) { StringIO.new }
+  let(:logger) { Logger.new(logio) }
+
+  it 'logs' do
+    app = ApiHammer::RequestLogger.new(proc { |env| [200, {}, []] }, logger)
+    app.call(Rack::MockRequest.env_for('/')).last.close
+    assert_match(/200/, logio.string)
+  end
+
+  it 'colors by status' do
+    {200 => :intense_green, 400 => :intense_yellow, 500 => :intense_red, 300 => :white}.each do |status, color|
+      app = ApiHammer::RequestLogger.new(proc { |env| [status, {}, []] }, logger)
+      app.call(Rack::MockRequest.env_for('/')).last.close
+      assert(logio.string.include?(Term::ANSIColor.send(color, status.to_s)))
+    end
+  end
+end

data/test/show_text_exceptions_test.rb

@@ -0,0 +1,29 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+
+describe ApiHammer::ShowTextExceptions do
+  it 'lets normal responses through untouched' do
+    orig_response = [200, {}, []]
+    app = ApiHammer::ShowTextExceptions.new(proc { |env| orig_response }, {})
+    app_response = app.call(Rack::MockRequest.env_for('/'))
+    assert_equal(orig_response, app_response)
+  end
+  it '500s' do
+    app = ApiHammer::ShowTextExceptions.new(proc { |env| raise }, :full_error => true)
+    assert_equal(500, app.call(Rack::MockRequest.env_for('/')).first)
+  end
+  it 'includes the full error' do
+    app = ApiHammer::ShowTextExceptions.new(proc { |env| raise 'foo' }, :full_error => true)
+    assert_match(/RuntimeError: foo/, app.call(Rack::MockRequest.env_for('/')).last.to_enum.to_a.join)
+  end
+  it 'does not include the full error' do
+    app = ApiHammer::ShowTextExceptions.new(proc { |env| raise }, :full_error => false)
+    assert_equal("Internal Server Error\n", app.call(Rack::MockRequest.env_for('/')).last.to_enum.to_a.join)
+  end
+  it 'logs' do
+    logio=StringIO.new
+    app = ApiHammer::ShowTextExceptions.new(proc { |env| raise 'foo' }, :logger => Logger.new(logio))
+    app.call(Rack::MockRequest.env_for('/'))
+    assert_match(/RuntimeError: foo/, logio.string)
+  end
+end

data/test/trailing_newline_test.rb

@@ -0,0 +1,24 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+
+describe ApiHammer::TrailingNewline do
+  it 'adds a trailing newline when one is missing' do
+    app = ApiHammer::TrailingNewline.new(proc { |env| [200, {}, ["foo"]] })
+    assert_equal("foo\n", app.call(Rack::MockRequest.env_for('/')).last.to_enum.to_a.join)
+  end
+
+  it 'does not add a trailing newline when one is present' do
+    app = ApiHammer::TrailingNewline.new(proc { |env| [200, {}, ["foo\n"]] })
+    assert_equal("foo\n", app.call(Rack::MockRequest.env_for('/')).last.to_enum.to_a.join)
+  end
+
+  it 'does not add a trailing newline when the response is blank' do
+    app = ApiHammer::TrailingNewline.new(proc { |env| [200, {}, []] })
+    assert_equal([], app.call(Rack::MockRequest.env_for('/')).last.to_enum.to_a)
+  end
+
+  it 'updates Content-Length if present' do
+    app = ApiHammer::TrailingNewline.new(proc { |env| [200, {'Content-Length' => '3'}, ['foo']] })
+    assert_equal('4', app.call(Rack::MockRequest.env_for('/'))[1]['Content-Length'])
+  end
+end

data/test/weblink_test.rb

@@ -0,0 +1,70 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+
+describe ApiHammer::Weblink do
+  describe '#parse_link_value' do
+    it 'parses link headers' do
+      examples = [
+        # one link with some attributes 
+        [ %q(<http://example.com>; rel=foo; title=example; title*="an example"),
+          'http://example.com',
+          {'rel' => 'foo', 'title' => 'example', 'title*' => 'an example'},
+        ],
+        # two links 
+        [ %q(<http://example.com>; rel=foo; title=example; title*="an example", <http://example2.com>; rel=bar),
+          'http://example.com',
+          {'rel' => 'foo', 'title' => 'example', 'title*' => 'an example'},
+          'http://example2.com',
+          {'rel' => 'bar'},
+        ],
+        # spaces
+        [ %q( <http://example.com> ;rel = foo ;title=example; title*="an example"  ),
+          'http://example.com',
+          {'rel' => 'foo', 'title' => 'example', 'title*' => 'an example'},
+        ],
+        # empty returns no links
+        [''],
+      ]
+      examples.each do |example|
+        link_value = example.shift
+        links = ApiHammer::Weblink.parse_link_value(link_value)
+        assert_equal(example.size, links.size * 2)
+        example.each_slice(2).zip(links).each do |((target_uri, attributes), link)|
+          assert_equal(Addressable::URI.parse(target_uri), link.target_uri)
+          assert_equal(attributes, link.attributes)
+        end
+      end
+    end
+
+    it 'gives an absolute uri based on context' do
+      link = ApiHammer::Weblink.parse_link_value('</bar>; rel=foo', 'http://example.com/foo').first
+      assert_equal(Addressable::URI.parse('http://example.com/bar'), link.absolute_target_uri)
+    end
+
+    it 'errors without context, trying to generate an absolute uri' do
+      link = ApiHammer::Weblink.parse_link_value('</bar>; rel=foo').first
+      assert_raises(ApiHammer::Weblink::NoContextError) { link.absolute_target_uri }
+    end
+
+    it 'returns an empty array for nil link header' do
+      assert_equal([], ApiHammer::Weblink.parse_link_value(nil))
+    end
+
+    it 'parse errors' do
+      examples = [
+        # missing >
+        %q(<http://example.com),
+        # missing <
+        %q(http://example.com>; rel=foo),
+        # , instead of ;
+        %q(<http://example.com>, rel=foo),
+        # non-ptoken characters (\,) unquoted 
+        %q(<http://example.com>; rel=b\\ar; title=example),
+        %q(<http://example.com>; rel=b,ar; title=example),
+      ]
+      examples.each do |example|
+        assert_raises(ApiHammer::Weblink::ParseError) { ApiHammer::Weblink.parse_link_value(example) }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: api_hammer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ethan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  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: term-ansicolor
+  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: json
+  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: addressable
+  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: rake
+  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: minitest
+  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: minitest-reporters
+  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: yard
+  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: simplecov
+  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'
+description: actually a set of small API-related tools. very much unlike a hammer
+  at all, which is one large tool.
+email:
+- ethan@unth
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".simplecov"
+- LICENSE.txt
+- README.md
+- Rakefile.rb
+- lib/api_hammer.rb
+- lib/api_hammer/check_required_params.rb
+- lib/api_hammer/halt.rb
+- lib/api_hammer/rails.rb
+- lib/api_hammer/request_logger.rb
+- lib/api_hammer/show_text_exceptions.rb
+- lib/api_hammer/tasks/gem_available_updates.rb
+- lib/api_hammer/trailing_newline.rb
+- lib/api_hammer/version.rb
+- lib/api_hammer/weblink.rb
+- test/check_required_params_test.rb
+- test/halt_test.rb
+- test/helper.rb
+- test/request_logger_test.rb
+- test/show_text_exceptions_test.rb
+- test/trailing_newline_test.rb
+- test/weblink_test.rb
+homepage: https://github.com/notEthan/api_hammer
+licenses:
+- MIT
+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: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: an API tool
+test_files:
+- test/check_required_params_test.rb
+- test/halt_test.rb
+- test/helper.rb
+- test/request_logger_test.rb
+- test/show_text_exceptions_test.rb
+- test/trailing_newline_test.rb
+- test/weblink_test.rb
+- ".simplecov"
+has_rdoc: