redhead 0.0.8 → 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0892d60ca1c5336181bad77ba4d2b0f3182eef5d
+  data.tar.gz: a191d0961aa8f43ef90ebccaa8920e1075649ad0
+SHA512:
+  metadata.gz: dd5b97bcb3e031d8dab2979d63654e455a4c0dc7e3a85d01ac1cb6a14f4423653255ad3066a961a3a9133a2731f0ffca0bf0d7d837006b157c92174fb5eb886c
+  data.tar.gz: cdd733e317bad53ab3fd68e700d9c0a09d730414513ca136fc1734f9cb5d3e94db80492a010d0be05101808ce666a6d8a3cf7364d76473917e703098c563e604

data/README.md

@@ -26,8 +26,6 @@ To contribute:
 * Make a new feature branch: `git checkout -b some-new-thing master`
 * Pull request
 
-It will be assumed that your contribution will be licensed under the same terms as the project.
-
 ## Basics
 
 A variable `post` referencing a simple string can be wrapped up in a `Redhead::String` object.
@@ -35,18 +33,18 @@ A variable `post` referencing a simple string can be wrapped up in a `Redhead::S
 	>> puts post
 	Title: Redhead is for headers!
 	Tags: redhead, ruby, headers
-	
+
 	Since time immemorial, ...
-	
+
 	>> post = Redhead::String[post]
 	=> +"Since time immemorial, ..."
-	
+
 	>> post.headers
 	=> { { :title => "Redhead is for headers" }, { :tags => "redhead, ruby, headers" } }
-	
+
 	>> post
 	=> +"Since time immemorial, ..."
-	
+
 	>> post.to_s
 	=> "Since time immemorial, ..."
 
@@ -60,26 +58,26 @@ A Redhead string has the functionality of a regular Ruby string.
 
 	>> post.split(/,/).first.reverse
 	=> "lairomemmi emit ecniS"
-	
+
 	>> post.split(/ /).first
 	=> "Since"
-	
+
 	# Modifies the receiver!
 	>> post.reverse!
 	=> "... ,lairomemmi emit ecniS"
-	
+
 	>> post.to_s
 	=> "..., lairomemmi emit ecniS"
-	
+
 	>> post.headers
 	=> { { :title => "Redhead is for headers" }, { :tags => "redhead, ruby, headers" } }
-	
+
 	>> post.replace("Better content.")
 	=> "Better content."
-	
+
 	>> post.to_s
 	=> "Better content."
-	
+
 	>> post.headers
 	=> { { :title => "Redhead is for headers" }, { :tags => "redhead, ruby, headers" } }
 
@@ -91,10 +89,10 @@ In addition, you get access to headers.
 
 	>> post.headers[:title]
 	=> { :title => "Redhead is for headers!" }
-	
+
 	>> post.headers[:tags].to_s
 	=> "redhead, ruby, headers"
-	
+
 	>> post.headers.to_s
 	=> "Title: Redhead is for headers!\nTags: redhead, ruby, headers"
 
@@ -104,7 +102,7 @@ Modifying a header value is easy.
 
 	>> post.headers[:title] = "A change of title."
 	=> "A change of title."
-	
+
 	>> post.headers[:title]
 	=> { :title => "A change of title." }
 
@@ -119,13 +117,13 @@ Alternatively, you can work with the header name-value object itself.
 
 	>> title_header = post.headers[:title]
 	=> { :title => "A change of title." }
-	
+
 	>> title_header.value = "A better title."
 	=> "A better title."
-	
+
 	>> title_header
 	=> { :title => "A better title." }
-	
+
 	>> title_header.to_s
 	=> "Title: A better title."
 
@@ -135,10 +133,10 @@ You can also create and add new headers, in a similar way to modifying an existi
 
 	>> post.headers[:awesome] = "very"
 	=> "very"
-	
+
 	>> post.headers
 	=> { { :title => "A better title." }, { :tags => "redhead, ruby, headers" }, { :awesome => "very" } }
-	
+
 	>> post.headers.to_s
 	=> "Title: A better title.\nTags: redhead, ruby, headers\nAwesome: very"
 
@@ -146,7 +144,7 @@ Since Ruby assignments always return the right-hand side, there is an alternativ
 
 	>> post.headers.add(:amount_of_awesome, "high")
 	=> { :amount_of_awesome => "high" }
-	
+
 	>> post.headers[:amount_of_awesome].to_s
 	=> "Amount-Of-Awesome: high"
 
@@ -156,10 +154,10 @@ Deleting headers is just as easy.
 
 	>> post.headers
 	=> { { :title => "A better title." }, { :tags => "redhead, ruby, headers" }, { :awesome => "very" }, { :amount_of_awesome => "high" } }
-	
+
 	>> post.headers.delete(:amount_of_awesome)
 	=> { :amount_of_awesome => "high" }
-	
+
 	>> post.headers
 	=> { { :title => "A better title." }, { :tags => "redhead, ruby, headers" }, { :awesome => "very" } }
 
@@ -178,7 +176,7 @@ Original header names are remembered from the input string, and not simply creat
 If the original string is:
 
 	WaCKY fieLd NaME: value
-	
+
 	String's content.
 
 Then the header will be turned into a symbol:
@@ -210,16 +208,16 @@ Redhead has two main conversions which take place, related to header names. One
 
 	>> str.headers
 	=> { { :awesome_rating => "quite" } }
-	
+
 	>> output = str.headers.to_s(:awesome_rating => "Something-Completely-Different") + "\n\n" + str.to_s
 	=> "Something-Completely-Different: quite\n\nString's content."
-	
+
 	>> input = Redhead::String[output]
 	=> "String's content."
-	
+
 	>> input.headers
 	=> { { :something_completely_different => "quite" } }
-	
+
 	>> input.headers[:awesome_rating]
 	=> nil
 
@@ -231,19 +229,19 @@ With the above caveats in mind, to actually change the raw header name, you can
 
 	>> str.headers[:awesome] = "quite"
 	=> "quite"
-	
+
 	>> awesome_header = str.headers[:awesome]
 	=> { :awesome => "quite" }
-	
+
 	>> awesome_header.raw = "Some-Awe"
 	=> "Some-Awe"
-	
+
 	>> awesome_header
 	=> { :awesome => "quite" }
-	
+
 	>> awesome_header.to_s
 	=> "Some-Awe: quite"
-	
+
 	>> str.headers.to_s
 	=> "Some-Awe: quite"
 
@@ -252,19 +250,19 @@ You can also change the symbolic header name in the same fashion.
 	# Delete to forget about the above
 	>> str.headers.delete(:awesome)
 	=> { :awesome => "quite" }
-	
+
 	>> str.headers[:awesome] = "quite"
 	=> "quite"
-	
+
 	>> awesome_header = str.headers[:awesome]
 	=> { :awesome => "quite" }
-	
+
 	>> awesome_header.key = :different_kind_of_awesome
 	=> :different_kind_of_awesome
-	
+
 	>> awesome_header
 	=> { :different_kind_of_awesome => "quite" }
-	
+
 	>> awesome_header.to_s
 	=> "Awesome: quite"
 
@@ -272,16 +270,16 @@ The original symbolic header name will no longer work.
 
 	>> str.headers[:awesome]
 	=> nil
-	
+
 	>> str.headers[:different_kind_of_awesome].key = :awesome
 	=> :awesome
-	
+
 	>> awesome_header
 	=> { :awesome => "quite" }
-	
+
 	>> awesome_header.to_s
 	=> "Awesome: quite"
-	
+
 	>> str.headers[:different_kind_of_awesome]
 	=> nil
 
@@ -289,19 +287,19 @@ As a further option, there is `headers!`, which allows more one-step control, wo
 
 	>> str.headers
 	=> { { :awesome => "quite" } }
-	
+
 	>> str.headers[:temp] = "temp"
 	=> "temp"
-	
+
 	>> str.headers
 	=> { { :awesome => "quite" }, { :temp => "temp" } }
-	
+
 	>> str.headers.to_s
 	=> "Some-Awe: quite\nTemp: temp"
-	
+
 	>> str.headers!(:awesome => { :key => :awesome_rating, :raw => "Awesome-Rating" })
 	=> { { :awesome_rating => "quite" } }
-	
+
 	>> str.headers
 	=> { { :awesome => "quite" }, { :temp => "temp" } }
 
@@ -313,17 +311,17 @@ To work with a different raw header name, without modifying anything, you can pa
 
 	>> str.headers
 	=> { { :awesome => "quite" }, { :temp => "temp" } }
-	
+
 	>> str.headers.to_s
 	=> "Awesome-Rating: quite\nTemp: temp"
-	
+
 	>> str.headers.to_s(:awesome => "Something-To-Do with Awesome-ness", :temp => "A very TEMPORARY header name")
 	=> "Something-To-Do with Awesome-ness: quite\nA very TEMPORARY header name"
-	
+
 	# Nothing changed.
 	>> str.headers
 	=> { { :awesome => "quite" }, { :temp => "temp" } }
-	
+
 	>> str.headers.to_s
 	=> "Awesome-Rating: quite\nTemp: temp"
 
@@ -333,16 +331,16 @@ The custom raw header name can also be given explicitly at creation time.
 
 	>> str.headers
 	=> { { :awesome => "quite" }, { :temp => "temp" } }
-	
+
 	>> str.headers.delete(:temp)
 	=> { :temp => "temp" }
-	
+
 	>> str.headers
 	=> { { :awesome => "quite" } }
-	
+
 	>> str.headers.add(:temporary, "temp", "A-Rather-Temporary-Value")
 	=> { :temp => "temp" }
-	
+
 	>> str.headers.to_s
 	=> "Awesome-Rating: quite\nA-Rather-Temporary-Value: temp"
 

data/lib/redhead.rb

@@ -1,20 +1,20 @@
 module Redhead
-  
+
   # The character used to separate raw header names from their values.
   HEADER_NAME_VALUE_SEPARATOR_CHARACTER = ":"
-  
+
   # The actual pattern to split header name from value. Uses the above character.
   HEADER_NAME_VALUE_SEPARATOR_PATTERN = /\s*#{HEADER_NAME_VALUE_SEPARATOR_CHARACTER}\s*/
-  
+
   # The separator between header lines and regular body content.
   HEADERS_SEPARATOR = "\n\n"
-  
+
   # The actual pattern used to split headers from content.
   HEADERS_SEPARATOR_PATTERN = /\r?\n\r?\n/m
-  
+
   # The default code to convert a given key to a raw header name.
   TO_RAW = lambda { |key| key.to_s.split(/_/).map(&:capitalize).join("-") }
-  
+
   # The default code to convert a given raw header name to a key.
   TO_KEY = lambda { |raw| raw.split(/[^a-z_]+/i).join("_").downcase.to_sym }
 end

data/lib/redhead/header.rb

@@ -1,13 +1,13 @@
 module Redhead
   class Header
     attr_accessor :key, :raw, :value
-    
+
     def initialize(key, raw, value)
       @key = key
       @raw = raw
       @value = value
     end
-    
+
     # Parses a string representing a header. Uses HEADER_NAME_VALUE_SEPARATOR_PATTERN
     # to determine the name and value parts of the string.
     def self.parse(header_string)
@@ -15,12 +15,12 @@ module Redhead
       raw = $`
       value = $'
       key = TO_KEY[raw]
-      
+
       header = new(key, raw, value)
-      
+
       header
     end
-    
+
     # Returns the header as a string. If raw_name is given, this value is used as the raw header
     # name. If raw_name is not given, do one of two things:
     # 
@@ -30,18 +30,18 @@ module Redhead
       r = raw_name || (block_given? ? yield(key) : raw)
       "#{r}#{Redhead::HEADER_NAME_VALUE_SEPARATOR_CHARACTER} #{value}"
     end
-    
+
     # Does the same thing as #to_s, but instead of calling #raw in the last case, it computes the
     # raw header name dynamically from the key.
     def to_s!(raw_name = nil)
       r = raw_name || (block_given? ? yield(key) : TO_RAW[key])
       "#{r}#{Redhead::HEADER_NAME_VALUE_SEPARATOR_CHARACTER} #{value}"
     end
-        
+
     def inspect
       "{ #{key.inspect} => #{value.inspect} }"
     end
-    
+
     # Returns true if other_header has the same raw header name and value as self.
     def ==(other_header)
       raw   == other_header.raw &&

data/lib/redhead/header_set.rb

@@ -1,12 +1,12 @@
 module Redhead
   class HeaderSet
     include Enumerable
-    
+
     # Sets the headers of the set to _headers_. _headers_ is assumed to be ordered.
     def initialize(headers)
       @headers = headers
     end
-    
+
     # Parses lines of header strings with Header.parse. Returns a new HeaderSet object
     # for the parsed headers.
     def self.parse(header_string)
@@ -14,10 +14,10 @@ module Redhead
       header_string.gsub(/\r\n/, "\n").split("\n").each do |str|
         headers << Redhead::Header.parse(str)
       end
-      
+
       new(headers)
     end
-    
+
     # Yields each header in the set.
     def each
       @headers.each { |h| yield h }
@@ -27,17 +27,17 @@ module Redhead
     def size
       @headers.size
     end
-    
+
     # Returns true if the set of headers is empty.
     def empty?
       @headers.empty?
     end
-    
+
     # Returns the first header found which has Header#key matching _key_.
     def [](key)
       @headers.find { |header| header.key == key }
     end
-    
+
     # If there is a header in the set with a key matching _key_, then set its value to _value_.
     # If there is no header matching _key_, create a new header with the given key and value.
     def []=(key, value)
@@ -49,25 +49,25 @@ module Redhead
         self << new_header
       end
     end
-    
+
     # Adds _header_ to the set of headers.
     def <<(header)
       @headers << header
     end
-    
+
     # Similar to #[]= but allows manually setting the value of Header#raw to _raw_.
     def add(key, value, raw = nil)
       new_header = Redhead::Header.new(key, raw || TO_RAW[key], value)
       self << new_header
       new_header
     end
-    
+
     # Removes any headers with key names matching _key_ from the set.
     def delete(key)
       header = self[key]
       @headers.reject! { |header| header.key == key } ? header : nil
     end
-    
+
     # Calls #to_s on each header in the set, joining the result with newlines.
     # 
     # If _hash_ has a key matching a header in the set, passes the value for that key in the hash
@@ -75,7 +75,7 @@ module Redhead
     # block to Header#to_s instead.
     def to_s(hash = {}, &block)
       return @headers.map { |header| header.to_s }.join("\n") if hash.empty? && !block_given?
-      
+
       @headers.map do |header|
         if hash.has_key?(header.key)
           header.to_s(hash[header.key])
@@ -84,7 +84,7 @@ module Redhead
         end
       end.join("\n")
     end
-    
+
     # If a block is given, passes the block to Header#to_s! Joins
     # the result with newlines.
     def to_s!(&block)
@@ -109,11 +109,11 @@ module Redhead
     end
 
     alias_method :to_hash, :to_h
-        
+
     def inspect
       "{ #{@headers.map { |header| header.inspect }.join(", ")} }"
     end
-    
+
     # Returns true if, for each header in the set, there is a header in _other_ for which header#==(other_header)
     # is true. Otherwise, returns false.
     def ==(other)

data/lib/redhead/redhead_string.rb

@@ -3,7 +3,7 @@ require "delegate"
 module Redhead
   class String < SimpleDelegator
     attr_reader :headers, :string
-    
+
     class << self
       alias_method :[], :new
     end
@@ -27,12 +27,12 @@ module Redhead
       head_content = $`
 
       return false unless $`
-      
+
       head_content.lines.all? do |l|
         l =~ HEADER_NAME_VALUE_SEPARATOR_PATTERN
       end
     end
-    
+
     # Takes _string_, splits the headers from the content using HEADERS_SEPARATOR_PATTERN, then
     # creates the headers by calling HeaderSet.parse.
     def initialize(string)
@@ -45,6 +45,9 @@ module Redhead
 
           @headers = Redhead::HeaderSet.parse(header_content)
         else
+          @string = ""
+          super(@string)
+
           # we're dealing with only headers, so pass in the entire original string.
           # this lets us deal with inputs like new("foo: bar")
           @headers = Redhead::HeaderSet.parse(string)
@@ -55,21 +58,21 @@ module Redhead
         @headers = Redhead::HeaderSet.new([])
       end
     end
-    
+
     # Returns the main body content wrapped in the Redhead String object.
     def to_s
-      __getobj__
+      @string
     end
-    
+
     def inspect
       "+#{string.inspect}"
     end
-    
+
     # Returns true if self.headers == other.headers and self.string == other.string.
     def ==(other)
       headers == other.headers && string == other.string
     end
-    
+
     # Modifies the headers in the set, using the given _hash_, which has the form
     # 
     #     { :some_header => { :raw => a, :key => b }, :another_header => ..., ... }
@@ -78,21 +81,15 @@ module Redhead
     # is _b_. Returns a HeaderSet object containing the changed Header objects.
     def headers!(hash)
       changing = headers.select { |header| hash.has_key?(header.key) }
-      
+
       # modifies its elements!
       changing.each do |header|
         new_values = hash[header.key]
         header.raw = new_values[:raw] if new_values[:raw]
         header.key = new_values[:key] if new_values[:key]
       end
-      
+
       Redhead::HeaderSet.new(changing)
     end
   end
-  
-  private
-  
-  def __getobj__
-    string
-  end
 end

data/redhead.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name         = "redhead"
-  s.version      = "0.0.8"
+  s.version      = "0.0.9"
   s.authors      = ["Adam Prescott"]
   s.email        = ["adam@aprescott.com"]
   s.homepage     = "https://github.com/aprescott/redhead"

data/test/header_set_spec.rb

@@ -8,10 +8,10 @@ describe Redhead::HeaderSet do
     @header = @headers.first
     @first_header_key = :a
     @header_set = Redhead::HeaderSet.new(@headers)
-    
+
     @simple_headers = Redhead::HeaderSet.parse("A-Header: one\nA-Header-Two: two")
   end
-    
+
   context "as a class" do
     describe ".parse" do
       it "calls Header.parse on each header line, to create a set of headers" do
@@ -22,26 +22,26 @@ describe Redhead::HeaderSet do
       end
     end
   end
-  
+
   it "is Enumerable and responds to #each" do
     @header_set.is_a?(Enumerable).should be_true
     @header_set.respond_to?(:each).should be_true
   end
-  
+
   describe "#[]" do
     context "for a key with a corresponding header" do
       it "takes a symbolic header name key and returns a header" do
         @header_set[:a].is_a?(Redhead::Header).should be_true
       end
     end
-    
+
     context "for a key with no corresponding header" do
       it "returns nil" do
         @header_set[:something_non_existent].should be_nil
       end
     end
   end
-  
+
   describe "#[]=" do
     context "for a key with a corresponding header" do
       it "sets a new header value" do
@@ -51,7 +51,7 @@ describe Redhead::HeaderSet do
         @header_set[@first_header_key].value.should == new_value
       end
     end
-    
+
     context "for a key with no corresponding header" do
       it "creates a new header with this value" do
         new_value = "some brand new value"
@@ -61,7 +61,7 @@ describe Redhead::HeaderSet do
       end
     end
   end
-  
+
   describe "#add" do
     context "being equivalent to #[]=" do
       def new_header(header_string)
@@ -69,21 +69,21 @@ describe Redhead::HeaderSet do
         @header_set.add(:brand_new_key, "some value")
         @header_set[:brand_new_key].should_not be_nil
       end
-    
+
       it "parses the given header string, adds the new header to self and returns that header" do
         new_header(@header_set)
       end
-    
+
       it "creates a new header with the given value" do
         new_header(@header_set)
         @header_set[:brand_new_key].value.should == "some value"
       end
-      
+
       it "returns a Redhead::Header object" do
         @header_set.add(:brand_new_key, "some value").class.should == Redhead::Header
       end
     end
-    
+
     it "takes an optional third argument which sets the value of the raw header" do
       @header_set.add(:foo, "bar", "BAZ!")
       @header_set[:foo].value.should == "bar"
@@ -91,7 +91,7 @@ describe Redhead::HeaderSet do
       @header_set[:foo].raw.should == "BAZ!"
     end
   end
-  
+
   describe "#delete" do
     it "removes a header from the set" do
       @header_set[:brand_new_key].should be_nil
@@ -101,13 +101,13 @@ describe Redhead::HeaderSet do
       @header_set.delete(:brand_new_key)
       @header_set[:brand_new_key].should be_nil
     end
-    
+
     it "returns the deleted header" do
       @header_set[:brand_new_key] = "test"
       h = @header_set[:brand_new_key]
       @header_set.delete(:brand_new_key).should == h
     end
-    
+
     it "returns nil if there is no header corresponding to the key" do
       @header_set[:brand_new_key].should be_nil
       @header_set.delete(:brand_new_key).should be_nil
@@ -142,85 +142,85 @@ describe Redhead::HeaderSet do
       @header_set.size.should == @headers.size
     end
   end
-  
+
   describe "#to_s" do
     it "equals the individual header to_s results, joined with newlines" do
       @header_set.to_s.should == @headers.map { |header| header.to_s }.join("\n")
     end
-    
+
     context %Q{with a hash argument :a => "something raw"} do
       def modified_full_header_set_string
         str = "something raw: value_a\n"
         str += @headers[1..-1].map { |e| "header_#{e.key}: value_#{e.key}" }.join("\n")
         str
       end
-      
+
       it %Q{sets the header with key :a to have #raw == "one" and #value == 1} do
         str = modified_full_header_set_string
-        
+
         @header_set.to_s(:a => "something raw").should == str
         @header_set[:a].raw.should_not == "something raw"
         @header_set[:a].raw.should == "header_a"
       end
-            
+
       it "does not leave a side-effect" do
         str = modified_full_header_set_string
-        
+
         @header_set.to_s(:a => "something raw").should == str
         @header_set[:a].raw.should_not == "something raw"
         @header_set[:a].raw.should == "header_a"
       end
     end
-    
+
     context "with a block argument" do
       def modified_full_header_set_string
         @headers.map { |e| "#{yield e.key}: value_#{e.key}" }.join("\n")
       end
-      
+
       it "uses the given block to convert #key to a raw header, for each header in the set" do
         @header_set.to_s { "testing" + "testing" }.should == modified_full_header_set_string { "testing" + "testing" }
-        
+
         new_to_raw = proc { |x| x.to_s.upcase.reverse }
-        
+
         @header_set.to_s(&new_to_raw).should == modified_full_header_set_string(&new_to_raw)
       end
-      
+
       it "follows the hash argument first, falling back to the given block" do
         @header_set.to_s(:a => "something raw") { "NOT RAW AT ALL" }.split("\n").first.should == "something raw: value_a"
       end
     end
   end
-  
+
   describe "#to_s!" do
     context "without a block" do
       it "calls to_s! on each header in the set, joining the results with newlines" do
         @simple_headers.to_s!.should == @simple_headers.map { |header| header.to_s! }.join("\n")
       end
     end
-    
+
     context "with a block" do
       it "calls to_s! on each header in the set, passing the given block, joining the results with newlines" do
         @header_set.to_s! { "Total foo bar" }.should == @headers.map { |header| "Total foo bar: #{header.value}" }.join("\n")
       end
     end
   end
-  
+
   describe "#==(other_header)" do
     it "is sane." do
       @header_set.should == @header_set
-      
+
       Redhead::HeaderSet.parse("Test: test").should == Redhead::HeaderSet.parse("Test: test")
     end
-    
+
     it "returns true if, for every header in self, there is a corresponding header in other_header equal to it, using Header#==" do
       one, two = @header_set.partition { |header| header.key.to_s < @header_set.to_a[1].key.to_s }.map { |part| Redhead::HeaderSet.new(part) }
-      
+
       one.all? { |a| two.find { |b| a == b } }.should be_false
       # sanity check with any?
       one.any? { |a| two.find { |b| a == b } }.should be_false
-      
+
       one << two.first # create an overlap
-      
+
       one.all? { |a| two.find { |b| a == b } }.should be_false
       # sanity check with any?
       one.any? { |a| two.find { |b| a == b } }.should be_true

data/test/header_spec.rb

@@ -6,21 +6,21 @@ describe Redhead::Header do
     @header_raw_name = "A-Header-Name"
     @header_value = "some value"
     @separator = Redhead::HEADER_NAME_VALUE_SEPARATOR_CHARACTER
-    
+
     @full_header_string = "#{@header_raw_name}#{@separator} #{@header_value}"
-    
+
     @header = Redhead::Header.new(:a_header_name, "A-Header-Name", "some value")
     @header_copy = Redhead::Header.new(:a_header_name, "A-Header-Name", "some value")
-    
+
     @different_header_raw_name = "An original HEADER name"
     @header_different_name = Redhead::Header.new(:a_header_name, "An original HEADER name", "something here")
   end
-  
+
   context "as a class" do
     it "responds to :parse" do
       Redhead::Header.respond_to?(:parse).should be_true
     end
-    
+
     describe "self.parse" do
       it "parses a string and returns a header" do
         parsed_header = Redhead::Header.parse(@full_header_string)
@@ -30,19 +30,19 @@ describe Redhead::Header do
         parsed_header.value.should == @header_value
         parsed_header.raw.should == @header_raw_name
       end
-      
+
       it "ignores consecutive non-separating characters by default" do
         parsed_header = Redhead::Header.parse("one very    strange!!! header: anything")
         parsed_header.key.should == :one_very_strange_header
       end
-      
+
       it "ignores whitespace around `:` by default" do
         spaces = []
-        
+
         20.times do |n|
           spaces << [" "*rand(n), " "*rand(n)]
         end
-        
+
         spaces.each do |before, after|
           Redhead::Header.parse("#{@header_raw_name}#{before}:#{after}#{@header_value}").key.should == @header_name
         end
@@ -55,92 +55,92 @@ describe Redhead::Header do
       end
     end
   end
-  
+
   describe "#key" do
     it "returns the symbolic header name" do
       @header.key.should == :a_header_name
     end
   end
-  
+
   describe "#raw" do
     it "returns the raw header name stored at creation time" do
       @header.raw.should == @header_raw_name
     end
   end
-    
+
   describe "#value" do
     it "returns the header value" do
       @header.value.should == @header_value
     end
   end
-  
+
   describe "#value=" do
     it "sets a new header value" do
       @header.value = "new value"
       @header.value.should == "new value"
     end
   end
-    
+
   describe "#to_s" do
     it "returns <raw><separator> <value>" do
       @header.to_s.should == @full_header_string
     end
-        
+
     context "with a block" do
       it "uses the given block to convert #key to a raw header, and returns the raw string" do
         @header.to_s { "test" }.should == "test#{@separator} #{@header_value}"
       end
     end
-    
+
     it "takes an optional argument which specifies the raw header to use, without side-effects" do
       @header.to_s("test").should_not == @full_header_string
       @header.to_s("test").should == "test#{@separator} #{@header_value}"
       @header.to_s.should == @full_header_string
       @header.to_s.should_not == "test#{@separator} #{@header_value}"
     end
-    
+
     it "ignores the given block if there is an explicit raw header name" do
       @header.to_s("test") { "foo" }.should_not == "foo#{@separator} #{@header_value}"
       @header.to_s("test") { "foo" }.should == "test#{@separator} #{@header_value}"
     end
   end
-  
+
   describe "#==(other)" do
     it "returns true if self.raw == other.raw && self.value == other.value, otherwise false" do
       @header_copy.value = "something else entirely"
       @header.should_not == @header_copy
-      
+
       # same raw name, same value
       Redhead::Header.new(:a_header_name, "A-Header-Name", "a").should == Redhead::Header.new(:a_header_name, "A-Header-Name", "a")
-      
+
       # same raw name, different value
       Redhead::Header.new(:a_header_name, "A-Header-Name", "a").should_not == Redhead::Header.new(:a_header_name, "A-Header-Name", "aaaaaaa")
-      
+
       # different raw name, same value
       Redhead::Header.new(:a_header_name, "A-Header-Name", "a").should_not == Redhead::Header.new(:a_header_name, "A-Header-Nameeeeeeee", "a")
     end
   end
-  
+
   describe "#to_s!" do
     it "returns <computed_raw_header><separator> <value>" do
       @header.to_s!.should == "#{@header_raw_name}#{@separator} #{@header_value}"
       @header_different_name.to_s!.should == "#{@header_raw_name}#{@separator} something here"
     end
-    
+
     context "with a block argument" do
       it "uses the given block to compute the raw header name" do
         @header.to_s! { "testing" }.should == "testing: #{@header_value}"
         @header.to_s! { |x| x.to_s.upcase.reverse.gsub("_", "-") }.should == "#{@header_raw_name.to_s.upcase.reverse}: #{@header_value}"
       end
     end
-    
+
     it "takes an optional argument specifying the raw header name to use, without side-effects" do
       @header.to_s!("test").should_not == @full_header_string
       @header.to_s!("test").should == "test#{@separator} #{@header_value}"
       @header.to_s!.should == @full_header_string
       @header.to_s!.should_not == "test#{@separator} #{@header_value}"
     end
-    
+
     it "ignores the given block if there is an explicit raw header name" do
       @header.to_s("test") { "foo" }.should_not == "foo#{@separator} #{@header_value}"
       @header.to_s("test") { "foo" }.should == "test#{@separator} #{@header_value}"

data/test/redhead_string_spec.rb

@@ -7,7 +7,7 @@ describe Redhead::String do
     @rh_string = Redhead::String[@string]
     @copy_rh_string = Redhead::String[@string.clone]
   end
-    
+
   context "as a class" do
     describe "self.[]" do
       it "is equal (==) in result to using .new" do
@@ -39,6 +39,11 @@ describe Redhead::String do
           h.value.should == "bar:baz"
         end
       end
+
+      it "handles header-only inputs" do
+        Redhead::String["foo: bar"].to_s.should eq("")
+        Redhead::String["foo: bar\n"].to_s.should eq("")
+      end
     end
 
     describe ".has_headers?" do
@@ -59,23 +64,23 @@ describe Redhead::String do
       end
     end
   end
-  
+
   context "before any modifications:" do
     describe "#to_s" do
       it "returns a proper String instance" do
         @rh_string.to_s.class.should == String
       end
-      
+
       it "is the contents of the header-less string" do
         @rh_string.to_s.should == @string_content
       end
-      
+
       it "is not in fact the same object as its contained string" do
         @rh_string.to_s.equal?(@string_content).should be_false
       end
     end
   end
-  
+
   describe "#headers" do
     it "returns a Redhead::HeaderSet object" do
       @rh_string.headers.is_a?(Redhead::HeaderSet).should be_true
@@ -86,54 +91,54 @@ describe Redhead::String do
       s.headers.size.should == 0
     end
   end
-  
+
   it "provides regular String methods" do
     String.instance_methods(false).each do |m|
       @rh_string.respond_to?(m).should be_true
     end
   end
-  
+
   it "modifies its containing string with bang-methods" do
     orig = @rh_string.to_s.dup
     @rh_string.reverse!
     @rh_string.to_s.should == orig.reverse
     @rh_string.reverse!
-    
+
     orig = @rh_string.to_s.dup
     @rh_string.upcase!
     @rh_string.to_s.should == orig.upcase
   end
-    
+
   describe "#==" do
     it "returns true if the two Redhead strings contain equal headersets (using HeaderSet#==) and the same string content (using String#==)" do
       @rh_string.should == @rh_string
       @copy_rh_string.should == @rh_string
-      
+
       # change the copy
       @copy_rh_string.headers[:a_header_value] = "something"
       @other_rh_string = @copy_rh_string
-      
+
       @rh_string.headers.should_not == @other_rh_string.headers
       @rh_string.string.should == @other_rh_string.string
       @rh_string.should_not == @other_rh_string
     end
   end
-  
+
   describe %Q{#headers!(:a => { :raw => "random raw", :key => "random key" })} do
     it %Q{modifies the header for key :a by calling raw="random raw", and key="random_key"} do
       header = @rh_string.headers[:a_header_value]
       header.raw.should_not == "random raw"
       header.key.should_not == "random key"
-      
+
       @rh_string.headers!(:a_header_value => { :raw => "random raw", :key => "random key" })
       header.raw.should == "random raw"
       header.key.should == "random key"
     end
-    
+
     it "ignores keys with no matching header" do
       expect { @rh_string.headers!(:lorem_ipsum_dolor_sit_amettttt => {}) }.to_not raise_error
     end
-    
+
     it "returns only the changed headers" do
       @rh_string.headers!(:lorem_ipsum_dolor_sit_amet => {}).empty?.should be_true
       @rh_string.headers!(:a_header_value => {}).empty?.should_not be_true

metadata

@@ -1,46 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: redhead
 version: !ruby/object:Gem::Version
-  version: 0.0.8
-  prerelease: 
+  version: 0.0.9
 platform: ruby
 authors:
 - Adam Prescott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-17 00:00:00.000000000 Z
+date: 2014-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: String header metadata.
@@ -50,48 +45,47 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gemtest"
+- Gemfile
+- LICENSE
+- README.md
 - lib/redhead.rb
-- lib/redhead/redhead_string.rb
 - lib/redhead/header.rb
 - lib/redhead/header_set.rb
-- test/test_helper.rb
-- test/redhead_spec.rb
-- test/redhead_string_spec.rb
+- lib/redhead/redhead_string.rb
+- rakefile
+- redhead.gemspec
 - test/header_set_spec.rb
 - test/header_spec.rb
-- redhead.gemspec
-- .gemtest
-- LICENSE
-- Gemfile
-- rakefile
-- README.md
+- test/redhead_spec.rb
+- test/redhead_string_spec.rb
+- test/test_helper.rb
 homepage: https://github.com/aprescott/redhead
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: String header metadata.
 test_files:
 - test/test_helper.rb
-- test/redhead_spec.rb
 - test/redhead_string_spec.rb
 - test/header_set_spec.rb
 - test/header_spec.rb
+- test/redhead_spec.rb