redhead 0.0.4 → 0.0.5

data/LICENSE

@@ -1,6 +1,6 @@
 (MIT License)
 
-Copyright (c) 2010 Adam Prescott
+Copyright (c) 2010-2012 Adam Prescott
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -165,8 +165,6 @@ There are conventions followed in creating a Redhead string and modifying certai
 
 By default, newly added header field names (i.e., the keys) will become capitalised and hyphen-separated to create their raw header name, so that the symbolic header name `:if_modified_since` becomes the raw header name `If-Modified-Since`. A similar process also happens when turning a string into a Redhead string (in reverse), and when using the default behaviour of `to_s`. To keep symbol names pleasant, by default, anything which isn't `A-Z`, `a-z` or `_` is converted into a `_` character. So `"Some! Long! Header! Name!"` becomes `:some_long_header_name` for accessing within Ruby.
 
-For information on changing the formatting rules, see the section on <a href="#special_circumstances">special circumstances</a>.
-
 ## Header name memory
 
 Original header names are remembered from the input string, and not simply created on-the-fly when using `to_s`. This is to make sure you get the same raw heading name, as a string, that you originally read in, instead of assuming you want it to be changed. Access as a Ruby object, however, is with a symbol by default.
@@ -336,126 +334,12 @@ The custom raw header name can also be given explicitly at creation time.
 	>> str.headers
 	=> { { :awesome => "quite" } }
 	
-	>> str.heders.add(:temporary, "temp", "A-Rather-Temporary-Value")
+	>> str.headers.add(:temporary, "temp", "A-Rather-Temporary-Value")
 	=> { :temp => "temp" }
 	
 	>> str.headers.to_s
 	=> "Awesome-Rating: quite\nA-Rather-Temporary-Value: temp"
 
-# Enterprise Header Solutions
-
-As mentioned, Redhead performs two conversions. One to produce a symbolic header name from the raw header name, and one to produce the raw header name from the symbolic header name. The symbolic -> raw process is used in `to_s!`, to force header names to be produced instead of using the header name remembered from when the header was created.
-
-If you need to control the format of header names beyond the simple separator option given above, you can provide a block, the result of which is the name used for the raw or symbolic header name.
-
-If that doesn't make a lot of sense on the first read, don't worry, here's some code.
-
-	>> string = "A-Header-Name: a header value\n\nContent."
-	=> "A-Header-Name: a header value\n\nContent."
-	
-	>> str = Redhead::String.new(string) do |name|
-	?>   name.split(/-/).join("").upcase.to_sym
-	?> end
-	=> +"Content."
-	
-	>> str.headers
-	=> { { :AHEADERNAME => "a header value" } }
-
-Note that this uses `Redhead::String.new` instead of `Redhead::String.[]` because of the block argument.
-
-The above defines how symbolic headers are created in when creating the header objects. Using this approach, you can work with non-standard headers quite easily.
-
-Note that `to_sym` is _not_ implicit, to suggest you use a pleasant symbol as the key.
-
-It's also possible to specify the code to be used when calling `to_s`:
-
-	>> str.headers
-	=> { { :AHEADERNAME => "a header value" } }
-	
-	>> str.headers.to_s do |name|
-	?>   name.to_s.downcase.scan(/..?.?/).join("-").capitalize
-	?> end
-	=> "ahe-ade-rna-me: a header value"
-
-The block to `to_s` will not modify the headers in-place, in keeping with the behaviour of the block-less `to_s`. To change how the symbolic-to-raw header name conversion works, you can do so on the object holding the headers.
-
-	>> str.headers.to_raw = lambda do |name|
-	?>   name.to_s.downcase.scan(/..?.?/).join("-").capitalize
-	?> end
-	=> #<Proc:...>
-
-Similarly, you can modify `to_key`. You can also change `to_raw` and `to_key` for each individual header. If no block is given for a specific header, it defaults to the block for the containing `headers` object. If nothing is given _there_, then it goes to the default.
-
-If `to_raw(produced_key) != original_key` for all the headers in the object, then the headers are in a mismatched state. Equally, a single header is in a mismatched state if the condition fails for that header.
-
-This can be checked with `reversible?`.
-
-	>> string = "A-Header-Name: a header value\n\nContent."
-	=> "A-Header-Name: a header value\n\nContent."
-	
-	>> str = Redhead::String.new(string) do |name|
-	?>   name.gsub(/-/, "").upcase.to_sym
-	?> end
-	=> +"Content."
-	
-	# At this point, `to_key` is not reversible via `to_raw`
-	
-	>> str.headers.reversible?
-	=> false
-	
-	>> str = Redhead::String.new(string) do |name|
-	?>   name.split(/-/).map { |e| e.upcase }.join("zzz").to_sym
-	?> end
-	=> +"Content."
-	
-	>> str.headers
-	=> { { :AzzzHEADERzzzNAME => "a header value" } }
-	
-	>> str.headers.reversible?
-	=> false
-	
-	>> str.headers.to_raw = lambda do |name|
-	?>   name.to_s.split(/zzz/).map { |e| e.capitalize }.join("-")
-	?> end
-	=> #<Proc:...> 
-	
-	# We can go back and forth without issue on this string
-	
-	>> str.headers.reversible?
-	=> true
-	
-	>> str.headers
-	=> { { :AzzzHEADERzzzzNAME => "a header value" } }
-	
-	>> str.headers.to_s
-	=> "A-Header-Name: a header value"
-
-Reversibility is checked by calling `reversible?` on all the headers in `str.headers`, since each header can have its own `to_key` and `to_raw` blocks. `reversible?` returning false will not raise an error or stop execution.
-
-When creating new headers, `to_raw`, is used, meaning your custom block will be picked up and used to create the raw header as though it had been created from a string.
-
-	>> str.headers.to_raw = proc { "Genuinely" }
-	
-	>> str.headers[:foo_bar] = "temp"
-	=> "temp"
-	
-	>> temp_header = str.headers[:foo_bar]
-	=> { :foo_bar => "temp" }
-	
-	>> temp_header.to_s
-	=> "Genuinely: temp"
-
-Changing `to_raw` after-the-fact will not change the raw header name stored for the object. To force `to_raw` to be used instead of the stored value, use `to_s!`, which _always_ uses `to_raw`.
-
-	>> temp_header.to_raw = lambda { "nothing meaningful" }
-	=> #<Proc:...>
-	
-	>> temp_header.to_s
-	=> "Temp-Orary-Header: temp"
-	
-	>> temp_header.to_s!
-	=> "nothing meaningful: temp"
-
 # TODO
 
 Headers on different lines with the same raw name. Important for HTTP.

data/lib/redhead.rb

@@ -1,6 +1,3 @@
-# Copyright (c) 2010 Adam Prescott
-# Licensed under the MIT license. See LICENSE.
-
 module Redhead
   
   # The character used to separate raw header names from their values.
@@ -20,16 +17,6 @@ module Redhead
   
   # 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 }
-  
-  # Method wrapping TO_RAW, to allow overriding for customisation.
-  def self.to_raw
-    TO_RAW
-  end
-  
-  # Method wrapping TO_KEY, to allow overriding for customisation.
-  def self.to_key
-    TO_KEY
-  end
 end
 
 require "redhead/header"

data/lib/redhead/header.rb

@@ -1,7 +1,6 @@
 module Redhead
   class Header
     attr_accessor :key, :raw, :value
-    attr_writer :to_key, :to_raw
     
     def initialize(key, raw, value)
       @key = key
@@ -11,17 +10,11 @@ module Redhead
     
     # Parses a string representing a header. Uses HEADER_NAME_VALUE_SEPARATOR_PATTERN
     # to determine the name and value parts of the string.
-    # 
-    # With a given block, the parsed raw header name is passed to the block and the result is
-    # used as the key name. If no block is given, then the default is used to create the key
-    # name.
-    def self.parse(header_string, &block)
+    def self.parse(header_string)
       header_string =~ HEADER_NAME_VALUE_SEPARATOR_PATTERN
       raw = $`
       value = $'
-      
-      to_key_block = block || Redhead.to_key
-      key = to_key_block[raw]
+      key = TO_KEY[raw]
       
       header = new(key, raw, value)
       
@@ -38,23 +31,13 @@ module Redhead
       "#{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 calls #raw!.
+    # 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) : raw!)
+      r = raw_name || (block_given? ? yield(key) : TO_RAW[key])
       "#{r}#{Redhead::HEADER_NAME_VALUE_SEPARATOR_CHARACTER} #{value}"
     end
-    
-    # Calls #to_key with #raw as the argument.
-    def key!
-      to_key[raw]
-    end
-    
-    # Calls #to_raw with #key as the argument. By-passes the stored raw header name and reproduces
-    # it with #to_raw dynamically.
-    def raw!
-      to_raw[key]
-    end
-    
+        
     def inspect
       "{ #{key.inspect} => #{value.inspect} }"
     end
@@ -64,20 +47,5 @@ module Redhead
       raw   == other_header.raw &&
       value == other_header.value
     end
-    
-    # Returns the Proc object used to convert keys to raw header names. Defaults to Redhead.to_raw.
-    def to_raw
-      @to_raw || Redhead.to_raw
-    end
-    
-    # Returns the Proc object used to convert keys to raw header names. Defaults to Redhead.to_raw.
-    def to_key
-      @to_key || Redhead.to_key
-    end
-    
-    # Returns true if to_raw[to_key[raw]] == raw, otherwise, false.
-    def reversible?
-      to_raw[to_key[raw]] == raw
-    end
   end
 end

data/lib/redhead/header_set.rb

@@ -9,10 +9,10 @@ module Redhead
     
     # Parses lines of header strings with Header.parse. Returns a new HeaderSet object
     # for the parsed headers.
-    def self.parse(header_string, &block)
+    def self.parse(header_string)
       headers = []
       header_string.split("\n").each do |str|
-        headers << Redhead::Header.parse(str, &block)
+        headers << Redhead::Header.parse(str)
       end
       
       new(headers)
@@ -34,15 +34,13 @@ module Redhead
     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,
-    # with a raw header equal to to_raw[key]. Sets the new header's to_raw to self#to_raw.
+    # If there is no header matching _key_, create a new header with the given key and value.
     def []=(key, value)
       h = self[key]      
       if h
         h.value = value
       else
-        new_header = Redhead::Header.new(key, to_raw[key], value)
-        new_header.to_raw = to_raw
+        new_header = Redhead::Header.new(key, TO_RAW[key], value)
         self << new_header
       end
     end
@@ -54,8 +52,7 @@ module Redhead
     
     # 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)
-      new_header.to_raw = to_raw
+      new_header = Redhead::Header.new(key, raw || TO_RAW[key], value)
       self << new_header
       new_header
     end
@@ -83,40 +80,13 @@ module Redhead
       end.join("\n")
     end
     
-    # If a block is given, passes the block to Header#to_s! otherwise passes #to_raw instead. Joins
+    # If a block is given, passes the block to Header#to_s! Joins
     # the result with newlines.
     def to_s!(&block)
-      blk = block || to_raw
+      blk = block || TO_RAW
       @headers.map { |header| header.to_s!(&blk) }.join("\n")
     end
-    
-    # Returns true if Header#reversible? is true for each header in the set, otherwise false.
-    def reversible?
-      all? { |header| header.reversible? }
-    end
-    
-    # Returns the Proc to be used to convert key names to raw header names. Defaults to Redhead.to_raw.
-    def to_raw
-      @to_raw || Redhead.to_raw
-    end
-    
-    # Sets HeaderSet#to_raw to _new_to_raw_. Sets Header#to_raw for each header in the set to _new_to_raw_.
-    def to_raw=(new_to_raw)
-      @to_raw = new_to_raw
-      each { |header| header.to_raw = new_to_raw }
-    end
-    
-    # Returns the Proc to be used to convert raw header names to key names. Defaults to Redhead.to_key.
-    def to_key
-      @to_key || Redhead.to_key
-    end
-    
-    # Sets HeaderSet#to_raw to _new_to_raw_. Sets Header#to_raw for each header in the set to _new_to_raw_.
-    def to_key=(new_to_key)
-      @to_key = new_to_key
-      each { |header| header.to_key = new_to_key }
-    end
-    
+        
     def inspect
       "{ #{@headers.map { |header| header.inspect }.join(", ")} }"
     end

data/lib/redhead/redhead_string.rb

@@ -9,15 +9,13 @@ module Redhead
     end
     
     # Takes _string_, splits the headers from the content using HEADERS_SEPARATOR_PATTERN, then
-    # creates the headers by calling HeaderSet.parse, passing in _block_. Sets #to_key to _block_,
-    # and calls super with the main body content as an argument.
-    def initialize(string, &block)
+    # creates the headers by calling HeaderSet.parse.
+    def initialize(string)
       string =~ HEADERS_SEPARATOR_PATTERN
       @string = $'
       super(@string)
       
-      @headers = Redhead::HeaderSet.parse($`, &block)
-      @headers.to_key = block
+      @headers = Redhead::HeaderSet.parse($`)
     end
     
     # Returns the main body content wrapped in the Redhead String object.

data/redhead.gemspec

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

data/test/header_set_spec.rb

@@ -8,11 +8,8 @@ describe Redhead::HeaderSet do
     @header = @headers.first
     @first_header_key = :a
     @header_set = Redhead::HeaderSet.new(@headers)
-    @default_to_raw = Redhead.to_raw
-    @default_to_key = Redhead.to_key
     
-    @reversible_headers = Redhead::HeaderSet.parse("A-Header: one\nA-Header-Two: two")
-    @irreversible_headers = Redhead::HeaderSet.parse("a_header: one\na_header_two: two")
+    @simple_headers = Redhead::HeaderSet.parse("A-Header: one\nA-Header-Two: two")
   end
     
   context "as a class" do
@@ -24,18 +21,6 @@ describe Redhead::HeaderSet do
         Redhead::HeaderSet.parse(@full_header_set_string).should == parsed_header_set
       end
     end
-    
-    context "with a block" do
-      it "uses the given block as to_key" do
-        Redhead::HeaderSet.parse(@full_header_set_string) { :foo }.each { |h| h.key.should == :foo }
-      end
-      
-      it "does not set to_key on each parsed header object in the set" do
-        # note: Proc#== bug!
-        to_key =  proc { :foo }
-        Redhead::HeaderSet.parse(@full_header_set_string, &to_key).each { |header| header.to_key.should_not == to_key }
-      end
-    end
   end
   
   it "is Enumerable and responds to #each" do
@@ -74,18 +59,6 @@ describe Redhead::HeaderSet do
         @header_set[:brand_new_key].should_not be_nil
         @header_set[:brand_new_key].value.should == new_value
       end
-      
-      it "calls #to_raw to create the value of #raw" do
-        @header_set.to_raw = proc { "WHOA!" }
-        @header_set[:brand_new_key] = "some value"
-        @header_set[:brand_new_key].raw.should == "WHOA!"
-      end
-      
-      it "sets new_header#to_raw to header_set#to_raw" do
-        @header_set.to_raw = proc { "Whoa!" }
-        @header_set[:brand_new_key] = "some value"
-        @header_set[:brand_new_key].to_raw.should == @header_set.to_raw
-      end
     end
   end
   
@@ -109,21 +82,6 @@ describe Redhead::HeaderSet do
       it "returns a Redhead::Header object" do
         @header_set.add(:brand_new_key, "some value").class.should == Redhead::Header
       end
-      
-      it "calls #to_raw to create the value of #raw" do
-        @header_set.add(:brand_new_key, "some value")
-        @header_set[:brand_new_key].raw.should == "Brand-New-Key"
-        
-        @header_set.to_raw = proc { "Nothing really" }
-        @header_set.add(:something_or_other, "something or other")
-        @header_set[:something_or_other].raw.should == "Nothing really"
-      end
-      
-      it "sets new_header#to_raw to header_set#to_raw" do
-        @header_set.to_raw = proc { "Whoa!" }
-        @header_set.add(:brand_new_key, "some value")
-        @header_set[:brand_new_key].to_raw.should == @header_set.to_raw
-      end
     end
     
     it "takes an optional third argument which sets the value of the raw header" do
@@ -131,7 +89,6 @@ describe Redhead::HeaderSet do
       @header_set[:foo].value.should == "bar"
       @header_set[:foo].key.should == :foo
       @header_set[:foo].raw.should == "BAZ!"
-      @header_set[:foo].raw!.should == "Foo"
     end
   end
   
@@ -199,11 +156,6 @@ describe Redhead::HeaderSet do
         @header_set.to_s(&new_to_raw).should == modified_full_header_set_string(&new_to_raw)
       end
       
-      it "does not leave the given block as #to_raw" do
-        @header_set.to_s { "test" + "test" }
-        @header_set.to_raw.should_not == proc { "test" + "test" }
-      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
@@ -212,9 +164,8 @@ describe Redhead::HeaderSet do
   
   describe "#to_s!" do
     context "without a block" do
-      it "calls to_s! on each header in the set, passing #to_raw as a block joining the results with newlines" do
-        @header_set.to_raw = proc { "Total foo bar" }
-        @header_set.to_s!.should == @headers.map { |header| "Total foo bar: #{header.value}" }.join("\n")
+      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
     
@@ -222,20 +173,6 @@ describe Redhead::HeaderSet 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
-      
-      it "does not leave the given block as #to_raw on existing headers" do
-        temp_to_raw = proc { "Total foo bar" }
-        @header_set.to_s!(&temp_to_raw)
-        @header_set.all? { |header| header.raw!.should_not == "Total foo bar" }
-      end
-      
-      it "does not leave the given block as #to_raw on the header set" do
-        temp_to_raw = proc { "Total foo bar" }
-        @header_set.to_s!(&temp_to_raw)
-        @header_set.to_raw.should_not == temp_to_raw
-        @header_set[:temp_foo_foo] = "what"
-        @header_set[:temp_foo_foo].raw!.should_not == "Total foo bar"
-      end
     end
   end
   
@@ -260,85 +197,4 @@ describe Redhead::HeaderSet do
       one.any? { |a| two.find { |b| a == b } }.should be_true
     end
   end
-  
-  describe "#reversible?" do
-    it "returns true if each header in the set is reversible, otherwise false" do
-      @reversible_headers.reversible?.should == @reversible_headers.all? { |header| header.reversible? }
-      @irreversible_headers.reversible?.should == @irreversible_headers.all? { |header| header.reversible? }
-      
-      @reversible_headers.reversible?.should be_true
-      @irreversible_headers.reversible?.should be_false
-      
-      @reversible_headers.to_raw = proc { "" }
-      @reversible_headers.reversible?.should_not be_true # contained headers get caught up in the change
-      
-      # example from the readme:
-      
-      string = "A-Header-Name: a header value\n\nContent."
-      
-      str = Redhead::String.new(string) do |name|
-        name.gsub(/-/, "").upcase.to_sym
-      end
-      
-      str.headers.reversible?.should be_false
-      
-      str = Redhead::String.new(string) do |name|
-        name.split(/-/).map { |e| e.upcase }.join("zzz").to_sym
-      end
-      
-      str.headers.reversible?.should be_false
-      
-      str.headers.to_raw = lambda do |name|
-        name.to_s.split(/zzz/).map { |e| e.capitalize }.join("-")
-      end
-      
-      str.headers.reversible?.should be_true
-    end
-  end
-  
-  describe "#to_raw" do
-    it "defaults to Redhead.to_raw" do
-      # note: Proc#== bug!
-      @header_set.to_raw.should == @default_to_raw
-    end
-  end
-  
-  describe "#to_raw=" do
-    it "sets a new block to be used as to_raw" do
-      # note: Proc#== bug!
-      new_to_raw = proc { "" + "" }
-      @header_set.to_raw = new_to_raw
-      @header_set.to_raw.should_not == @default_to_raw
-      @header_set.to_raw.should == new_to_raw
-    end
-    
-    it "sets to_raw, for each header in the set" do
-      new_to_raw = proc { "" + "" }
-      @header_set.to_raw = new_to_raw
-      @header_set.each { |header| header.to_raw.should == new_to_raw }
-    end
-  end
-  
-  describe "#to_key" do
-    it "defaults to Redhead.to_key" do
-      # note: Proc#== bug!
-      @header_set.to_key.should == @default_to_key
-    end
-  end
-  
-  describe "#to_key=" do
-    it "sets a new block to be used as to_key" do
-      # note: Proc#== bug!
-      new_to_key = proc { "" + "" }
-      @header_set.to_key = new_to_key
-      @header_set.to_key.should_not == @default_to_key
-      @header_set.to_key.should == new_to_key
-    end
-    
-    it "sets to_key, for each header in the set" do
-      new_to_key = proc { "" + "" }
-      @header_set.to_key = new_to_key
-      @header_set.each { |header| header.to_key.should == new_to_key }
-    end
-  end
 end

data/test/header_spec.rb

@@ -14,9 +14,6 @@ describe Redhead::Header do
     
     @different_header_raw_name = "An original HEADER name"
     @header_different_name = Redhead::Header.new(:a_header_name, "An original HEADER name", "something here")
-    
-    @default_to_raw = Redhead.to_raw
-    @default_to_key = Redhead.to_key
   end
   
   context "as a class" do
@@ -50,25 +47,6 @@ describe Redhead::Header do
           Redhead::Header.parse("#{@header_raw_name}#{before}:#{after}#{@header_value}").key.should == @header_name
         end
       end
-      
-      context "with a given block" do
-        it "uses the given block as to_key" do
-          Redhead::Header.parse(@full_header_string) { :foo }.key.should == :foo
-        end
-        
-        # do not set to_key to the given block so that using parse with a block does not prevent any dynamic
-        # calls up the chain to work out what to_raw should be for each object. i.e., Header#to_key should default
-        # to Redhead.to_key, but since each header doesn't know which headerset it's in, HeaderSet needs to pass down
-        # a block to each Header object. if the Header object set the block as to_key, there'd be problems.
-        # 
-        # Similarly, Redhead::String.parse(..., &blk) should not set Header#to_key because then there'd never be any
-        # calls up the hierarchy, since an individual Header's @to_key would exist already.
-        it "sets to_key to the given block" do
-          # note: Proc#== bug!
-          to_key = proc { :foo }
-          Redhead::Header.parse(@full_header_string, &to_key).to_key.should_not == to_key
-        end
-      end
     end
   end
   
@@ -78,51 +56,12 @@ describe Redhead::Header do
     end
   end
   
-  describe "#key!" do
-    it "uses #to_key to convert #raw to a header key" do
-      @header.to_key = proc { "test" }
-      @header.key!.should == "test"
-      
-      @header.to_key = proc { |x| x.upcase.reverse.gsub("-", "_").to_sym }
-      @header.key!.should == @header_raw_name.upcase.reverse.gsub("-", "_").to_sym
-    end
-    
-    it "does not change #key after being called" do
-      @header.to_key = proc { "test" }
-      @header.key.should == @header_name
-      @header.key!.should == "test"
-      @header.key.should_not == "test"
-      @header.key.should == @header_name
-    end
-  end
-  
   describe "#raw" do
     it "returns the raw header name stored at creation time" do
       @header.raw.should == @header_raw_name
-      @header.to_raw = proc { "" }
-      @header.raw!.should == ""
-      @header.raw.should == @header_raw_name
     end
   end
-  
-  describe "#raw!" do
-    it "uses #to_raw to convert #key to a raw header, ignoring the value of #raw" do
-      @header.to_raw = proc { "test" }
-      @header.raw!.should == "test"
-      
-      @header.to_raw = proc { |x| x.to_s.upcase.reverse }
-      @header.raw!.should == @header_name.to_s.upcase.reverse
-    end
     
-    it "does not change #raw after being called" do
-      @header.to_raw = proc { "test" }
-      @header.raw.should == @header_raw_name
-      @header.raw!.should == "test"
-      @header.raw.should_not == "test"
-      @header.raw.should == @header_raw_name
-    end
-  end
-  
   describe "#value" do
     it "returns the header value" do
       @header.value.should == @header_value
@@ -145,12 +84,6 @@ describe Redhead::Header 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
-      
-      it "does not set a new value for #to_raw" do
-        @header.to_s { "test" }
-        @header.to_s.should_not == "test#{@separator} #{@header_value}"
-        @header.to_s.should == @full_header_string
-      end
     end
     
     it "takes an optional argument which specifies the raw header to use, without side-effects" do
@@ -182,77 +115,17 @@ describe Redhead::Header do
     end
   end
   
-  describe "#reversible?" do
-    it "returns true for the defaults" do
-      @header.reversible?.should be_true
-    end
-    
-    it "returns true if self.to_raw[self.key!] == self.raw, i.e., if we can't recover the current raw header name via to_key(to_raw(current_raw_header_name))" do
-      @header.to_raw[@header.key!].should == @header_raw_name
-      @header.reversible?.should be_true # by default
-      
-      @header.to_raw = proc { |x| "1#{x}" }
-      @header.to_key = proc { |x| "2#{x}" }
-      @header.to_raw[@header.key!].should_not == @header_raw_name
-      @header.reversible?.should be_false # :key does not equal 2Key1Key
-      
-      @header.to_raw = proc { |x| x.to_s.reverse }
-      @header.to_key = proc { |x| x.reverse.to_sym }
-      @header.to_raw[@header.key!].should == @header_raw_name
-      @header.reversible?.should be_true
-    end
-  end
-  
-  describe "#to_raw" do
-    it "returns Redhead.to_raw by default" do
-      # note: Proc#== bug!
-      @header.to_raw.should == @default_to_raw
-    end
-  end
-    
-  describe "#to_key" do
-    it "returns Redhead.to_key by default" do
-      # note: Proc#== bug!
-      @header.to_key.should == @default_to_key
-    end
-  end
-  
-  describe "#to_raw=(blk)" do
-    it "sets to_raw to blk" do
-      new_block = proc { }
-      @header.to_raw.should_not == new_block
-      @header.to_raw = new_block
-      @header.to_raw.should == new_block
-    end
-  end
-  
-  describe "#to_key=(blk)" do
-    it "sets to_key to blk" do
-      new_block = proc { "" + "" }
-      @header.to_key.should_not == new_block
-      @header.to_key = new_block
-      @header.to_key.should == new_block
-    end
-  end
-  
   describe "#to_s!" do
-    # TODO: this test doesn't do what it should. know what @header.raw! is going to be and use it in this test
-    # instead of relying on @header.raw! in this test itself. better go through all tests and double-check this.
-    it "returns <raw!><separator> <value>" do
-      @header.to_s!.should == "#{@header.raw!}#{@separator} #{@header_value}"
+    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 as though it were #to_raw" 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
-      
-      it "does not leave to_raw as the given block" do
-        @header.to_s! { "testing" }
-        @header.to_raw.should_not == proc { "testing" }
-        @header.to_raw[:random].should_not == "testing"
-      end
     end
     
     it "takes an optional argument specifying the raw header name to use, without side-effects" do

data/test/redhead_string_spec.rb

@@ -14,26 +14,6 @@ describe Redhead::String do
         Redhead::String[@string].should == Redhead::String.new(@string)
       end
     end
-    
-    describe "self.new" do
-      context "with a given block:" do
-        it "uses the given block as to_key" do
-          Redhead::String.new(@string) { :foo }.headers.first.key.should == :foo
-        end
-        
-        it "sets the given block as the HeaderSet's to_key" do
-          # note: Proc#== bug!
-          blk = proc { :foo }
-          Redhead::String.new(@string, &blk).headers.to_key.should == blk
-        end
-        
-        it "sets each individual header's to_key to the given block" do
-          # note: Proc#== bug!
-          blk = proc { :foo }
-          Redhead::String.new(@string, &blk).headers.each { |header| header.to_key.should == blk }
-        end
-      end
-    end
   end
   
   context "before any modifications:" do

metadata

@@ -1,57 +1,63 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: redhead
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.5
   prerelease: 
-  version: 0.0.4
 platform: ruby
-authors: 
+authors:
 - Adam Prescott
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-19 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    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
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: String header metadata.
-email: 
+email:
 - adam@aprescott.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- lib/redhead/header_set.rb
+files:
+- lib/redhead.rb
 - lib/redhead/redhead_string.rb
 - lib/redhead/header.rb
-- lib/redhead.rb
-- test/header_set_spec.rb
-- test/redhead_spec.rb
+- lib/redhead/header_set.rb
 - test/test_helper.rb
+- test/redhead_spec.rb
 - test/redhead_string_spec.rb
+- test/header_set_spec.rb
 - test/header_spec.rb
 - redhead.gemspec
 - .gemtest
@@ -61,34 +67,31 @@ files:
 - README.md
 homepage: https://github.com/aprescott/redhead
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.2
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: String header metadata.
-test_files: 
-- test/header_set_spec.rb
-- test/redhead_spec.rb
+test_files:
 - test/test_helper.rb
+- test/redhead_spec.rb
 - test/redhead_string_spec.rb
+- test/header_set_spec.rb
 - test/header_spec.rb