redhead 0.0.6 → 0.0.8

data/lib/redhead/header_set.rb

@@ -22,6 +22,11 @@ module Redhead
     def each
       @headers.each { |h| yield h }
     end
+
+    # Returns the number of headers in the set.
+    def size
+      @headers.size
+    end
     
     # Returns true if the set of headers is empty.
     def empty?
@@ -86,6 +91,24 @@ module Redhead
       blk = block || TO_RAW
       @headers.map { |header| header.to_s!(&blk) }.join("\n")
     end
+
+    # Returns a hash from the headers in the set, where keys are
+    # formed from #key and values from #value for each header.
+    #
+    #     rh_string = Redhead::String["foo: bar\nbaz: baaaaz\n\nstring"]
+    #     rh_string.headers.to_h
+    #     
+    #     # A Hash instance:
+    #     #=> { :foo => "bar", :baz => "baaaaz" }
+    def to_h
+      h = {}
+      each do |header|
+        h[header.key] = header.value
+      end
+      h
+    end
+
+    alias_method :to_hash, :to_h
         
     def inspect
       "{ #{@headers.map { |header| header.inspect }.join(", ")} }"

data/lib/redhead/redhead_string.rb

@@ -7,15 +7,53 @@ module Redhead
     class << self
       alias_method :[], :new
     end
+
+    # Checks if the input string has header lines at the start of its content,
+    # and returns true or false depending on the value.
+    def self.has_headers?(string)
+      return false if string.strip.empty?
+
+      # check if the string itself is entirely headers
+      has_headers_no_content = string.strip.lines.all? do |l|
+        l =~ HEADER_NAME_VALUE_SEPARATOR_PATTERN
+      end
+
+      return true if has_headers_no_content
+
+      # split based on the headers separator and see if
+      # all lines before the separator look like headers.
+
+      string =~ HEADERS_SEPARATOR_PATTERN
+      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)
-      string =~ HEADERS_SEPARATOR_PATTERN
-      @string = $'
-      super(@string)
-      
-      @headers = Redhead::HeaderSet.parse($`)
+      if self.class.has_headers?(string)
+        # if there is a separator between header content and body content
+        if string =~ HEADERS_SEPARATOR_PATTERN
+          @string = $'
+          header_content = $`
+          super(@string)
+
+          @headers = Redhead::HeaderSet.parse(header_content)
+        else
+          # 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)
+        end
+      else
+        @string = string
+        super(@string)
+        @headers = Redhead::HeaderSet.new([])
+      end
     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.6"
+  s.version      = "0.0.8"
   s.authors      = ["Adam Prescott"]
   s.email        = ["adam@aprescott.com"]
   s.homepage     = "https://github.com/aprescott/redhead"

data/test/header_set_spec.rb

@@ -113,6 +113,35 @@ describe Redhead::HeaderSet do
       @header_set.delete(:brand_new_key).should be_nil
     end
   end
+
+  # to_hash is an alias for to_h
+
+  [:to_h, :to_hash].each do |meth|
+    describe "##{meth}" do
+      it "returns a Hash instance containing symbol keys and header values" do
+        @header_set.public_send(meth).should == Hash[@headers.map { |header| [header.key, header.value] }]
+      end
+
+      it "contains only keys in the original header" do
+        @header_set.public_send(meth).keys.should == @headers.map { |header| header.key }
+      end
+
+      it "contains correct corresponding values for each key" do
+        h = @header_set.public_send(meth)
+        h.keys.size.should == @header_set.size
+
+        h.each do |key, value|
+          @header_set[key].value.should == value
+        end
+      end
+    end
+  end
+
+  describe "#size" do
+    it "is the number of headers in the set" 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

data/test/header_spec.rb

@@ -47,6 +47,12 @@ describe Redhead::Header do
           Redhead::Header.parse("#{@header_raw_name}#{before}:#{after}#{@header_value}").key.should == @header_name
         end
       end
+
+      it "handles values with a separator" do
+        header = Redhead::Header.parse("created: 20:30")
+        header.key.should == :created
+        header.value.should == "20:30"
+      end
     end
   end
   

data/test/redhead_string_spec.rb

@@ -22,6 +22,41 @@ describe Redhead::String do
           subject.headers[:bar].value.should == "2"
         end
       end
+
+      it "can handle strings with no headers" do
+        expect { Redhead::String[""] }.to_not raise_error
+        expect { Redhead::String["some content\n\nwith no headers"] }.to_not raise_error
+      end
+
+      it "can handle headers that have the header name-value separator in the value" do
+        test_cases = ["foo: bar:baz", "foo: bar:baz\n", "foo: bar:baz\n\ncontent"]
+
+        test_cases.each do |t|
+          s = Redhead::String[t]
+          s.headers.size.should == 1
+          h = s.headers[:foo]
+          h.should_not be_nil
+          h.value.should == "bar:baz"
+        end
+      end
+    end
+
+    describe ".has_headers?" do
+      it "is true if the string has valid headers" do
+        tests = {
+          "foo: bar\n\ncontent" => true,
+          "foo: bar" => true,
+          "" => false,
+          "some content\n\nhere" => false,
+          "foo: bar:baz" => true,
+          "foo: bar:baz\n" => true,
+          "foo: bar:baz\n\ncontent" => true
+        }
+
+        tests.each do |input, value|
+          Redhead::String.has_headers?(input).should == value
+        end
+      end
     end
   end
   
@@ -45,6 +80,11 @@ describe Redhead::String do
     it "returns a Redhead::HeaderSet object" do
       @rh_string.headers.is_a?(Redhead::HeaderSet).should be_true
     end
+
+    it "works for an empty string, too" do
+      s = Redhead::String[""]
+      s.headers.size.should == 0
+    end
   end
   
   it "provides regular String methods" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redhead
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-13 00:00:00.000000000 Z
+date: 2012-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake