earl 0.3.0 → 1.0.0

data/spec/earl/earl_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Earl do
-  subject { Earl }
-
-  it { should respond_to( :URL ) }
-  describe '#URL' do
-    subject { Earl::URL( 'http://foo.com' ) }
-    it { should be_kind_of( Earl::URLEntity ) }
-  end
-
-  it { should respond_to( :Email ) }
-  describe '#Email' do
-    subject { Earl::Email( 'foo@bar.com' ) }
-    it { should be_kind_of( Earl::EmailEntity ) }
-  end
-end

data/spec/earl/email_entity_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Earl::EmailEntity do
-  subject { Earl::EmailEntity }
-
-  # username
-
-  it { should produce( 'foo@bar.com' ).from( 'baz@bar.com' ).when_given( :username => 'foo' ) }
-  it 'must have a username when parsing an email' do
-    expect { Earl::Email( '@bar.com' ) }.to raise_error( Earl::InvalidURLError )
-  end
-  it 'wont let you set the username to nil' do
-    expect { Earl::Email( 'foo@bar.com' ).username = nil }.to raise_error( Earl::InvalidURLError )
-  end
-
-  # domain
-
-  it { should produce( 'foo@bar.com' ).from( 'foo@baz.com' ).when_given( :domain => 'bar.com' ) }
-  it 'must have a domain when parsing an email' do
-    expect { Earl::Email( 'foo@' ) }.to raise_error( Earl::InvalidURLError )
-  end
-  it 'wont let you set the domain to nil' do
-    expect { Earl::Email( 'foo@bar.com' ).domain = nil }.to raise_error( Earl::InvalidURLError )
-  end
-
-  # contact
-
-  it { should produce( 'foo@bar.com <Woot!>' ).from( 'foo@bar.com <Foo Bar>' ).when_given( :contact => 'Woot!' ) }
-  it { should produce( 'foo@bar.com <Woot!>' ).from( 'foo@bar.com' ).when_given( :contact => 'Woot!' ) }
-  it { should produce( 'foo@bar.com' ).from( 'foo@bar.com <Woot!>' ).when_given( :contact => nil ) }
-end

data/spec/earl/email_parser_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Earl do
-  let( :parser    ){ Earl::EmailParser.new    }
-  let( :assembler ){ Earl::EmailAssembler.new }
-
-  [
-    [ 'foo@bar.com', {
-      :username => 'foo',
-      :domain => 'bar.com'
-    } ],
-    [ 'foo.bar@baz.com', {
-      :username => 'foo.bar',
-      :domain => 'baz.com'
-    } ],
-    [ 'foo.bar@baz.com <Foo Bar>', {
-      :username => 'foo.bar',
-      :domain => 'baz.com',
-      :contact => 'Foo Bar'
-    } ]
-  ].each do |string, parts|
-    it "should correctly parse the email parts for #{string}" do
-      parser.parse( string ).resolve.should eql( parts )
-    end
-    it "should correctly assemble the email parts to #{string}" do
-      assembler.assemble( parts ).should eql( string )
-    end
-  end
-end

data/spec/earl/entity_base_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Earl::EntityBase do
-
-  describe 'the entity dsl' do
-    subject { Class.new( Earl::EntityBase ) do
-      def initialize; end # so we don't invoke our parser
-
-      part_accessor :foo, :bar
-
-      part_accessor :baz do |value|
-        raise EarlError if value == 'woot!'
-      end
-    end.new }
-
-    it { should be_kind_of( Earl::HashInquirer ) }
-
-    [ :foo, :foo=, :bar, :bar=, :baz, :baz= ].each do |method|
-      it { should respond_to( method ) }
-    end
-
-    it 'should define setters/getters' do
-      subject.foo = 'foo!'
-      subject.foo.should eq( 'foo!' )
-      subject[ :foo ].should eq( 'foo!' )
-      subject.foo?.should eq( true )
-    end
-
-    it 'should call the block if given' do
-      expect { subject.baz = 'baz!'  }.not_to raise_error
-      expect { subject.baz = 'woot!' }.to raise_error
-    end
-
-    it 'should return a string inquirer for string attributes' do
-      subject.foo = 'sup'
-      subject.foo.kind_of?( Earl::StringInquirer ).should == true
-    end
-  end
-end

data/spec/earl/hash_inquirer_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Earl::HashInquirer do
-  subject { Earl::HashInquirer.new :foo => 'bar', :baz => 123, :woo => false }
-
-  it { should be_a( Hash ) }
-  it { should eql( :foo => 'bar', :baz => 123, :woo => false ) }
-
-  describe 'string keys' do
-    its( :foo? ){ should be_true }
-  end
-
-  describe 'numeric keys' do
-    its( :baz? ){ should be_true }
-  end
-
-  describe 'boolean keys' do
-    its( :woo? ){ should be_true }
-  end
-
-  describe 'nonexistant keys' do
-    its( :sup? ){ should be_false }
-  end
-end

data/spec/earl/string_inquirer_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Earl::StringInquirer do
-  subject { Earl::StringInquirer.new 'foo' }
-
-  it { should be_a( String ) }
-  its( :foo? ){ should be_true }
-  its( :bar? ){ should be_false }
-end

data/spec/earl/url_entity_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Earl::URLEntity do
-  subject { Earl::URLEntity }
-
-  # scheme
-
-  it { should produce( 'https://foo.com' ).from( 'http://foo.com' ).when_given( :scheme => 'https' ) }
-  it { should produce( 'http://foo.com' ).from( 'foo.com' ).when_given( :scheme => 'http' ) }
-  it { should produce( 'foo.com' ).from( 'http://foo.com' ).when_given( :scheme => nil ) }
-
-  # subdomain
-
-  it { should produce( 'baz.bar.com' ).from( 'foo.bar.com' ).when_given( :subdomain => 'baz' ) }
-  it { should produce( 'bar.foo.com' ).from( 'foo.com' ).when_given( :subdomain => 'bar' ) }
-  it { should produce( 'bar.com' ).from( 'foo.bar.com' ).when_given( :subdomain => nil ) }
-
-  # port
-
-  it { should produce( 'foo.com:4567' ).from( 'foo.com:80' ).when_given( :port => 4567 ) }
-  it { should produce( 'foo.com:4567' ).from( 'foo.com' ).when_given( :port => 4567 ) }
-  it { should produce( 'foo.com' ).from( 'foo.com:4567' ).when_given( :port => nil ) }
-
-  # path
-
-  it { should produce( 'foo.com/bar' ).from( 'foo.com/baz' ).when_given( :path => 'bar' ) }
-  it { should produce( 'foo.com/bar' ).from( 'foo.com' ).when_given( :path => 'bar' ) }
-  it { should produce( 'foo.com' ).from( 'foo.com/bar' ).when_given( :path => nil ) }
-
-  # search
-
-  it { should produce( 'foo.com?bar=asdf' ).from( 'foo.com?bar=baz' ).when_given( :search => 'bar=asdf' ) }
-  it { should produce( 'foo.com?bar=asdf' ).from( 'foo.com' ).when_given( :search => 'bar=asdf' ) }
-  it { should produce( 'foo.com' ).from( 'foo.com?bar=asdf' ).when_given( :search => nil ) }
-
-  # host
-
-  it { should produce( 'www.foo.edu' ).from( 'www.foo.com' ).when_given( :host => 'foo.edu' ) }
-  it 'must have a host when parsing a url' do
-    expect { Earl::URL( 'http://' ) }.to raise_error( Earl::InvalidURLError )
-  end
-  it 'wont let you set the host to nil' do
-    expect { Earl::URL( 'www.foo.com' ).host = nil }.to raise_error( Earl::InvalidURLError )
-  end
-end

data/spec/earl/url_parser_spec.rb

@@ -1,189 +0,0 @@
-require 'spec_helper'
-
-describe Earl do
-  let( :parser    ){ Earl::URLParser.new    }
-  let( :assembler ){ Earl::URLAssembler.new }
-
-  [
-    [ 'localhost', {
-      :host => 'localhost'
-    } ],
-    [ 'foo.com', {
-      :host => 'foo.com'
-    } ],
-
-    [ 'foo.edu', {
-      :host => 'foo.edu'
-    } ],
-
-    [ 'foo2bar.biz', {
-      :host => 'foo2bar.biz'
-    } ],
-
-    [ 'www.foo.com', {
-      :host => 'foo.com',
-      :subdomain => 'www'
-    } ],
-
-    [ 'http://localhost', {
-      :scheme => 'http',
-      :host => 'localhost'
-    } ],
-
-    [ 'http://foo.com', {
-      :scheme => 'http',
-      :host => 'foo.com'
-    } ],
-
-    [ 'http://www.foo.com', {
-      :scheme => 'http',
-      :host => 'foo.com',
-      :subdomain => 'www'
-    } ],
-
-    [ 'localhost:3000', {
-      :host => 'localhost',
-      :port => '3000'
-    } ],
-
-    [ 'http://localhost:3000', {
-      :scheme => 'http',
-      :host => 'localhost',
-      :port => '3000'
-    } ],
-
-    [ 'www.foo.com:8080', {
-      :subdomain => 'www',
-      :host => 'foo.com',
-      :port => '8080'
-    } ],
-
-    [ 'http://www.foo.com:8080', {
-      :scheme => 'http',
-      :subdomain => 'www',
-      :host => 'foo.com',
-      :port => '8080'
-    } ],
-
-    [ 'localhost/bar', {
-      :host => 'localhost',
-      :path => 'bar'
-    } ],
-
-    [ 'foo.com/bar', {
-      :host => 'foo.com',
-      :path => 'bar'
-    } ],
-
-    [ 'www.foo.com/bar', {
-      :subdomain => 'www',
-      :host => 'foo.com',
-      :path => 'bar'
-    } ],
-
-    [ 'http://localhost/bar', {
-      :scheme => 'http',
-      :host => 'localhost',
-      :path => 'bar'
-    } ],
-
-    [ 'http://foo.com/bar', {
-      :scheme => 'http',
-      :host => 'foo.com',
-      :path => 'bar'
-    } ],
-
-    [ 'http://www.foo.com/bar', {
-      :scheme => 'http',
-      :subdomain => 'www',
-      :host => 'foo.com',
-      :path => 'bar'
-    } ],
-
-    [ 'localhost?baz=woo', {
-      :host => 'localhost',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'localhost:3000?baz=woo', {
-      :host => 'localhost',
-      :port => '3000',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'localhost:3000/bar?baz=woo', {
-      :host => 'localhost',
-      :port => '3000',
-      :path => 'bar',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'foo.com?baz=woo', {
-      :host => 'foo.com',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'www.foo.com?baz=woo', {
-      :subdomain => 'www',
-      :host => 'foo.com',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'http://foo.com?baz=woo', {
-      :scheme => 'http',
-      :host => 'foo.com',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'http://www.foo.com?baz=woo', {
-      :scheme => 'http',
-      :subdomain => 'www',
-      :host => 'foo.com',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'http://foo.com/bar?baz=woo', {
-      :scheme => 'http',
-      :host => 'foo.com',
-      :path => 'bar',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'http://www.foo.com/bar?baz=woot', {
-      :scheme => 'http',
-      :subdomain => 'www',
-      :host => 'foo.com',
-      :path => 'bar',
-      :search => 'baz=woot'
-    } ],
-
-    [ 'http://localhost:3000?baz=woo', {
-      :scheme => 'http',
-      :host => 'localhost',
-      :port => '3000',
-      :search => 'baz=woo'
-    } ],
-
-    [ 'http://foo.com:8080?baz=woooo', {
-      :scheme => 'http',
-      :host => 'foo.com',
-      :port => '8080',
-      :search => 'baz=woooo'
-    } ],
-
-    [ 'http://foo.com:8080/bar?baz=woo', {
-      :scheme => 'http',
-      :host => 'foo.com',
-      :port => '8080',
-      :path => 'bar',
-      :search => 'baz=woo'
-    } ]
-  ].each do |string, parts|
-    it "should correctly parse the url parts for #{string}" do
-      parser.parse( string ).resolve.should eql( parts )
-    end
-    it "should correctly assemble the url parts to #{string}" do
-      assembler.assemble( parts ).should eql( string )
-    end
-  end
-end