url_parser 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09b0929a6a38afe26b698634a884e309bbcd84a0
-  data.tar.gz: 70ec9fba2693c46a884878d59468c3ba85b50975
+  metadata.gz: 69dee1c0cfaf6d371119bbbc969312ea4ec1632b
+  data.tar.gz: e57b7aea6c0a4ea33e4d4a8fd63954a47385ec73
 SHA512:
-  metadata.gz: b6e85bfec45e2045ff22622b2d18dac0d8e36c04e4867e0b3436ae00ed80cc9275a270344adc19c406cbb5d433f81488c63e6f44d8a0281d68c08cbd68092043
-  data.tar.gz: bf8f1eeade03e380ac45f92d77da18577ee2ae58e9c3a2df27ceb88faed4cf841bd34e9d853f28f9c54ce7ca64d5b3478e0883777fc79a09082a1e102f79fabe
+  metadata.gz: ebd283b722a4e5e4a6ac6b66812fad32d138be669c22e87b9c226e0a8aab7fc0ee0ff9b8445ba1d3e5139d9d59ce41b6d26ba864270c201e7742f7ff00e3572a
+  data.tar.gz: 2ba608ea61964843d308a7c88415b7f73509d8f7be4f7541e461faae5989213f4c072b3fe9a071f4f3a521fdef8b1062cb31dca7c3608a515f24d61877cd608e

data/Guardfile

@@ -0,0 +1,17 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/lib/url_parser.rb

@@ -20,9 +20,29 @@ end
 
 module UrlParser
 
+  # https://secure.wikimedia.org/wikipedia/en/wiki/URI_scheme
+  SCHEMES = [
+    'file', 'ftp', 'gopher', 'h323', 'hdl', 'http', 'https',
+    'imap', 'magnet', 'mailto', 'mms', 'news', 'nntp', 'prospero',
+    'rsync', 'rtsp', 'rtspu', 'sftp', 'shttp', 'sip', 'sips',
+    'snews', 'svn', 'svn+ssh', 'telnet', 'wais',
+    # Unofficial schemes
+    'aim', 'callto', 'cvs', 'facetime', 'feed', 'git', 'gtalk',
+    'irc', 'ircs', 'irc6', 'itms', 'mms', 'msnim', 'mvn', 'skype',
+    'ssh', 'smb', 'svn', 'ymsg', 'webcal'
+  ]
+
+  DEFAULT_SCHEMES = [
+    'http', 'https', 'ftp', 'mailto', 'file', 'ssh', 'feed',
+    'cvs', 'git', 'mvn', 'nntp', 'shttp', 'svn', 'webcal'
+  ]
 
   module Error; end
 
+  class InvalidScheme
+    include UrlParser::Error
+  end
+
   def self.call(text, options = {})
     urls = []
     PostRank::URI.extract(text).each do |url|
@@ -37,45 +57,29 @@ module UrlParser
 
   class Base
 
-    # https://secure.wikimedia.org/wikipedia/en/wiki/URI_scheme
-    MAJOR_SCHEMES = [
-      'file', 'ftp', 'gopher', 'h323', 'hdl', 'http', 'https', 'imap', 'magnet',
-      'mailto', 'mms', 'news', 'nntp', 'prospero', 'rsync', 'rtsp', 'rtspu',
-      'sftp', 'shttp', 'sip', 'sips', 'snews', 'svn', 'svn+ssh', 'telnet',
-      'wais',
-      # Unofficial schemes
-      'aim', 'callto', 'cvs', 'facetime', 'feed', 'git', 'gtalk', 'irc', 'ircs',
-      'irc6', 'itms', 'mms', 'msnim', 'skype', 'ssh', 'smb', 'svn', 'ymsg', 'mvn'
-    ]
-
-    DEFAULT_SCHEMES = [
-      'http', 'https', 'ftp', 'mailto', 'file', 'ssh', 'feed',
-      'cvs', 'git', 'mvn', 'nntp', 'shttp', 'svn'
-    ]
+    attr_reader :url, :original_url, :raise_errors
 
-    attr_reader :url, :original_url
+    attr_accessor :errors
 
     def initialize(url, options = {})
-      @schemes = options.fetch(:schemes) { DEFAULT_SCHEMES }
-      @clean = options.fetch(:clean) { false }
-      @original_url = url
-      @url = @clean ? clean(url) : parse(url)
+      @schemes        = options.fetch(:schemes) { UrlParser::DEFAULT_SCHEMES }
+      @clean          = options.fetch(:clean) { false }
+      @raise_errors   = options.fetch(:raise_errors) { false }
+      @errors         = []
+      @original_url   = url
+      @url            = @clean ? clean(url) : parse(url)
+      prepare
     end
 
     def schemes
       Array.wrap(@schemes)
     end
 
-    def parse(url)
-      tag_errors do
-        PostRank::URI.parse(url, raw: true)
-      end
-    end
-
-    def clean(url)
-      tag_errors do
-        PostRank::URI.clean(url, raw: true)
-      end
+    def clean!
+      @parser = nil
+      @url = clean(url)
+      @clean = true
+      self
     end
 
     def parser
@@ -84,18 +88,13 @@ module UrlParser
       end
     end
 
-    def clean!
-      @parser = nil
-      @url = clean(url)
-      @clean = true
-      self
-    end
-
     def to_s
+      return '' if errors.any?
       url.to_s
     end
 
     def hash(options = {})
+      return nil if errors.any?
       clean = options.fetch(:clean) { nil }
       if clean.nil?
         Digest::SHA1.hexdigest(url.to_s)
@@ -107,13 +106,11 @@ module UrlParser
     end
 
     def valid?
-      return true if localhost?
-      return false unless schemes.include?(scheme)
-      return false unless hostname =~ /\./
-      true
+      errors.empty?
     end
 
     def join(relative_path)
+      return nil if errors.any?
       UrlParser.new(
         Addressable::URI.join(url, relative_path).to_s
       )
@@ -122,29 +119,35 @@ module UrlParser
     # URI Components
 
     def scheme
+      return nil if errors.any?
       url.scheme
     end
 
     def username
+      return nil if errors.any?
       url.user
     end
     alias_method :user, :username
 
     def password
+      return nil if errors.any?
       url.password
     end
 
     def userinfo
+      return nil if errors.any?
       url.userinfo
     end
 
     def www
+      return nil if errors.any?
       return nil if parser.subdomain.empty?
       parts = slice_domain.split('.')
       parts.first =~ /www?\d*/ ? parts.shift : nil
     end
 
     def subdomain
+      return nil if errors.any?
       return nil if parser.subdomain.empty?
       parts = slice_domain.split('.')
       parts.shift if parts.first =~ /www?\d*/
@@ -152,15 +155,18 @@ module UrlParser
     end
 
     def subdomains
+      return nil if errors.any?
       return nil if parser.subdomain.empty?
       [ www, subdomain ].compact.join('.')
     end
 
     def domain_name
+      return nil if errors.any?
       parser.domain.empty? ? nil : parser.domain
     end
 
     def domain
+      return nil if errors.any?
       if parser.domain_with_public_suffix.empty?
         nil
       else
@@ -169,36 +175,44 @@ module UrlParser
     end
 
     def tld
+      return nil if errors.any?
       tld = parser.public_suffix
       tld.empty? ? nil : tld
     end
 
     def hostname
+      return nil if errors.any?
       url.host
     end
 
     def port
+      return nil if errors.any?
       url.port
     end
 
     def host
+      return nil if errors.any?
       name = [ hostname, port ].compact.join(':')
       name.empty? ? nil : name
     end
 
     def origin
+      return nil if errors.any?
       url.origin == "null" ? nil : url.origin
     end
 
     def authority
+      return nil if errors.any?
       url.authority
     end
 
     def site
+      return nil if errors.any?
       url.site
     end
 
     def directory
+      return nil if errors.any?
       parts = path.split('/')
       return '/' if parts.empty?
       parts.pop unless segment.to_s.empty?
@@ -207,38 +221,46 @@ module UrlParser
     end
 
     def path
+      return nil if errors.any?
       url.path
     end
 
     def segment
+      return nil if errors.any?
       path =~ /\/\z/ ? nil : path.split('/').last
     end
 
     def filename
+      return nil if errors.any?
       return 'index.html' if segment.to_s.empty?
       return '' if suffix.to_s.empty?
       segment
     end
 
     def suffix
+      return nil if errors.any?
       ext = File.extname(path)
       ext[0] = '' if ext[0] == '.'
       ext.empty? ? nil : ext
     end
 
     def query
+      return nil if errors.any?
       url.query
     end
 
     def query_values
+      return {} if errors.any?
       url.query_values.to_h
     end
 
     def fragment
+      return nil if errors.any?
       url.fragment
     end
 
     def resource
+      return nil if errors.any?
       name = [
         [ segment, query ].compact.join('?'), fragment
       ].compact.join('#')
@@ -246,14 +268,17 @@ module UrlParser
     end
 
     def relative?
+      return nil if errors.any?
       url.relative?
     end
 
     def absolute?
+      return nil if errors.any?
       url.absolute?
     end
 
     def localhost?
+      return nil if errors.any?
       !!(hostname =~ /(\A|\.)localhost\z/)
     end
 
@@ -266,8 +291,29 @@ module UrlParser
     def tag_errors
       yield
     rescue Exception => error
-      error.extend(UrlParser::Error)
-      raise
+      unless error.singleton_class.include?(UrlParser::Error)
+        error.extend(UrlParser::Error)
+      end
+      @errors << error
+      raise if raise_errors
+    end
+
+    def parse(url)
+      tag_errors do
+        PostRank::URI.parse(url, raw: true)
+      end
+    end
+
+    def clean(url)
+      tag_errors do
+        PostRank::URI.clean(url, raw: true)
+      end
+    end
+
+    # Initialize parser to ensure no errors are raised
+    #
+    def prepare
+      parser
     end
 
   end

data/lib/url_parser/version.rb

@@ -1,3 +1,3 @@
 module UrlParser
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/spec/url_parser_spec.rb

@@ -8,6 +8,18 @@ describe UrlParser do
     expect(UrlParser::VERSION).not_to be_nil
   end
 
+  context "::SCHEMES" do
+
+    it { expect( UrlParser::SCHEMES).to be_an Array }
+
+  end
+
+  context "::DEFAULT_SCHEMES" do
+
+    it { expect( UrlParser::DEFAULT_SCHEMES).to be_an Array }
+
+  end
+
   context "::call" do
 
     let(:link) { 'http://example.com/' }
@@ -33,10 +45,6 @@ describe UrlParser do
       expect(parser.to_s).to eq link
     end
 
-    it "cannot initialize invalid urls" do
-      expect{ UrlParser.new('http:||bra.ziz') }.to raise_error
-    end
-
     it "adds http by default" do
       expect(UrlParser.new('example.com/path').to_s).to eq link
     end
@@ -45,10 +53,12 @@ describe UrlParser do
       expect(UrlParser.new('//example.com/path').to_s).to eq link
     end
 
-    it "any errors raised inherit from UrlParser::Error" do
-      expect{
-        UrlParser.new('http:||bra.ziz')
-      }.to raise_error UrlParser::Error
+    it "cannot initialize invalid urls" do
+      expect(UrlParser.new('http:||bra.ziz').url).to be_nil
+    end
+
+    it "catches errors from invalid urls" do
+      expect(UrlParser.new('http:||bra.ziz').errors).not_to be_empty
     end
 
     context "options" do
@@ -81,6 +91,22 @@ describe UrlParser do
 
       end
 
+      context ":raise_errors" do
+
+        it "raises instead of catching errors" do
+          expect{
+            UrlParser.new('http:||bra.ziz', raise_errors: true)
+          }.to raise_error
+        end
+
+        it "any errors raised inherit from UrlParser::Error" do
+          expect{
+            UrlParser.new('http:||bra.ziz', raise_errors: true)
+          }.to raise_error UrlParser::Error
+        end
+
+      end
+
     end
 
   end
@@ -123,10 +149,10 @@ describe UrlParser do
       UrlParser.new(link, clean: false)
     end
 
-    it "tags errors" do
-      parser = UrlParser.new(link, clean: true)
+    it "tags errors when set to raise errors" do
+      parser = UrlParser.new(link, clean: true, raise_errors: true)
       expect(PostRank::URI).to receive(:parse).and_raise(StandardError)
-      expect{ parser.parse(link) }.to raise_error UrlParser::Error
+      expect{ parser.send(:parse, link) }.to raise_error UrlParser::Error
     end
 
   end
@@ -141,9 +167,9 @@ describe UrlParser do
     end
 
     it "tags errors" do
-      parser = UrlParser.new(link, clean: false)
+      parser = UrlParser.new(link, clean: false, raise_errors: true)
       expect(PostRank::URI).to receive(:clean).and_raise(StandardError)
-      expect{ parser.clean(link) }.to raise_error UrlParser::Error
+      expect{ parser.send(:clean, link) }.to raise_error UrlParser::Error
     end
 
   end
@@ -153,15 +179,15 @@ describe UrlParser do
     let(:link) { 'link.to?a=b&utm_source=FeedBurner#stuff' }
 
     it "calls postrank-uri's clean function" do
-      parser = UrlParser.new(link, clean: true)
       expect(Domainatrix).to receive(:parse).with(parser.to_s)
-      parser.parser
+      UrlParser.new(link, clean: true)
     end
 
     it "tags errors" do
-      parser = UrlParser.new(link, clean: false)
       expect(Domainatrix).to receive(:parse).and_raise(StandardError)
-      expect{ parser.parser }.to raise_error UrlParser::Error
+      expect{
+        UrlParser.new(link, clean: false, raise_errors: true)
+      }.to raise_error UrlParser::Error
     end
 
   end
@@ -208,24 +234,12 @@ describe UrlParser do
 
   context "#valid?" do
 
-    it "returns false if the url is invalid" do
-      expect(UrlParser.new('bullshit')).not_to be_valid
-    end
-
-    it "returns false if the url scheme is not in the options" do
-      expect(UrlParser.new('telnet://some.com')).not_to be_valid
-    end
-
-    it "returns true if the url scheme is in the options" do
-      expect(UrlParser.new('telnet://some.com', schemes: ['telnet'])).to be_valid
-    end
-
-    it "returns true if the url is valid" do
-      expect(UrlParser.new('http://example.com/')).to be_valid
+    it "returns true if there are no errors" do
+      expect(UrlParser.new('http://example.com')).to be_valid
     end
 
-    it "returns true for localhost" do
-      expect(UrlParser.new('localhost:5000')).to be_valid
+    it "returns false if there are errors" do
+      expect(UrlParser.new('http:||bra.ziz')).not_to be_valid
     end
 
   end
@@ -273,13 +287,15 @@ describe UrlParser do
 
     let(:parser) { UrlParser.new(link, clean: false) }
 
-    context "when present" do
+    context "when all are present" do
 
       let(:link) do
-        'foo://username:password@ww2.foo.bar.example.com:123/hello/world/there.html?name=ferret#foo'
+        'https://username:password@ww2.foo.bar.example.com:123/hello/world/there.html?name=ferret#foo'
       end
 
-      it { expect(parser.scheme).to eq 'foo' }
+      it { expect(parser.errors).to be_empty }
+      it { expect(parser).to be_valid }
+      it { expect(parser.scheme).to eq 'https' }
       it { expect(parser.username).to eq 'username' }
       it { expect(parser.password).to eq 'password' }
       it { expect(parser.userinfo).to eq 'username:password' }
@@ -292,9 +308,9 @@ describe UrlParser do
       it { expect(parser.hostname).to eq 'ww2.foo.bar.example.com' }
       it { expect(parser.port).to eq 123 }
       it { expect(parser.host).to eq 'ww2.foo.bar.example.com:123' }
-      it { expect(parser.origin).to eq 'foo://ww2.foo.bar.example.com:123' }
+      it { expect(parser.origin).to eq 'https://ww2.foo.bar.example.com:123' }
       it { expect(parser.authority).to eq 'username:password@ww2.foo.bar.example.com:123' }
-      it { expect(parser.site).to eq 'foo://username:password@ww2.foo.bar.example.com:123' }
+      it { expect(parser.site).to eq 'https://username:password@ww2.foo.bar.example.com:123' }
       it { expect(parser.directory).to eq '/hello/world' }
       it { expect(parser.path).to eq '/hello/world/there.html' }
       it { expect(parser.segment).to eq 'there.html' }
@@ -304,15 +320,13 @@ describe UrlParser do
       it { expect(parser.query_values['name']).to eq 'ferret' }
       it { expect(parser.fragment).to eq 'foo' }
       it { expect(parser.resource).to eq 'there.html?name=ferret#foo' }
-
     end
 
-    context "when missing" do
+    context "when none are present" do
 
-      let(:link) do
-        '/'
-      end
+      let(:link) { '/' }
 
+      it { expect(parser.errors).to be_empty }
       it { expect(parser.scheme).to be_nil }
       it { expect(parser.username).to be_nil }
       it { expect(parser.password).to be_nil }
@@ -341,6 +355,72 @@ describe UrlParser do
 
     end
 
+    context "when empty" do
+
+      let(:link) { '' }
+
+      it { expect(parser.errors).to be_empty }
+      it { expect(parser.scheme).to be_nil }
+      it { expect(parser.username).to be_nil }
+      it { expect(parser.password).to be_nil }
+      it { expect(parser.userinfo).to be_nil }
+      it { expect(parser.www).to be_nil }
+      it { expect(parser.subdomain).to be_nil }
+      it { expect(parser.subdomains).to be_nil }
+      it { expect(parser.domain_name).to be_nil }
+      it { expect(parser.domain).to be_nil }
+      it { expect(parser.tld).to be_nil }
+      it { expect(parser.hostname).to be_nil }
+      it { expect(parser.port).to be_nil }
+      it { expect(parser.host).to be_nil }
+      it { expect(parser.origin).to be_nil }
+      it { expect(parser.authority).to be_nil }
+      it { expect(parser.site).to be_nil }
+      it { expect(parser.directory).to eq '/' }
+      it { expect(parser.path).to eq '' }
+      it { expect(parser.segment).to be_nil }
+      it { expect(parser.filename).to eq 'index.html' }
+      it { expect(parser.suffix).to be_nil }
+      it { expect(parser.query).to be_nil }
+      it { expect(parser.query_values['name']).to be_nil }
+      it { expect(parser.fragment).to be_nil }
+      it { expect(parser.resource).to be_nil }
+
+    end
+
+    context "when invalid" do
+
+      let(:link) { 'http://#content-zone' }
+
+      it { expect(parser.errors).not_to be_empty }
+      it { expect(parser.scheme).to be_nil }
+      it { expect(parser.username).to be_nil }
+      it { expect(parser.password).to be_nil }
+      it { expect(parser.userinfo).to be_nil }
+      it { expect(parser.www).to be_nil }
+      it { expect(parser.subdomain).to be_nil }
+      it { expect(parser.subdomains).to be_nil }
+      it { expect(parser.domain_name).to be_nil }
+      it { expect(parser.domain).to be_nil }
+      it { expect(parser.tld).to be_nil }
+      it { expect(parser.hostname).to be_nil }
+      it { expect(parser.port).to be_nil }
+      it { expect(parser.host).to be_nil }
+      it { expect(parser.origin).to be_nil }
+      it { expect(parser.authority).to be_nil }
+      it { expect(parser.site).to be_nil }
+      it { expect(parser.directory).to be_nil }
+      it { expect(parser.path).to be_nil }
+      it { expect(parser.segment).to be_nil }
+      it { expect(parser.filename).to be_nil }
+      it { expect(parser.suffix).to be_nil }
+      it { expect(parser.query).to be_nil }
+      it { expect(parser.query_values['name']).to be_nil }
+      it { expect(parser.fragment).to be_nil }
+      it { expect(parser.resource).to be_nil }
+
+    end
+
   end
 
   context "localhost?" do

data/url_parser.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "pry"
 
   spec.add_dependency "domainatrix", ">= 0.0.11"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: url_parser
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Matt Solt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-09 00:00:00.000000000 Z
+date: 2014-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -119,6 +133,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile