segregate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ebb52ffc2a9364921143e72be4e33c036fe241b
+  data.tar.gz: 4dd0ee7bd05e7718fb57918f5ae416783a2266d5
+SHA512:
+  metadata.gz: 92bf21b2a568e476884189262dd195ab31487d4e3451104f492b4d0e8a8b62dc9897e85a718c812086c85edb5cf2d9574a4ca05b973407ad45c5665395d6b6e6
+  data.tar.gz: 65eb168efe658013e9dfd428814792d3a4369c94c14b3ea52ae03f965a4492ec354381f505b61880fc6343f3411a7dc95c13e91cc85e19e7dbee04f489065f04

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ben Slaughter
+
+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,10 @@
+Segregate
+=========
+
+[![Code Climate](https://codeclimate.com/github/benSlaughter/segregate.png)](https://codeclimate.com/github/benSlaughter/segregate)
+[![Build Status](https://travis-ci.org/benSlaughter/segregate.png?branch=master)](https://travis-ci.org/benSlaughter/segregate)
+[![Dependency Status](https://gemnasium.com/benSlaughter/segregate.png)](https://gemnasium.com/benSlaughter/segregate)
+[![Coverage Status](https://coveralls.io/repos/benSlaughter/segregate/badge.png?branch=master)](https://coveralls.io/r/benSlaughter/segregate?branch=master)
+[![Gem Version](https://badge.fury.io/rb/segregate.png)](http://badge.fury.io/rb/segregate)
+
+An http parser that also includes URI parsing and retaining and rebuilding the original data

data/lib/segregate/http_methods.rb

@@ -0,0 +1,13 @@
+class Segregate
+	HTTP_METHODS = [
+		"OPTIONS",
+		"GET",
+		"HEAD",
+		"POST",
+		"PUT",
+		"DELETE",
+		"TRACE",
+		"CONNECT",
+		"PATCH"
+	]
+end

data/lib/segregate/http_regular_expressions.rb

@@ -0,0 +1,5 @@
+class Segregate
+	REQUEST_LINE = /^(#{HTTP_METHODS.join("|")})\s(\*|\S+)\sHTTP\/(\d).(\d)$/
+	STATUS_LINE = /^HTTP\/(\d).(\d)\s(\d{3})\s([\w\s\-]+)$/
+	UNKNOWN_REQUEST_LINE = /^(\w+)\s(\*|\S+)\sHTTP\/(\d).(\d)$/
+end

data/lib/segregate/version.rb

@@ -0,0 +1,4 @@
+class Segregate
+	VERSION = "0.1.0".freeze
+  DATE = "2014-02-03".freeze
+end

data/lib/segregate.rb

@@ -0,0 +1,162 @@
+require 'uri'
+require 'hashie'
+require 'segregate/http_methods'
+require 'segregate/http_regular_expressions'
+
+class Segregate
+  attr_reader :uri, :request_method, :status_code, :status_phrase, :http_version, :headers, :body
+
+  def method_missing meth, *args, &block
+    if @uri.respond_to? meth
+      @uri.send meth, *args, &block
+    else
+      super
+    end
+  end
+
+  def respond_to?(meth, include_private = false)
+    @uri.respond_to?(meth, include_private) || super
+  end
+
+  def initialize
+    @uri = nil
+    @request_method = nil
+    @status_code = nil
+    @status_phrase = nil
+    @http_version = [nil, nil]
+
+    @headers = Hashie::Mash.new
+    @body = ""
+
+    @request = false
+    @response = false
+
+    @first_line_complete = false
+    @headers_complete = false
+    @body_complete = false
+    @header_order = []
+  end
+
+  def request?
+    @request
+  end
+
+  def response?
+    @response
+  end
+
+  def headers_complete?
+    @headers_complete
+  end
+
+  def body_complete?
+    @body_complete
+  end
+
+  def request_line
+    request? ? "%s %s HTTP/%d.%d" % [request_method, request_url.to_s, *http_version] : nil
+  end
+
+  def status_line
+    response? ? "HTTP/%d.%d %d %s" % [*http_version, status_code, status_phrase] : nil
+  end
+
+  def request_url
+    uri ? uri.to_s : nil
+  end
+
+  def major_http_version
+    http_version[0]
+  end
+
+  def minor_http_version
+    http_version[1]
+  end
+
+  def parse data
+    raise "ERROR: parsing completed" if @body_complete
+
+    data = StringIO.new data
+
+    read_first_line data unless @first_line_complete
+    read_headers data unless @headers_complete
+    read_body data unless data.eof?
+  end
+
+  private
+
+  def read data, size = nil
+    if size
+      data.read(size + 2).chomp("\r\n")
+    else
+      data.readline.chomp("\r\n")
+    end
+  end
+
+  def read_first_line data
+    line = read data
+
+    if line =~ REQUEST_LINE
+      parse_request_line line
+    elsif line =~ STATUS_LINE
+      parse_status_line line
+    elsif line =~ UNKNOWN_REQUEST_LINE
+      raise "ERROR: Unknown http method: %s" % line[/^\S+/]
+    else
+      raise "ERROR: Unknown first line: %s" % line
+    end
+
+    @first_line_complete = true
+  end
+
+  def parse_request_line line
+    @request = true
+    @request_method, url, @http_version[0], @http_version[1] = line.scan(REQUEST_LINE).flatten
+    @http_version.map! {|v| v.to_i}
+    @uri = URI.parse url
+  end
+
+  def parse_status_line line
+    @response = true
+    @http_version[0], @http_version[1], code, @status_phrase = line.scan(STATUS_LINE).flatten
+    @http_version.map! {|v| v.to_i}
+    @status_code = code.to_i
+  end
+
+  def read_headers data
+    while !data.eof? && !@headers_complete
+      line = read data
+      if line.empty?
+        @headers_complete = true
+      else
+        key, value = line.split(":")
+        @headers[key.downcase] = value.strip
+        @header_order << key.downcase
+      end
+    end
+  end
+
+  def read_body data
+    if headers.key? 'content-length'
+      parse_body data
+    elsif headers['content-encoding'] == 'chunked'
+      parse_chunked_data data
+    end
+  end
+
+  def parse_body data
+    @body = read data, headers['content-length'].to_i
+    @body_complete = true
+  end
+
+  def parse_chunked_data data
+    while !data.eof? && !@body_complete
+      chunk_size = read(data).to_i
+      if chunk_size == 0
+        @body_complete = true
+      else
+        @body << read(data, chunk_size)
+      end
+    end
+  end
+end

data/spec/segregate_spec.rb

@@ -0,0 +1,399 @@
+require 'spec_helper'
+
+describe Segregate do
+  it 'should be an instance of Class' do
+    expect(Segregate).to be_an_instance_of Class
+  end
+
+  describe '::new' do
+  	it 'returns an instance of Segregate' do
+  		expect(Segregate.new).to be_an_instance_of Segregate
+  	end
+
+    it 'has the inital values' do
+      @parser = Segregate.new
+      expect(@parser.request?).to be_false
+      expect(@parser.response?).to be_false
+      expect(@parser.uri).to be_nil
+      expect(@parser.request_line).to be_nil
+      expect(@parser.request_method).to be_nil
+      expect(@parser.request_url).to be_nil
+      expect(@parser.status_line).to be_nil
+      expect(@parser.status_code).to be_nil
+      expect(@parser.status_phrase).to be_nil
+      expect(@parser.http_version).to eq [nil, nil]
+      expect(@parser.major_http_version).to be_nil
+      expect(@parser.minor_http_version).to be_nil
+      expect(@parser.headers).to be_empty
+      expect(@parser.body).to be_empty
+    end
+  end
+
+  context 'a new parser has been created' do
+    before(:each) do
+      @parser = Segregate.new
+    end
+
+    describe '#parse' do
+      it 'accepts one argument' do
+        expect(@parser).to respond_to(:parse).with(1).argument
+      end
+
+      it 'errors if an incorrect first line is received' do
+        expect{ @parser.parse "fail\r\n" }.to raise_error RuntimeError, 'ERROR: Unknown first line: fail'
+      end
+
+      it 'errors if an incorrect http method is received' do
+        expect{ @parser.parse "FAIL /endpoint HTTP/1.1\r\n" }.to raise_error RuntimeError, 'ERROR: Unknown http method: FAIL'
+      end
+    end
+
+    context 'a request line has been parsed' do
+      before(:each) do
+        @parser.parse "GET /endpoint HTTP/1.1\r\n"
+      end
+
+      describe '#request_line' do
+        it 'returns a string' do
+          expect(@parser.request_line).to be_an_instance_of String
+        end
+
+        it 'returns a request line' do
+          expect(@parser.request_line).to match Segregate::REQUEST_LINE
+        end
+      end
+
+      describe '#status_line' do
+        it 'returns nil' do
+          expect(@parser.status_line).to be_nil
+        end
+      end
+
+      describe '#request?' do
+        it 'returns true' do
+          expect(@parser.request?).to be_an_instance_of TrueClass
+        end
+      end
+
+      describe '#response?' do
+        it 'returns false' do
+          expect(@parser.response?).to be_an_instance_of FalseClass
+        end
+      end
+
+      describe '#http_version' do
+        it 'returns an array' do
+          expect(@parser.http_version).to be_an_instance_of Array
+        end
+
+        it 'returns [1, 1]' do
+          expect(@parser.http_version).to eql [1,1]
+        end
+      end
+
+      describe '#major_http_version' do
+        it 'returns an integer' do
+          expect(@parser.major_http_version).to be_an_instance_of Fixnum
+        end
+
+        it 'returns 1' do
+          expect(@parser.major_http_version).to eql 1
+        end
+      end
+
+      describe '#minor_http_version' do
+        it 'returns an integer' do
+          expect(@parser.minor_http_version).to be_an_instance_of Fixnum
+        end
+
+        it 'returns 1' do
+          expect(@parser.minor_http_version).to eql 1
+        end
+      end
+
+      describe '#request_method' do
+        it 'returns an string' do
+          expect(@parser.request_method).to be_an_instance_of String
+        end
+
+        it 'returns GET' do
+          expect(@parser.request_method).to eq 'GET'
+        end
+      end
+
+      describe '#request_url' do
+        it 'returns an string' do
+          expect(@parser.request_url).to be_an_instance_of String
+        end
+
+        it 'returns /endpoint' do
+          expect(@parser.request_url).to eq '/endpoint'
+        end
+      end
+
+      describe '#status_code' do
+        it 'returns nil' do
+          expect(@parser.status_code).to be_nil
+        end
+      end
+
+      describe '#status_phrase' do
+        it 'returns nil' do
+          expect(@parser.status_phrase).to be_nil
+        end
+      end
+
+      describe '#uri' do
+        it 'returns a URI' do
+          expect(@parser.uri).to be_an_instance_of URI::Generic
+        end
+      end
+
+      describe '#method_missing' do
+        it 'returns the uri methods' do
+          expect(@parser.path).to eq '/endpoint'
+        end
+
+        it 'raises an error if uri does not respond to the method' do
+          expect{ @parser.not_present }.to raise_error NoMethodError, /undefined method `not_present'/
+        end
+      end
+
+      describe '#respond_to?' do
+        it 'responds to the uri path' do
+          expect(@parser.respond_to? :uri).to be_true
+          expect(@parser.respond_to? :path).to be_true
+        end
+      end
+    end
+
+    context 'a response line has been parsed' do
+      before(:each) do
+        @parser.parse "HTTP/1.1 200 OK\r\n"
+      end
+
+      describe '#request_line' do
+        it 'returns nil' do
+          expect(@parser.request_line).to be_nil
+        end
+      end
+
+      describe '#status_line' do
+        it 'returns a string' do
+          expect(@parser.status_line).to be_an_instance_of String
+        end
+
+        it 'returns a status line' do
+          expect(@parser.status_line).to match Segregate::STATUS_LINE
+        end
+      end
+
+      describe '#request?' do
+        it 'returns false' do
+          expect(@parser.request?).to be_an_instance_of FalseClass
+        end
+      end
+
+      describe '#response?' do
+        it 'returns true' do
+          expect(@parser.response?).to be_an_instance_of TrueClass
+        end
+      end
+
+      describe '#http_version' do
+        it 'returns an array' do
+          expect(@parser.http_version).to be_an_instance_of Array
+        end
+
+        it 'returns [1, 1]' do
+          expect(@parser.http_version).to eql [1,1]
+        end
+      end
+
+      describe '#major_http_version' do
+        it 'returns an integer' do
+          expect(@parser.major_http_version).to be_an_instance_of Fixnum
+        end
+
+        it 'returns 1' do
+          expect(@parser.major_http_version).to eql 1
+        end
+      end
+
+      describe '#minor_http_version' do
+        it 'returns an integer' do
+          expect(@parser.minor_http_version).to be_an_instance_of Fixnum
+        end
+
+        it 'returns 1' do
+          expect(@parser.minor_http_version).to eql 1
+        end
+      end
+
+      describe '#request_method' do
+        it 'returns nil' do
+          expect(@parser.request_method).to be_nil
+        end
+      end
+
+      describe '#request_url' do
+        it 'returns nil' do
+          expect(@parser.request_url).to be_nil
+        end
+      end
+
+      describe '#status_code' do
+        it 'returns an integer' do
+          expect(@parser.status_code).to be_an_instance_of Fixnum
+        end
+
+        it 'returns 200' do
+          expect(@parser.status_code).to eql 200
+        end
+      end
+
+      describe '#status_phrase' do
+        it 'returns an string' do
+          expect(@parser.status_phrase).to be_an_instance_of String
+        end
+
+        it 'returns OK' do
+          expect(@parser.status_phrase).to eq 'OK'
+        end
+      end
+
+      describe '#uri' do
+        it 'returns nil' do
+          expect(@parser.uri).to be_nil
+        end
+      end
+    end
+
+    context 'a header has been parsed' do
+      before(:each) do
+        @parser.parse "GET /endpoint HTTP/1.1\r\n"
+        @parser.parse "Accept: application/json\r\n"
+      end
+
+      describe '#headers' do
+        it 'returns an instans of a hashie mash' do
+          expect(@parser.headers).to be_an_instance_of Hashie::Mash
+        end
+
+        it 'contains the parsed header' do
+          expect(@parser.headers).to respond_to(:accept)
+          expect(@parser.headers.accept).to eq 'application/json'
+        end
+      end
+
+      describe '#headers_complete?' do
+        it 'returns false' do
+          expect(@parser.headers_complete?).to be_an_instance_of FalseClass
+        end
+      end
+    end
+
+    context 'all headers have been parsed' do
+      before(:each) do
+        @parser.parse "GET /endpoint HTTP/1.1\r\n"
+        @parser.parse "Accept: application/json\r\n"
+        @parser.parse "Host: www.google.com\r\n"
+        @parser.parse "\r\n"
+      end
+
+      describe '#headers' do
+        it 'returns an instans of a hashie mash' do
+          expect(@parser.headers).to be_an_instance_of Hashie::Mash
+        end
+
+        it 'contains all the parsed headers' do
+          expect(@parser.headers).to respond_to(:accept)
+          expect(@parser.headers).to respond_to(:host)
+          expect(@parser.headers.accept).to eq 'application/json'
+          expect(@parser.headers.host).to eq 'www.google.com'
+        end
+      end
+
+      describe '#headers_complete?' do
+        it 'returns true' do
+          expect(@parser.headers_complete?).to be_an_instance_of TrueClass
+        end
+      end
+    end
+
+    context 'a body has been parsed' do
+      before(:each) do
+        @parser.parse "GET /endpoint HTTP/1.1\r\n"
+        @parser.parse "Host: www.google.com\r\n"
+        @parser.parse "Content-Length: 20\r\n"
+        @parser.parse "\r\n"
+        @parser.parse "This is the content!\r\n\r\n"
+      end
+
+      describe '#body' do
+        it 'returns a string' do
+          expect(@parser.body).to be_an_instance_of String
+        end
+
+        it 'contains the body text' do
+          expect(@parser.body).to eq "This is the content!"
+        end
+      end
+
+      describe '#body_complete?' do
+        it 'returns true' do
+          expect(@parser.body_complete?).to be_an_instance_of TrueClass
+        end
+      end
+    end
+
+    context 'a partial chunked body has been parsed' do
+      before(:each) do
+        @parser.parse "GET /endpoint HTTP/1.1\r\n"
+        @parser.parse "Host: www.google.com\r\n"
+        @parser.parse "Content-Encoding: chunked\r\n"
+        @parser.parse "\r\n"
+        @parser.parse "26\r\nThis is the first content!\r\n"
+      end
+
+      describe '#body' do
+        it 'returns a string' do
+          expect(@parser.body).to be_an_instance_of String
+        end
+
+        it 'contains the body text' do
+          expect(@parser.body).to eq "This is the first content!"
+        end
+      end
+
+      describe '#body_complete?' do
+        it 'returns false' do
+          expect(@parser.body_complete?).to be_an_instance_of FalseClass
+        end
+      end
+
+      context 'the body parsing is completed' do
+        before(:each) do
+          @parser.parse "27\r\nThis is the second content!\r\n"
+          @parser.parse "0\r\n\r\n"
+        end
+
+        describe '#body' do
+          it 'returns a string' do
+            expect(@parser.body).to be_an_instance_of String
+          end
+
+          it 'contains the body text' do
+            expect(@parser.body).to eq "This is the first content!This is the second content!"
+          end
+        end
+
+        describe '#body_complete?' do
+          it 'returns true' do
+            expect(@parser.body_complete?).to be_an_instance_of TrueClass
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'coveralls'
+
+Coveralls.wear!
+require 'segregate'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = :documentation
+end
+
+def fixture_path
+  File.expand_path("../fixtures/", __FILE__)
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: segregate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ben Slaughter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-03 00:00:00.000000000 Z
+dependencies:
+- !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: 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: coveralls
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  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'
+description: An http parser that also includes URI parsing and retaining and rebuilding
+  the original data
+email: b.p.slaughter@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- lib/segregate/http_methods.rb
+- lib/segregate/http_regular_expressions.rb
+- lib/segregate/version.rb
+- lib/segregate.rb
+- spec/segregate_spec.rb
+- spec/spec_helper.rb
+homepage: http://benslaughter.github.io/segregate/
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Segregate http parser
+test_files:
+- spec/segregate_spec.rb
+- spec/spec_helper.rb
+has_rdoc: