earl 0.3.0 → 2.0.0

data/.rvmrc

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-
-# This is an RVM Project .rvmrc file, used to automatically load the ruby
-# development environment upon cd'ing into the directory
-
-# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
-# Only full ruby name is supported here, for short names use:
-#     echo "rvm use 1.9.3" > .rvmrc
-environment_id="ruby-1.9.3-p125@earl"
-
-# Uncomment the following lines if you want to verify rvm version per project
-# rvmrc_rvm_version="1.10.3" # 1.10.1 seams as a safe start
-# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
-#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
-#   return 1
-# }
-
-# First we attempt to load the desired environment directly from the environment
-# file. This is very fast and efficient compared to running through the entire
-# CLI and selector. If you want feedback on which environment was used then
-# insert the word 'use' after --create as this triggers verbose mode.
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
-  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
-then
-  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
-    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
-else
-  # If the environment file has not yet been created, use the RVM CLI to select.
-  rvm --create  "$environment_id" || {
-    echo "Failed to create RVM environment '${environment_id}'."
-    return 1
-  }
-fi
-
-# If you use bundler, this might be useful to you:
-# if [[ -s Gemfile ]] && {
-#   ! builtin command -v bundle >/dev/null ||
-#   builtin command -v bundle | grep $rvm_path/bin/bundle >/dev/null
-# }
-# then
-#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
-#   gem install bundler
-# fi
-# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
-# then
-#   bundle install | grep -vE '^Using|Your bundle is complete'
-# fi

data/lib/earl/email_assembler.rb

@@ -1,11 +0,0 @@
-module Earl
-  class EmailAssembler
-
-    def assemble( parts={} )
-      ''.tap do |email|
-        email << [ parts[ :username ], parts[ :domain ] ].join( '@' )
-        email << " <#{parts[ :contact ]}>" if parts[ :contact ]
-      end
-    end
-  end
-end

data/lib/earl/email_entity.rb

@@ -1,27 +0,0 @@
-require 'treetop'
-require 'earl/email_parser'
-
-module Earl
-  class EmailEntity < EntityBase
-
-    part_accessor :contact
-
-    part_accessor :username do |value|
-      raise InvalidURLError if value.nil?
-    end
-
-    part_accessor :domain do |value|
-      raise InvalidURLError if value.nil?
-    end
-
-    protected
-
-    def parser
-      @parser ||= EmailParser.new
-    end
-
-    def assembler
-      @assembler ||= EmailAssembler.new
-    end
-  end
-end

data/lib/earl/email_parser.tt

@@ -1,58 +0,0 @@
-module Earl
-  grammar Email
-
-    rule program
-      whitespace v:( email ) whitespace {
-        def resolve
-          { }.merge v.resolve
-        end
-      }
-    end
-
-    rule whitespace
-      [\s]*
-    end
-
-    rule email
-      username '@' domain whitespace contact {
-        def resolve
-          username.resolve.merge domain.resolve.merge contact.resolve
-        end
-      }
-      /
-      username '@' domain {
-        def resolve
-          username.resolve.merge domain.resolve
-        end
-      }
-    end
-
-    rule username
-      [^@\s]+ {
-        def resolve
-          { :username => text_value }
-        end
-      }
-    end
-
-    rule domain
-      characters '.' characters {
-        def resolve
-          { :domain => text_value }
-        end
-      }
-    end
-
-    rule contact
-      '<' [^>]+ '>' {
-        def resolve
-          { :contact => elements[ 1 ].text_value }
-        end
-      }
-    end
-
-    rule characters
-      [a-zA-Z0-9]+
-    end
-  end
-end

data/lib/earl/entity_base.rb

@@ -1,37 +0,0 @@
-module Earl
-  class EntityBase < HashInquirer
-    def initialize( source )
-      super parser.parse( source ).resolve rescue raise InvalidURLError
-    end
-
-    def to_s
-      assembler.assemble self
-    end
-
-    def self.part_accessor( *parts, &block )
-      parts.each do |part|
-        define_method part do
-          if self[ part ].is_a? String
-            StringInquirer.new self[ part ]
-          else
-            self[ part ]
-          end
-        end
-        define_method :"#{part}=" do |value|
-          self[ part ] = value
-          yield value if block_given?
-        end
-      end
-    end
-
-    protected
-
-    def parser
-      raise SubclassError
-    end
-
-    def assembler
-      raise SubclassError
-    end
-  end
-end

data/lib/earl/hash_inquirer.rb

@@ -1,16 +0,0 @@
-module Earl
-  class HashInquirer < ::Hash
-    def initialize( hash, &block )
-      merge! hash
-      super block
-    end
-
-    def method_missing( meth, *args, &block )
-      if meth.to_s[ -1 ] == '?'
-        self.has_key? meth.to_s[ 0..-2 ].to_sym
-      else
-        super
-      end
-    end
-  end
-end

data/lib/earl/string_inquirer.rb

@@ -1,11 +0,0 @@
-module Earl
-  class StringInquirer < ::String
-    def method_missing( meth, *args, &block )
-      if meth.to_s[ -1 ] == '?'
-        meth.to_s[ 0..-2 ] == to_s
-      else
-        super
-      end
-    end
-  end
-end

data/lib/earl/url_assembler.rb

@@ -1,15 +0,0 @@
-module Earl
-  class URLAssembler
-
-    def assemble( parts={} )
-      ''.tap do |url|
-        url << ( parts[ :scheme ] + '://'  ) if parts[ :scheme ]
-        url << ( parts[ :subdomain ] + '.' ) if parts[ :subdomain ]
-        url << ( parts[ :host ]            ) if parts[ :host ]
-        url << ( ':' + parts[ :port ].to_s ) if parts[ :port ]
-        url << ( '/' + parts[ :path ]      ) if parts[ :path ]
-        url << ( '?' + parts[ :search ]    ) if parts[ :search ]
-      end
-    end
-  end
-end

data/lib/earl/url_entity.rb

@@ -1,23 +0,0 @@
-require 'treetop'
-require 'earl/url_parser'
-
-module Earl
-  class URLEntity < EntityBase
-
-    part_accessor :scheme, :subdomain, :port, :path, :search
-
-    part_accessor :host do |value|
-      raise InvalidURLError if value.nil?
-    end
-
-    protected
-
-    def parser
-      @parser ||= URLParser.new
-    end
-
-    def assembler
-      @assembler ||= URLAssembler.new
-    end
-  end
-end

data/lib/earl/url_parser.tt

@@ -1,163 +0,0 @@
-module Earl
-  grammar URL
-
-    rule program
-      whitespace v:( url ) whitespace {
-        def resolve
-          { }.merge v.resolve
-        end
-      }
-    end
-
-    rule whitespace
-      [\s]*
-    end
-
-    rule url
-      scheme host port path search {
-        def resolve
-          scheme.resolve.merge port.resolve.merge host.resolve.merge path.resolve.merge search.resolve
-        end
-      }
-      /
-      scheme host port path {
-        def resolve
-          scheme.resolve.merge port.resolve.merge host.resolve.merge path.resolve
-        end
-      }
-      /
-      scheme host port search {
-        def resolve
-          scheme.resolve.merge port.resolve.merge host.resolve.merge search.resolve
-        end
-      }
-      /
-      scheme host port {
-        def resolve
-          scheme.resolve.merge port.resolve.merge host.resolve
-        end
-      }
-      /
-      scheme host path search {
-        def resolve
-          scheme.resolve.merge host.resolve.merge path.resolve.merge search.resolve
-        end
-      }
-      /
-      scheme host path {
-        def resolve
-          scheme.resolve.merge host.resolve.merge path.resolve
-        end
-      }
-      /
-      scheme host search {
-        def resolve
-          scheme.resolve.merge host.resolve.merge search.resolve
-        end
-      }
-      /
-      scheme host {
-        def resolve
-          scheme.resolve.merge host.resolve
-        end
-      }
-      /
-      host port path search {
-        def resolve
-          port.resolve.merge host.resolve.merge path.resolve.merge search.resolve
-        end
-      }
-      /
-      host port path {
-        def resolve
-          port.resolve.merge host.resolve.merge path.resolve
-        end
-      }
-      /
-      host port search {
-        def resolve
-          port.resolve.merge host.resolve.merge search.resolve
-        end
-      }
-      /
-      host port {
-        def resolve
-          port.resolve.merge host.resolve
-        end
-      }
-      /
-      host path {
-        def resolve
-          host.resolve.merge path.resolve
-        end
-      }
-      /
-      host search {
-        def resolve
-          host.resolve.merge search.resolve
-        end
-      }
-      /
-      host
-    end
-
-    rule scheme
-      characters '://' {
-        def resolve
-          { :scheme => characters.text_value }
-        end
-      }
-    end
-
-    rule host
-      subdomain:characters '.' domain:characters '.' tld:characters {
-        def resolve
-          {
-            :subdomain => subdomain.text_value,
-            :host => "#{domain.text_value}.#{tld.text_value}"
-          }
-        end
-      }
-      /
-      domain:characters '.' tld:characters {
-        def resolve
-          { :host => text_value }
-        end
-      }
-      /
-      characters {
-        def resolve
-          { :host => text_value }
-        end
-      }
-    end
-
-    rule port
-      ':' port:([0-9]1..4) {
-        def resolve
-          { :port => port.text_value }
-        end
-      }
-    end
-
-    rule path
-      '/' characters {
-        def resolve
-          { :path => characters.text_value }
-        end
-      }
-    end
-
-    rule search
-      '?' search:( characters '=' characters ) {
-        def resolve
-          { :search => search.text_value }
-        end
-      }
-    end
-
-    rule characters
-      [a-zA-Z0-9]+
-    end
-  end
-end

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