response 0.0.2

data/lib/response.rb

@@ -0,0 +1,271 @@
+#encoding: utf-8
+require 'time'
+require 'ice_nine'
+require 'adamantium'
+require 'concord'
+require 'abstract_type'
+require 'equalizer'
+
+# Library to build rack compatible responses in a functional style
+class Response
+  include Adamantium::Flat, Concord.new(:status, :headers, :body)
+
+  # Error raised when finalizing responses with undefined components 
+  class InvalidError < RuntimeError; end
+
+  TEXT_PLAIN = 'text/plain; charset=UTF-8'.freeze
+
+  # Undefined response component
+  #
+  # A class to get nice #inspect behavior ootb
+  #
+  Undefined = Class.new.freeze
+
+  # Return status code
+  #
+  # @return [Response::Status]
+  #   if set
+  #
+  # @return [undefined]
+  #   otherwise
+  #
+  # @api private
+  #
+  attr_reader :status
+
+  # Return headers code
+  #
+  # @return [Hash]
+  #   if set
+  #
+  # @return [undefined]
+  #   otherwise
+  #
+  # @api private
+  #
+  attr_reader :headers
+
+  # Return status code
+  #
+  # @return [#each]
+  #   if set
+  #
+  # @return [undefined]
+  #   otherwise
+  #
+  # @api private
+  #
+  attr_reader :body
+
+  # Return response with new status
+  #
+  # @param [Fixnum] status
+  #   the status for the response
+  #
+  # @return [Response]
+  #   new response object with status set
+  #
+  # @example
+  #
+  #   response = Response.new
+  #   response = response.with_status(200)
+  #   response.status # => 200
+  #
+  # @api public
+  #
+  def with_status(status)
+    self.class.new(status, headers, body)
+  end
+
+  # Return response with new body
+  #
+  # @param [Object] body
+  #   the body for the response
+  #
+  # @return [Response]
+  #   new response with body set
+  #
+  # @example
+  #
+  #   response = Response.new
+  #   response = response.with_body('Hello')
+  #   response.body # => 'Hello'
+  #
+  # @api public
+  #
+  def with_body(body)
+    self.class.new(status, headers, body)
+  end
+
+  # Return response with new headers
+  #
+  # @param [Hash] headers
+  #   the header for the response
+  #
+  # @return [Response]
+  #   new response with headers set
+  #
+  # @example
+  #
+  #   response = Response.new
+  #   response = response.with_header({'Foo' => 'Bar'})
+  #   response.headers # => {'Foo' => 'Bar'}
+  #
+  # @api public
+  #
+  def with_headers(headers)
+    self.class.new(status, headers, body)
+  end
+
+  # Return response with merged headers
+  #
+  # @param [Hash] headers
+  #   the headers to merge
+  #
+  # @example
+  #
+  #   response = Response.new(200, {'Foo' => 'Baz', 'John' => 'Doe'})
+  #   response = response.merge_header({'Foo' => 'Bar'})
+  #   response.headers # => {'Foo' => 'Bar', 'John' => 'Doe'}
+  #
+  # @api public
+  #
+  # @return [Response]
+  #   returns new response with merged header
+  #
+  def merge_headers(headers)
+    self.class.new(status, self.headers.merge(headers), body)
+  end
+
+  # Return rack compatible array after asserting response is valid
+  #
+  # @return [Array]
+  #   rack compatible array
+  #
+  # @raise InvalidError
+  #   raises InvalidError when request containts undefined components
+  #
+  # @api private
+  #
+  def to_rack_response
+    assert_valid
+    rack_array
+  end
+
+  # Test if object is a valid response
+  #
+  # @return [true]
+  #   if all required fields are present
+  #
+  # @return [false]
+  #   otherwise
+  #
+  # @api private
+  #
+  def valid?
+    ![status, headers, body].any? { |item| item.equal?(Undefined) }
+  end
+  memoize :valid?
+
+  # Return rack compatible array
+  #
+  # @return [Array]
+  #   rack compatible array
+  #
+  # @example
+  #
+  #   response = Response.new(200, {'Foo' => 'Bar'}, 'Hello World')
+  #   response.rack_array # => [200, {'Foo' => 'Bar'}, 'Hello World']
+  #
+  # @api public
+  #
+  def rack_array
+    [status.code, headers, body]
+  end
+  memoize :rack_array
+
+  # Return contents of content type header
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def content_type
+    headers['Content-Type']
+  end
+
+  # Return last modified 
+  #
+  # @return [Time]
+  #   if last modified header is present
+  #
+  # @return [nil]
+  #   otherwise
+  #
+  # @api private
+  #
+  def last_modified
+    value = headers.fetch('Last-Modified') { return }
+    Time.httpdate(value)
+  end
+  memoize :last_modified
+
+  # Return contents of cache control header
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def cache_control
+    headers['Cache-Control']
+  end
+
+  # Build response with a dsl like interface
+  #
+  # @example
+  #
+  #   response = Response.build(200) do |response|
+  #     response.
+  #       with_headers('Foo' => 'Bar').
+  #       with_body('Hello')
+  #   end
+  #
+  #   response.status  # => 200
+  #   response.headers # => {'Foo' => 'Bar' }
+  #   response.body    # => 'Hello'
+  #
+  # @return [Array]
+  #   rack compatible array
+  #
+  # @api public
+  #
+  def self.build(status = Undefined, headers = {}, body = Undefined)
+    response = new(status, headers, body)
+    response = yield response if block_given?
+    response
+  end
+
+private
+
+  # Raise error when request containts undefined components
+  #
+  # @raise InvalidError
+  #   raises InvalidError when request containts undefined components
+  #
+  # @return [undefined]
+  #
+  # @api private
+  #
+  def assert_valid
+    unless valid?
+      raise InvalidError, "Not a valid response: #{self.inspect}"
+    end
+  end
+end
+
+require 'response/status'
+require 'response/redirect'
+require 'response/html'
+require 'response/xml'
+require 'response/json'
+require 'response/text'

data/response.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.name        = 'response'
+  gem.version     = '0.0.2'
+  gem.authors     = [ 'Markus Schirp' ]
+  gem.email       = [ 'mbj@seonic.net' ]
+  gem.description = 'Build rack responses with functional style'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/mbj/response'
+
+  gem.require_paths    = [ 'lib' ]
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.md TODO]
+
+  gem.add_dependency('ice_nine',      '~> 0.7.0')
+  gem.add_dependency('adamantium',    '~> 0.0.7')
+  gem.add_dependency('equalizer',     '~> 0.0.5')
+  gem.add_dependency('abstract_type', '~> 0.0.5')
+  gem.add_dependency('concord',       '~> 0.1.0')
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/functional_command_method_behavior.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+shared_examples_for 'a functional command method' do
+  it 'returns object of described_class' do
+    should be_kind_of(described_class)
+  end
+
+  it 'should return a new object' do
+    should_not be(object)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+require 'response'
+require 'devtools'
+Devtools.init_spec_helper
+
+RSpec.configure do |config|
+end

data/spec/unit/response/body_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Response, '#body' do
+
+  subject { object.body }
+
+  context 'when unset' do
+    let(:object) { described_class.build }
+
+    it { should be(Response::Undefined) }
+  end
+
+  context 'when set' do
+    let(:body) { mock('Body') }
+
+    let(:object) { described_class.build.with_body(body) }
+
+    it { should be(body) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/response/cache_control_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Response, '#cache_control' do
+  subject { object.cache_control }
+
+  let(:object) { Response.build.with_headers(header) }
+
+  context 'when Cache-Control header is present' do
+    let(:header) { { 'Cache-Control' => value } }
+
+    let(:value) { mock('Value') }
+
+    it { should be(value) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when Cache-Control header is not present' do
+    let(:header) { {} }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/response/class_methods/build_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Response, '.build' do
+  subject { object.build(&block) }
+
+  let(:object) { described_class }
+
+  context 'without arguments and block' do
+    let(:block)   { nil }
+
+    its(:valid?)  { should be(false)               }
+    its(:headers) { should eql({})                 }
+    its(:status)  { should be(Response::Undefined) }
+    its(:body)    { should be(Response::Undefined) }
+  end
+
+  context 'with block' do
+    let(:yields) { [] }
+    let(:value) { mock('Value') }
+    let(:block) { lambda { |response| yields << response; value } }
+
+    it 'should return value from block' do
+      should be(value)
+    end
+
+    it 'should call block with response' do
+      subject
+      yields.should eql([Response.build])
+    end
+  end
+end

data/spec/unit/response/content_type_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Response, '#content_type' do
+  subject { object.content_type }
+
+  let(:object) { Response.build.with_headers(header) }
+
+  context 'when Content-Type header is present' do
+    let(:header) { { 'Content-Type' => value } }
+
+    let(:value) { mock('Value') }
+
+    it { should be(value) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when Content-Type header is not present' do
+    let(:header) { {} }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end
+

data/spec/unit/response/headers_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Response, '#headers' do
+
+  subject { object.headers }
+
+  context 'when unset' do
+    let(:object) { described_class.build }
+
+    it { should eql({}) }
+  end
+
+  context 'when set' do
+    let(:headers) { mock('Headers') }
+
+    let(:object) { described_class.build.with_headers(headers) }
+
+    it { should be(headers) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+end

data/spec/unit/response/html/class_methods/build_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Response::HTML, '.build' do
+  subject { object.build(body) }
+
+  let(:body)    { mock('Body')    }
+  let(:object)  { described_class }
+
+  its(:status)  { should be(Response::Status::OK)  }
+  its(:body)    { should be(body) }
+  its(:headers) { should eql('Content-Type' => 'text/html; charset=UTF-8') }
+
+  it 'allows to modify response' do
+    object.build(body) do |response|
+      response.with_status(Response::Status::NOT_FOUND)
+    end.status.should be(Response::Status::NOT_FOUND)
+  end
+end

data/spec/unit/response/json/class_methods/build_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Response::JSON, '.build' do
+  subject { object.build(body) }
+
+  let(:body)   { mock('Body')    }
+  let(:object) { described_class }
+                
+  its(:status)  { should be(Response::Status::OK)                                 }
+  its(:body)    { should be(body)                                                 }
+  its(:headers) { should eql('Content-Type' => 'application/json; charset=UTF-8') }
+
+  it 'allows to modify response' do
+    object.build(body) do |response|
+      response.with_status(404)
+    end.status.should be(404)
+  end
+end

data/spec/unit/response/last_modified_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Response, '#last_modified' do
+  subject { object.last_modified }
+
+  let(:object) { Response.build.with_headers(header) }
+
+  let(:time) { Time.httpdate(Time.now.httpdate) }
+
+  context 'when Content-Type header is present' do
+    let(:header) { { 'Last-Modified' => time.httpdate } }
+
+    it { should eql(time) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when Content-Type header is not present' do
+    let(:header) { {} }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/response/merge_headers_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Response, '#merge_headers' do
+  subject { object.merge_headers(update_headers) }
+
+  let(:object)           { described_class.build(status, original_headers, body)  }
+  let(:status)           { Response::Status::OK }
+  let(:update_headers)   { { 'Baz' => 'Zot' }   }
+  let(:original_headers) { { 'Foo' => 'Bar' }   }
+
+  let(:status)  { mock('Status')    }
+  let(:body)    { mock('Body')      }
+
+  its(:status)  { should be(status) }
+  its(:body)    { should be(body)   }
+  its(:headers) { should eql('Foo' => 'Bar', 'Baz' => 'Zot') }
+
+  it_should_behave_like 'a functional command method'
+end
+

data/spec/unit/response/rack_array_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Response, '#rack_array' do
+  subject { object.rack_array }
+
+  let(:status)  { Response::Status::OK  }
+  let(:headers) { mock('Headers') }
+  let(:body)    { mock('Body')    }
+
+  let(:object) { described_class.build(status, headers, body) }
+
+  it { should eql([200, headers, body]) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/response/redirect/class_methods/build_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Response::Redirect::Found, '#build' do
+  
+  subject { object.build(location) }
+
+  let(:object) { described_class }
+
+  let(:location) { mock('Location', :to_s => 'THE-LOCATION') }
+
+  its(:status)  { should be(Response::Status::FOUND) }
+  its(:headers) { should eql('Location' => location, 'Content-Type' => 'text/plain; charset=UTF-8') }
+  its(:body)    { should eql('You are beeing redirected to: THE-LOCATION') }
+end
+
+describe Response::Redirect::Permanent, '#build' do
+  
+  subject { object.build(location) }
+
+  let(:object) { described_class }
+
+  let(:location) { mock('Location', :to_s => 'THE-LOCATION') }
+
+  its(:status)  { should be(Response::Status::MOVED_PERMANENTLY) }
+  its(:headers) { should eql('Location' => location, 'Content-Type' => 'text/plain; charset=UTF-8') }
+  its(:body)    { should eql('You are beeing redirected to: THE-LOCATION') }
+end
+

data/spec/unit/response/status_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Response, '#status' do
+
+  subject { object.status }
+
+  context 'when unset' do
+    let(:object) { described_class.build }
+
+    it { should be(Response::Undefined) }
+  end
+
+  context 'when set' do
+    let(:status) { mock('Status') }
+
+    let(:object) { described_class.build.with_status(status) }
+
+    it { should be(status) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/response/text/class_methods/build_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Response::Text, '.build' do
+  subject { object.build(body) }
+
+  let(:body)    { mock('Body')    }
+  let(:object)  { described_class }
+
+  its(:status)  { should be(Response::Status::OK)  }
+  its(:body)    { should be(body) }
+  its(:headers) { should eql('Content-Type' => 'text/plain; charset=UTF-8') }
+
+  it 'allows to modify response' do
+    object.build(body) do |response|
+      response.with_status(Response::Status::NOT_FOUND)
+    end.status.should be(Response::Status::NOT_FOUND)
+  end
+end

data/spec/unit/response/to_rack_response_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Response, '#to_rack_response' do
+
+  subject { object.to_rack_response }
+
+  let(:status)  { Response::Status::OK }
+  let(:headers) { mock('Headers') }
+  let(:body)    { mock('Body') }
+
+  context 'with valid response' do
+    let(:object) { Response.build(status, headers, body) }
+
+    it { should eql([200, headers, body]) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'with invalid response' do
+    let(:object) { Response.build }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(Response::InvalidError, "Not a valid response: #{object.inspect}")
+    end
+  end
+end

data/spec/unit/response/valid_predicate_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Response, '#valid?' do
+  subject { object.valid? }
+
+  context 'with status and body' do
+    let(:object) { described_class.build(Response::Status::OK, {}, mock('Body')) }
+
+    it { should be(true) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'without body' do
+    let(:object) { described_class.build.with_status(Response::Status::OK) }
+
+    it { should be(false) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'without status' do
+    let(:object) { described_class.build.with_body(mock('Body')) }
+
+    it { should be(false) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'without status and body' do
+    let(:object) { described_class.build }
+
+    it { should be(false) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end