redhead 0.0.1

data/test/header_spec.rb

@@ -0,0 +1,270 @@
+require "test_helper"
+
+describe Redhead::Header do
+  before(:each) do
+    @header_name = :a_header_name
+    @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")
+    
+    @default_to_raw = Redhead.to_raw
+    @default_to_key = Redhead.to_key
+  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)
+        parsed_header.class.should == Redhead::Header
+        parsed_header.should_not be_nil
+        parsed_header.key.should == @header_name
+        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
+      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
+  
+  describe "#key" do
+    it "returns the symbolic header name" do
+      @header.key.should == :a_header_name
+    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
+    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
+      
+      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
+      @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 "#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}"
+    end
+    
+    context "with a block argument" do
+      it "uses the given block as though it were #to_raw" 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
+      @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
+end

data/test/redhead_spec.rb

@@ -0,0 +1 @@
+require "test_helper"

data/test/redhead_string_spec.rb

@@ -0,0 +1,114 @@
+require "test_helper"
+
+describe Redhead::String do
+  before(:each) do
+    @string_content = "Lorem ipsum dolor sit amet."
+    @string = "A-Header-Value: value\n\n#{@string_content}"
+    @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
+        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
+    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
+    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
+      @rh_string.headers!(:a_header_value => {}).to_a.length.should == 1
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1 @@
+require "redhead"

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: redhead
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Adam Prescott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-04-22 00:00:00.000000000 +01:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &73758240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *73758240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &73758020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *73758020
+description: String header metadata.
+email:
+- adam@aprescott.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/redhead/header.rb
+- lib/redhead/redhead_string.rb
+- lib/redhead/header_set.rb
+- lib/redhead.rb
+- test/redhead_spec.rb
+- test/redhead_string_spec.rb
+- test/test_helper.rb
+- test/header_set_spec.rb
+- test/header_spec.rb
+- LICENSE
+- Gemfile
+- rakefile
+- README.md
+has_rdoc: true
+homepage: https://github.com/aprescott/redhead
+licenses: []
+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.6.2
+signing_key: 
+specification_version: 3
+summary: String header metadata.
+test_files:
+- test/redhead_spec.rb
+- test/redhead_string_spec.rb
+- test/test_helper.rb
+- test/header_set_spec.rb
+- test/header_spec.rb