api_hammer 0.19.0 → 0.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43a33c5f9ae38cb2f9bdc1fa75f16c9bbb58abc228ae400d1321f90872dc09e6
-  data.tar.gz: c69e131b3dc28183e32f1cc5a601f38bdb7cd82a8493e0b854818e66c8f9215d
+  metadata.gz: 431eb2a642aea887bd47826572e0631ebc6e18daa0714c430d6b0c690bb68ea3
+  data.tar.gz: dd74fb4768fb9f51dcb139fe3ba7cf61e9f949b96ec3013cfbde0f41534ced12
 SHA512:
-  metadata.gz: a581e28995ffdeee7f712d9bc743b77db7deca57748267cfbc17e2fb0bf481542facf6a5d511379ed5d8c9291ccb57f4539021eb1e0951834872da6754cdd1bb
-  data.tar.gz: a1fada15803bcb03ba0745c1c46bdd062845b9c511d792d48795a67271ccac78203106a9e9e955e4aad29fad9ba950b5430db51e2c2f472431e9864358a0bfc1
+  metadata.gz: 22aa57cf47a015dc1c62053c21bff79e549ebcf7cc7d3c2702224fdcd1dd86f037186419525dbb4143c75f9ae9ce639df91af621bd7ce6b5d12b6435e200bdad
+  data.tar.gz: c136b0b42e7256bcbb9c8b6498a1a52307d116fcf0d8f0f2f8bb41991842912b3b32a95e86f8442ce36ccb42e8563ca2cac17ad969f177d3567c4b627140039e

data/README.md

@@ -1,7 +1,5 @@
 # ApiHammer
 
-[![Build Status](https://travis-ci.org/notEthan/api_hammer.svg?branch=master)](https://travis-ci.org/notEthan/api_hammer)
-
 a collection of little tools I have used when creating APIs. these are generally too small to have their own 
 library, so have been collected here. 
 

data/api_hammer.gemspec

@@ -13,27 +13,26 @@ Gem::Specification.new do |spec|
     'is one large tool.'
   spec.homepage      = 'https://github.com/notEthan/api_hammer'
   spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0") - ['.gitignore']
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = `git ls-files -z test`.split("\x0") + [
-    '.simplecov',
-  ]
+  spec.files         = [
+    *%w(
+      .yardopts
+      CHANGELOG.md
+      LICENSE.txt
+      README.md
+      api_hammer.gemspec
+      bin/hc
+    ),
+    *Dir['lib/**/*'],
+  ].reject { |f| File.lstat(f).ftype == 'directory' }
+  spec.bindir        = 'bin'
+  spec.executables   = ['hc']
   spec.require_paths = ['lib']
 
   spec.add_dependency 'rack'
   spec.add_dependency 'faraday'
   spec.add_dependency 'term-ansicolor'
   spec.add_dependency 'json'
-  spec.add_dependency 'json_pure'
   spec.add_dependency 'addressable'
   spec.add_dependency 'coderay'
   spec.add_dependency 'i18n'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rack-test'
-  spec.add_development_dependency 'minitest'
-  spec.add_development_dependency 'minitest-reporters'
-  spec.add_development_dependency 'yard'
-  spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'actionpack'
 end

data/lib/api_hammer/body.rb

@@ -12,17 +12,23 @@ module ApiHammer
     # parses the body to an object
     def object
       instance_variable_defined?(:@object) ? @object : @object = begin
-        if media_type == 'application/json'
+        if body.nil?
+          nil
+        elsif media_type == 'application/json'
           JSON.parse(body) rescue nil
         elsif media_type == 'application/x-www-form-urlencoded'
-          CGI.parse(body).map { |k, vs| {k => vs.last} }.inject({}, &:update)
+          Addressable::URI.form_unencode(body).group_by(&:first).transform_values do |kvs|
+            kvs.map(&:last).inject(nil) { |c, v| c ? v ? "#{c},#{v}" : c : v }
+          end
         end
       end
     end
 
     def filtered(options)
       @filtered ||= Body.new(begin
-        if media_type == 'application/json'
+        if body.nil?
+          nil
+        elsif media_type == 'application/json'
           begin
             ApiHammer::Filtration::Json.new(body, options).filter
           rescue JSON::ParserError
@@ -82,7 +88,7 @@ module ApiHammer
         end
         begin
           JSON.generate([body])
-        rescue Encoding::UndefinedConversionError
+        rescue Encoding::UndefinedConversionError, JSON::GeneratorError
           # if updating by content-type didn't do it, try UTF8 since JSON wants that - but only 
           # if it seems to be valid utf8. 
           # don't try utf8 if the response content-type indicated something else. 

data/lib/api_hammer/content_type_attrs.rb

@@ -1,3 +1,5 @@
+require 'strscan'
+
 module ApiHammer
   # parses attributes out of content type header
   class ContentTypeAttrs

data/lib/api_hammer/filtration/json.rb

@@ -15,7 +15,7 @@ module ApiHammer
 
       def filter
         reset
-        obj = ''
+        obj = +''
         while !eos? && scan_result(obj, IGNORE)
         end
         if eos?
@@ -57,7 +57,7 @@ module ApiHammer
       end
 
       def filter_array
-        result = ''
+        result = +''
         delim = false
         until eos?
           if (value = filter_value) != UNPARSED
@@ -86,7 +86,7 @@ module ApiHammer
       FILTERED_JSON = JSON.generate("[FILTERED]", :quirks_mode => true)
 
       def filter_object
-        result = ''
+        result = +''
         delim = false
         until eos?
           if (string = filter_string) != UNPARSED

data/lib/api_hammer/request_logger.rb

@@ -53,14 +53,18 @@ module ApiHammer
       super(app, logger)
     end
 
+    Headers = ::Rack.const_defined?(:Headers) ? ::Rack::Headers : ::Rack::Utils::HeaderHash
+
     def call(env)
       began_at = Time.now
       began_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
 
       # 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
+      if env["rack.input"]
+        env["rack.input"].rewind
+        request_body = env["rack.input"].read
+        env["rack.input"].rewind
+      end
 
       if @logger && @logger.formatter.respond_to?(:current_tags)
         log_tags = @logger.formatter.current_tags.dup
@@ -76,7 +80,7 @@ module ApiHammer
       )
 
       status, response_headers, response_body = @app.call(env)
-      response_headers = ::Rack::Utils::HeaderHash.new(response_headers)
+      response_headers = Headers.new.merge(response_headers)
       body_proxy = ::Rack::BodyProxy.new(response_body) do
         log(env, request_uri, request_body, status, response_headers, response_body, began_at, began_ns, log_tags)
       end
@@ -135,7 +139,9 @@ module ApiHammer
           parsed_body = ApiHammer::Body.new(body, content_type)
           content_type_attrs = ApiHammer::ContentTypeAttrs.new(content_type)
           if content_type_attrs.text?
-            if (400..599).include?(status.to_i) || body.size < LARGE_BODY_SIZE
+            if body.nil?
+              data[role]['body'] = body
+            elsif (400..599).include?(status.to_i) || body.size < LARGE_BODY_SIZE
               # log bodies if they are not large, or if there was an error (either client or server) 
               data[role]['body'] = parsed_body.filtered(@options.reject { |k,v| ![:filter_keys].include?(k) }).jsonifiable.body
             else

data/lib/api_hammer/trailing_newline.rb

@@ -29,8 +29,10 @@ module ApiHammer
       _, content_type = headers.detect { |(k,_)| k =~ /\Acontent.type\z/i }
       if env['REQUEST_METHOD'].downcase != 'head' && ApiHammer::ContentTypeAttrs.new(content_type).text?
         body = TNLBodyProxy.new(body){}
-        if headers["Content-Length"]
-          headers["Content-Length"] = body.map(&:bytesize).inject(0, &:+).to_s
+        headers.each_key do |k|
+          if "content-length".casecmp?(k)
+            headers[k] = body.map(&:bytesize).inject(0, &:+).to_s
+          end
         end
       end
       [status, headers, body]

data/lib/api_hammer/version.rb

@@ -1,3 +1,3 @@
 module ApiHammer
-  VERSION = "0.19.0"
+  VERSION = "0.19.2"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: api_hammer
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.19.2
 platform: ruby
 authors:
 - Ethan
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -66,20 +65,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: json_pure
-  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
@@ -122,104 +107,6 @@ dependencies:
     - - ">="
       - !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: 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: 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'
-- !ruby/object:Gem::Dependency
-  name: actionpack
-  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:
@@ -229,18 +116,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".simplecov"
-- ".travis.yml"
 - ".yardopts"
 - CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile.rb
 - api_hammer.gemspec
 - bin/hc
-- gemfiles/Gemfile_rack_1
-- gemfiles/Gemfile_rack_2
 - lib/api_hammer.rb
 - lib/api_hammer/body.rb
 - lib/api_hammer/content_type_attrs.rb
@@ -275,21 +156,10 @@ files:
 - lib/logstash/filters/request_bodies_parsed.rb
 - lib/logstash/filters/ruby_logger.rb
 - lib/logstash/filters/sidekiq.rb
-- test/check_required_params_test.rb
-- test/faraday_request_logger_test.rb
-- test/halt_test.rb
-- test/helper.rb
-- test/public_instance_exec_test.rb
-- test/request_logger_test.rb
-- test/show_text_exceptions_test.rb
-- test/trailing_newline_test.rb
-- test/weblink_test.rb
-- test/ycomb_test.rb
 homepage: https://github.com/notEthan/api_hammer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -304,20 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
-signing_key: 
+rubygems_version: 4.0.5
 specification_version: 4
 summary: an API tool
-test_files:
-- test/check_required_params_test.rb
-- test/faraday_request_logger_test.rb
-- test/halt_test.rb
-- test/helper.rb
-- test/public_instance_exec_test.rb
-- test/request_logger_test.rb
-- test/show_text_exceptions_test.rb
-- test/trailing_newline_test.rb
-- test/weblink_test.rb
-- test/ycomb_test.rb
-- ".simplecov"
+test_files: []

data/.simplecov

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

data/.travis.yml

@@ -1,13 +0,0 @@
-rvm:
-  - 2.2.10
-  - 2.3.8
-  - 2.6.1
-gemfile:
-  - gemfiles/Gemfile_rack_1
-  - gemfiles/Gemfile_rack_2
-matrix:
-  fast_finish: true
-  exclude:
-    - rvm: 2.0.0
-      gemfile: gemfiles/Gemfile_rack_2
-script: rake test

data/Gemfile

@@ -1,10 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in api_hammer.gemspec
-gemspec
-
-gem 'byebug'
-gem 'wwtd'
-if RUBY_VERSION == '2.0.0'
-  gem 'nokogiri', '~> 1.6.8'
-end

data/Rakefile.rb

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

data/gemfiles/Gemfile_rack_1

@@ -1,13 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec path: '..'
-
-gem 'wwtd'
-
-gem 'rack', '~> 1.0'
-gem 'actionpack', '~> 4.0'
-
-if RUBY_VERSION == '2.0.0'
-  gem 'nokogiri', '~> 1.6.8'
-  gem 'public_suffix', '~> 2.0'
-end

data/gemfiles/Gemfile_rack_2

@@ -1,12 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec path: '..'
-
-gem 'wwtd'
-
-gem 'rack', '~> 2.0'
-gem 'actionpack', '~> 5.0'
-
-if RUBY_VERSION == '2.0.0'
-  gem 'nokogiri', '~> 1.6.8'
-end

data/test/check_required_params_test.rb

@@ -1,80 +0,0 @@
-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
-
-# strong parameters doesn't require its dependencies so good
-require 'rack/test'
-require 'active_support/core_ext/module'
-require 'action_controller/metal/strong_parameters'
-
-[Hash, ActionController::Parameters].each do |params_class|
-  describe "ApiHammer::Rails#check_required_params with #{params_class}" do
-    define_method(:controller_with_params) do |params|
-      FakeController.new.tap { |c| c.params = params_class.new.merge(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::Rails::Halt) { c.check_required_params(checks) }
-        assert_equal({'error_message' => 'id is required but was not provided', 'errors' => {'id' => ['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::Rails::Halt) { c.check_required_params(checks) }
-        assert_equal({'error_message' => 'person is required but was not provided', 'errors' => {'person' => ['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::Rails::Halt) { c.check_required_params(checks) }
-        assert_equal({'error_message' => 'person must be a Hash', 'errors' => {'person' => ['person must be a Hash']}}, err.body)
-      end
-
-      it 'is has the wrong type for person with hash check' do
-        c = controller_with_params(:person => [])
-        err = assert_raises(ApiHammer::Rails::Halt) { c.check_required_params(:person => {:id => Fixnum}) }
-        assert_equal({'error_message' => 'person must be a Hash', 'errors' => {'person' => ['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::Rails::Halt) { c.check_required_params(checks) }
-        assert_equal({'error_message' => 'person#name is required but was not provided', 'errors' => {'person#name' => ['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::Rails::Halt) { c.check_required_params(checks) }
-        assert_equal({'error_message' => 'lucky_numbers is required but was not provided', 'errors' => {'lucky_numbers' => ['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::Rails::Halt) { c.check_required_params(checks) }
-        assert_equal({'error_message' => 'lucky_numbers must be a Array', 'errors' => {'lucky_numbers' => ['lucky_numbers must be a Array']}}, err.body)
-      end
-
-      it 'has multiple problems' do
-        c = controller_with_params({})
-        err = assert_raises(ApiHammer::Rails::Halt) { c.check_required_params(checks) }
-        assert_equal({'error_message' => 'id is required but was not provided. person is required but was not provided. lucky_numbers is required but was not provided.', 'errors' => {'id' => ['id is required but was not provided'], 'person' => ['person is required but was not provided'], 'lucky_numbers' => ['lucky_numbers is required but was not provided']}}, err.body)
-      end
-    end
-  end
-end

data/test/faraday_request_logger_test.rb

@@ -1,228 +0,0 @@
-# encoding: utf-8
-
-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
-    conn = Faraday.new do |f|
-      f.use ApiHammer::Faraday::RequestLogger, logger
-      f.use Faraday::Adapter::Rack, proc { |env| [200, {}, []] }
-    end
-    conn.get '/'
-    assert_match(/200/, logio.string)
-    lines = logio.string.split("\n")
-    assert_equal(2, lines.size)
-    assert lines.last =~ /INFO -- : /
-    json_bit = $'
-    JSON.parse json_bit # should not raise 
-  end
-
-  {200 => :intense_green, 400 => :intense_yellow, 500 => :intense_red, 300 => :white}.each do |status, color|
-    it "colors by #{status} status" do
-      conn = Faraday.new do |f|
-        f.use ApiHammer::Faraday::RequestLogger, logger
-        f.use Faraday::Adapter::Rack, proc { |env| [status, {}, []] }
-      end
-      conn.get '/'
-      assert(logio.string.include?(Term::ANSIColor.send(color, status.to_s)))
-    end
-  end
-
-  it 'registers by name' do
-    conn = Faraday.new do |f|
-      f.request :api_hammer_request_logger, logger
-      f.use Faraday::Adapter::Rack, proc { |env| [200, {}, []] }
-    end
-    conn.get '/'
-    assert_match(/200/, logio.string)
-  end
-
-  describe 'response body encoding' do
-    it 'deals with encoding specified properly by the content type' do
-      app = proc do |env|
-        [200, {'Content-Type' => 'text/plain; charset=utf-8'}, ["Jalapeños".force_encoding("ASCII-8BIT")]]
-      end
-      conn = Faraday.new do |f|
-        f.request :api_hammer_request_logger, logger
-        f.use Faraday::Adapter::Rack, app
-      end
-      conn.get '/'
-      assert_match(/Jalapeños/, logio.string)
-    end
-
-    it 'deals content type specifying no encoding' do
-      app = proc do |env|
-        [200, {'Content-Type' => 'text/plain; x=y'}, ["Jalapeños".force_encoding("ASCII-8BIT")]]
-      end
-      conn = Faraday.new do |f|
-        f.request :api_hammer_request_logger, logger
-        f.use Faraday::Adapter::Rack, app
-      end
-      conn.get '/'
-      assert_match(/Jalapeños/, logio.string)
-    end
-
-    it 'deals with no content type' do
-      app = proc do |env|
-        [200, {}, ["Jalapeños".force_encoding("ASCII-8BIT")]]
-      end
-      conn = Faraday.new do |f|
-        f.request :api_hammer_request_logger, logger
-        f.use Faraday::Adapter::Rack, app
-      end
-      conn.get '/'
-      assert_match(/Jalapeños/, logio.string)
-    end
-
-    it 'falls back to array of codepoints when encoding is improperly specified by the content type' do
-      app = proc do |env|
-        [200, {'Content-Type' => 'text/plain; charset=utf-8'}, ["xx" + [195].pack("C*")]]
-      end
-      conn = Faraday.new do |f|
-        f.request :api_hammer_request_logger, logger
-        f.use Faraday::Adapter::Rack, app
-      end
-      conn.get '/'
-      assert_match('[120,120,195]', logio.string)
-    end
-
-    it 'falls back to array of codepoints when encoding is not specified and not valid utf8' do
-      app = proc do |env|
-        [200, {}, ["xx" + [195].pack("C*")]]
-      end
-      conn = Faraday.new do |f|
-        f.request :api_hammer_request_logger, logger
-        f.use Faraday::Adapter::Rack, app
-      end
-      conn.get '/'
-      assert_match('[120,120,195]', logio.string)
-    end
-  end
-  describe 'logging body by content-type' do
-    {
-      'application/octet-stream' => false,
-      'image/png' => false,
-      'image/png; charset=what' => false,
-      'text/plain' => true,
-      'text/plain; charset=utf-8' => true,
-    }.each do |content_type, istext|
-      it "does #{istext ? '' : 'not'} log body for #{content_type}" do
-        app = proc do |env|
-          [200, {'Content-Type' => content_type}, ['data go here']]
-        end
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.get '/'
-        assert(logio.string.include?('data go here') == istext)
-      end
-    end
-  end
-
-  describe 'log_bodies' do
-    it 'does not log bodies when log_bodies is false' do
-      app = proc do |env|
-        [200, {'Content-Type' => 'text/plain'}, ['data go here']]
-      end
-      conn = Faraday.new do |f|
-        f.request :api_hammer_request_logger, logger, :log_bodies => false
-        f.use Faraday::Adapter::Rack, app
-      end
-      conn.get '/'
-      assert(!logio.string.include?('data go here'))
-    end
-  end
-
-  describe 'filtering' do
-    describe 'json response' do
-      it 'filters' do
-        app = proc { |env| [200, {'Content-Type' => 'application/json'}, ['{"pin": "foobar", "bar": "baz"}']] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.get '/'
-        assert_includes(logio.string, %q("body":"{\"pin\": \"[FILTERED]\", \"bar\": \"baz\"}"))
-      end
-      it 'filters nested' do
-        app = proc { |env| [200, {'Content-Type' => 'application/json'}, ['{"object": {"pin": "foobar"}, "bar": "baz"}']] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.get '/'
-        assert_includes(logio.string, %q("body":"{\"object\": {\"pin\": \"[FILTERED]\"}, \"bar\": \"baz\"}"))
-      end
-      it 'filters in array' do
-        app = proc { |env| [200, {'Content-Type' => 'application/json'}, ['[{"object": [{"pin": ["foobar"]}], "bar": "baz"}]']] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.get '/'
-        assert_includes(logio.string, %q("body":"[{\"object\": [{\"pin\": \"[FILTERED]\"}], \"bar\": \"baz\"}]"))
-      end
-    end
-
-    describe 'json request' do
-      it 'filters a json request' do
-        app = proc { |env| [200, {}, []] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.post '/', '[{"object": [{"pin": ["foobar"]}], "bar": "baz"}]', {'Content-Type' => 'application/json'}
-        assert_includes(logio.string, %q("body":"[{\"object\": [{\"pin\": \"[FILTERED]\"}], \"bar\": \"baz\"}]"))
-      end
-    end
-
-    describe 'form encoded response' do
-      it 'filters' do
-        app = proc { |env| [200, {'Content-Type' => 'application/x-www-form-urlencoded'}, ['pin=foobar&bar=baz']] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.get '/'
-        assert_includes(logio.string, %q("body":"pin=[FILTERED]&bar=baz"))
-      end
-      it 'filters nested' do
-        app = proc { |env| [200, {'Content-Type' => 'application/x-www-form-urlencoded'}, ['object[pin]=foobar&bar=baz']] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.get '/'
-        assert_includes(logio.string, %q("body":"object[pin]=[FILTERED]&bar=baz"))
-      end
-      it 'filters in array' do
-        app = proc { |env| [200, {'Content-Type' => 'application/x-www-form-urlencoded'}, ['object[][pin][]=foobar&bar=baz']] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.get '/'
-        assert_includes(logio.string, %q("body":"object[][pin][]=[FILTERED]&bar=baz"))
-      end
-    end
-
-    describe 'form encoded request' do
-      it 'filters a json request' do
-        app = proc { |env| [200, {}, []] }
-        conn = Faraday.new do |f|
-          f.request :api_hammer_request_logger, logger, :filter_keys => 'pin'
-          f.use Faraday::Adapter::Rack, app
-        end
-        conn.post '/', 'object[pin]=foobar&bar=baz', {'Content-Type' => 'application/x-www-form-urlencoded'}
-        assert_includes(logio.string, %q(object[pin]=[FILTERED]&bar=baz))
-      end
-    end
-  end
-end

data/test/halt_test.rb

@@ -1,66 +0,0 @@
-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::Rails::Halt' do
-    haltex = assert_raises(ApiHammer::Rails::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::Rails::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::Rails::Halt) { FakeController.new.halt_unprocessable_entity({}) }
-      assert_equal({'errors' => {}}, haltex.body)
-      assert_equal(422, haltex.render_options[:status])
-    end
-  end
-
-  describe 'find_or_halt' do
-    it 'returns a record if it exists' do
-      record = Object.new
-      model = Class.new do
-        define_singleton_method(:where) { |attrs| [record] }
-        define_singleton_method(:table_name) { 'records' }
-      end
-      assert_equal record, FakeController.new.find_or_halt(model, {:id => 'anid'})
-    end
-    it 'it halts with 404 if not' do
-      model = Class.new do
-        (class << self; self; end).class_eval do
-          define_method(:where) { |attrs| [] }
-          define_method(:table_name) { 'record' }
-        end
-      end
-      haltex = assert_raises(ApiHammer::Rails::Halt) { FakeController.new.find_or_halt(model, {:id => 'anid'}) }
-      assert_equal({'error_message' => 'Unknown record! id: anid', 'errors' => {'record' => ['Unknown record! id: anid']}}, haltex.body)
-      assert_equal(404, 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

@@ -1,15 +0,0 @@
-proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('../lib', File.dirname(__FILE__)))
-
-require 'bundler'
-Bundler.setup
-
-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/public_instance_exec_test.rb

@@ -1,43 +0,0 @@
-proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
-require 'helper'
-
-require 'api_hammer/public_instance_exec'
-
-class Foo
-  def public_method(arg = :public)
-    arg
-  end
-  protected
-  def protected_method(arg = :protected)
-    arg
-  end
-  private
-  def private_method(arg = :private)
-    arg
-  end
-end
-
-describe '#public_instance_exec' do
-  it 'does things' do
-    foo = Foo.new
-    assert_equal(:public_exec, foo.public_instance_exec(:public_exec) { |arg| public_method(arg) })
-    regularex = (foo.protected_method rescue $!)
-    ex = assert_raises(regularex.class) { foo.public_instance_exec(:protected_exec) { |arg| protected_method(arg) } }
-    assert_includes(regularex.message, ex.message)
-    regularex = (foo.private_method rescue $!)
-    ex = assert_raises(regularex.class) { foo.public_instance_exec(:private_exec) { |arg| private_method(arg) } }
-    assert_includes(regularex.message, ex.message)
-  end
-end
-describe '#public_instance_eval' do
-  it 'does things' do
-    foo = Foo.new
-    assert_equal(:public, foo.public_instance_eval { public_method })
-    regularex = (foo.protected_method rescue $!)
-    ex = assert_raises(regularex.class) { foo.public_instance_eval { protected_method } }
-    assert_includes(regularex.message, ex.message)
-    regularex = (foo.private_method rescue $!)
-    ex = assert_raises(regularex.class) { foo.public_instance_eval { private_method } }
-    assert_includes(regularex.message, ex.message)
-  end
-end

data/test/request_logger_test.rb

@@ -1,136 +0,0 @@
-# -*- coding: utf-8 -*-
-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
-
-  it 'logs id and uuid (json)' do
-    body = %Q({"uuid": "theuuid", "foo_uuid": "thefoouuid", "id": "theid", "id_for_x": "theidforx", "bar.id": "thebarid", "baz-guid": "bazzz", "bigthing": "#{' ' * 4096}"})
-    app = ApiHammer::RequestLogger.new(proc { |env| [200, {"Content-Type" => 'application/json; charset=UTF8'}, [body]] }, logger)
-    app.call(Rack::MockRequest.env_for('/')).last.close
-    assert_match(%q("body_ids":{"uuid":"theuuid","foo_uuid":"thefoouuid","id":"theid","id_for_x":"theidforx","bar.id":"thebarid","baz-guid":"bazzz"}), logio.string)
-  end
-
-  it 'logs id and uuid (json array)' do
-    body = %Q([{"uuid": "theuuid", "foo_uuid": "thefoouuid"}, {"id": "theid", "id_for_x": "theidforx"}, {"bar.id": "thebarid", "baz-guid": "bazzz", "bigthing": "#{' ' * 4096}"}])
-    app = ApiHammer::RequestLogger.new(proc { |env| [200, {"Content-Type" => 'application/json; charset=UTF8'}, [body]] }, logger)
-    app.call(Rack::MockRequest.env_for('/')).last.close
-    assert_match(%q("body_ids":[{"uuid":"theuuid","foo_uuid":"thefoouuid"},{"id":"theid","id_for_x":"theidforx"},{"bar.id":"thebarid","baz-guid":"bazzz"}]), logio.string)
-  end
-
-  it 'logs id and uuid (form encoded)' do
-    body = %Q(uuid=theuuid&foo_uuid=thefoouuid&id=theid&id_for_x=theidforx&bar.id=thebarid&baz-guid=bazzz&bigthing=#{' ' * 4096})
-    app = ApiHammer::RequestLogger.new(proc { |env| [200, {"Content-Type" => 'application/x-www-form-urlencoded; charset=UTF8'}, [body]] }, logger)
-    app.call(Rack::MockRequest.env_for('/')).last.close
-    assert_match(%q("body_ids":{"uuid":"theuuid","foo_uuid":"thefoouuid","id":"theid","id_for_x":"theidforx","bar.id":"thebarid","baz-guid":"bazzz"}), logio.string)
-  end
-
-  it 'logs not-too-big request response bodies' do
-    app = ApiHammer::RequestLogger.new(proc { |env| [200, {}, ['the_response_body']] }, logger)
-    app.call(Rack::MockRequest.env_for('/', :input => 'the_request_body')).last.close
-    assert_match(/"request":\{.*"body":"the_request_body/, logio.string)
-    assert_match(/"response":\{.*"body":"the_response_body/, logio.string)
-  end
-
-  it 'logs request and response body on error (even if big)' do
-    app = ApiHammer::RequestLogger.new(proc { |env| [400, {}, ["the_response_body #{' ' * 4096}"]] }, logger)
-    app.call(Rack::MockRequest.env_for('/', :input => "the_request_body #{' ' * 4096}")).last.close
-    assert_match(/"request":\{.*"body":"the_request_body/, logio.string)
-    assert_match(/"response":\{.*"body":"the_response_body/, logio.string)
-  end
-
-  describe 'filtering' do
-    describe 'json response' do
-      it 'filters' do
-        body = %Q({"pin": "foobar"})
-        app = proc { |env| [200, {"Content-Type" => 'application/json; charset=UTF8'}, [body]] }
-        app = ApiHammer::RequestLogger.new(app, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/')).last.close
-
-        assert_includes(logio.string, %q("body":"{\"pin\": \"[FILTERED]\"}"))
-      end
-
-      it 'filters unicode' do
-        body = %Q({"key": "Björn"})
-        app = proc { |env| [200, {"Content-Type" => 'application/json; charset=utf-8'}, [body]] }
-        app = ApiHammer::RequestLogger.new(app, logger)
-        app.call(Rack::MockRequest.env_for('/')).last.close
-
-        assert_includes(logio.string, %q("body":"{\"key\": \"Björn\"}"))
-      end
-
-      it 'filters nested' do
-        body = %Q({"object": {"pin": "foobar"}})
-        app = proc { |env| [200, {"Content-Type" => 'application/json; charset=UTF8'}, [body]] }
-        app = ApiHammer::RequestLogger.new(app, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/')).last.close
-
-        assert_includes(logio.string, %q("body":"{\"object\": {\"pin\": \"[FILTERED]\"}}"))
-      end
-      it 'filters in array' do
-        body = %Q([{"object": [{"pin": ["foobar"]}]}])
-        app = proc { |env| [200, {"Content-Type" => 'application/json; charset=UTF8'}, [body]] }
-        app = ApiHammer::RequestLogger.new(app, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/')).last.close
-
-        assert_includes(logio.string, %q("body":"[{\"object\": [{\"pin\": \"[FILTERED]\"}]}]"))
-      end
-    end
-
-    describe 'json request' do
-      it 'filters a json request' do
-        app = ApiHammer::RequestLogger.new(proc { |env| [200, {}, []] }, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/', :input => '[{"object": [{"pin": ["foobar"]}]}]', 'CONTENT_TYPE' => 'application/json')).last.close
-        assert_includes(logio.string, %q("body":"[{\"object\": [{\"pin\": \"[FILTERED]\"}]}]"))
-      end
-    end
-
-    describe('form encoded response') do
-      it 'filters' do
-        app = proc { |env| [200, {"Content-Type" => 'application/x-www-form-urlencoded'}, ['pin=foobar']] }
-        app = ApiHammer::RequestLogger.new(app, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/')).last.close
-        assert_includes(logio.string, %q("body":"pin=[FILTERED]"))
-      end
-      it 'filters nested' do
-        app = proc { |env| [200, {'Content-Type' => 'application/x-www-form-urlencoded'}, ['object[pin]=foobar']] }
-        app = ApiHammer::RequestLogger.new(app, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/')).last.close
-        assert_includes(logio.string, %q("body":"object[pin]=[FILTERED]"))
-      end
-      it 'filters in array' do
-        app = proc { |env| [200, {'Content-Type' => 'application/x-www-form-urlencoded'}, ['object[][pin][]=foobar']] }
-        app = ApiHammer::RequestLogger.new(app, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/')).last.close
-        assert_includes(logio.string, %q("body":"object[][pin][]=[FILTERED]"))
-      end
-    end
-
-    describe 'form encoded request' do
-      it 'filters a json request' do
-        app = proc { |env| [200, {}, []] }
-        app = ApiHammer::RequestLogger.new(app, logger, :filter_keys => 'pin')
-        app.call(Rack::MockRequest.env_for('/', :input => 'object[pin]=foobar', 'CONTENT_TYPE' => 'application/x-www-form-urlencoded')).last.close
-        assert_includes(logio.string, %q(object[pin]=[FILTERED]))
-      end
-    end
-  end
-end

data/test/show_text_exceptions_test.rb

@@ -1,29 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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
-
-    describe '#to_s' do
-      it 'makes a string' do
-        link = ApiHammer::Weblink.new('http://example.com', :rel => 'foo', :title => 'example', 'title*' => 'an example')
-        assert_equal(%q(<http://example.com>; rel="foo"; title="example"; title*="an example"), link.to_s)
-      end
-      it 'parses the string to the same values' do
-        link = ApiHammer::Weblink.new('http://example.com', 'rel' => 'foo', 'title' => 'example', 'title*' => 'an example')
-        parsed_link = ApiHammer::Weblink.parse_link_value(link.to_s).first
-        assert_equal(link.target_uri, parsed_link.target_uri)
-        assert_equal(link.attributes, parsed_link.attributes)
-      end
-    end
-  end
-end

data/test/ycomb_test.rb

@@ -1,13 +0,0 @@
-proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
-require 'helper'
-
-require 'api_hammer/ycomb'
-describe 'ycomb' do
-  it 'does the needful' do
-    length = ycomb do |len|
-      proc{|list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
-    end
-    assert_equal(0, length.call([]))
-    assert_equal(3, length.call([:a, :b, :c]))
-  end
-end