domain_extractor 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bc4d6ad831692d1251048f8b21820bb0efb10ed5b3cce641441b31afb5308b4
-  data.tar.gz: 67a96b33dc3544847af271c8bd837dbc592031bff5dac126022a147c2281460c
+  metadata.gz: 2b919b52fe3fda7edf9738141e66e2acbcb2458d276800cb62b48c4c34d3b914
+  data.tar.gz: be02cf195da3a6a9da51136140f1487e96c026b22f1a300825d15733eb493acf
 SHA512:
-  metadata.gz: 02bca764446a3391461695cfeeaef9c6e7920308bc78768b062ae676005d3610b09733133cb10c34cd5e29dc35169f770b4789f418fd554cba762a6d5a19022a
-  data.tar.gz: eeaaa8356b306feba33e08e54c8da2926f7e052ebac5d6920f0a6f26c0dacd3bfbb0d4f863fa694377d87441564a2c1eecff764d756ce4efde0569fabf573ee2
+  metadata.gz: 981d228483ba55b85834c38df3146a47018be6b7456053add7356a74f15d33cd27038d50682e5488f14ff9dfd09ef463bee1bbd6f7c486d9e9698dd305543738
+  data.tar.gz: e320e6d216196664de8f73b18be95746863b60fba99e496dc166ebd2f051afdf475d56f7d7a30dc6910e66d380e5b03b7d472730698905ed5b83e87aba3eb4e5

data/README.md

@@ -65,6 +65,10 @@ end
 result.subdomain      # => 'www'
 result.domain         # => 'example'
 result.host           # => 'www.example.co.uk'
+
+# Opt into strict parsing when needed
+DomainExtractor.parse!('notaurl')
+# => raises DomainExtractor::InvalidURLError: Invalid URL Value
 ```
 
 ## ParsedURL API - Intuitive Method Access
@@ -150,6 +154,28 @@ DomainExtractor.parse('https://api.dashtrack.com').subdomain?   # => true
 # Check for www subdomain specifically
 DomainExtractor.parse('https://www.dashtrack.com').www_subdomain? # => true
 DomainExtractor.parse('https://api.dashtrack.com').www_subdomain? # => false
+
+```
+
+#### Handling Unknown or Invalid Data
+
+```ruby
+# Default accessors fail silently with nil
+DomainExtractor.parse(nil).domain                 # => nil
+DomainExtractor.parse('').host                    # => nil
+DomainExtractor.parse('asdfasdfds').domain        # => nil
+
+# Boolean checks never raise
+DomainExtractor.parse(nil).subdomain?             # => false
+DomainExtractor.parse('').domain?                 # => false
+DomainExtractor.parse('https://dashtrack.com').subdomain? # => false
+
+# Bang methods raise when a component is missing
+DomainExtractor.parse('').host!                   # => raises DomainExtractor::InvalidURLError
+DomainExtractor.parse('asdfasdfds').domain!       # => raises DomainExtractor::InvalidURLError
+
+# Strict parsing helper mirrors legacy behaviour
+DomainExtractor.parse!('asdfasdfds')              # => raises DomainExtractor::InvalidURLError
 ```
 
 #### Safe Batch Processing

data/lib/domain_extractor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DomainExtractor
-  VERSION = '0.1.8'
+  VERSION = '0.1.9'
 end

data/lib/domain_extractor.rb

@@ -15,10 +15,21 @@ module DomainExtractor
   class << self
     # Parse an individual URL and extract domain attributes.
     # Returns a ParsedURL object that supports hash-style access and method calls.
-    # Raises DomainExtractor::InvalidURLError when the URL fails validation.
+    # For invalid inputs the returned ParsedURL will be marked invalid and all
+    # accessors (without bang) will evaluate to nil/false.
     # @param url [String, #to_s]
     # @return [ParsedURL]
     def parse(url)
+      Parser.call(url)
+    end
+
+    # Parse an individual URL and raise when extraction fails.
+    # This mirrors the legacy behaviour of .parse while giving callers an
+    # explicit opt-in to strict validation.
+    # @param url [String, #to_s]
+    # @return [ParsedURL]
+    # @raise [InvalidURLError]
+    def parse!(url)
       result = Parser.call(url)
       raise InvalidURLError unless result.valid?
 

data/spec/domain_extractor_spec.rb

@@ -142,40 +142,42 @@ RSpec.describe DomainExtractor do
     end
 
     context 'with invalid URLs' do
-      it 'raises InvalidURLError for malformed URLs' do
-        expect { described_class.parse('http://') }.to raise_error(
-          DomainExtractor::InvalidURLError,
-          'Invalid URL Value'
-        )
+      let(:invalid_inputs) { ['http://', 'not_a_url', '192.168.1.1', '[2001:db8::1]', '', nil] }
+
+      it 'returns an invalid ParsedURL that safely yields nil values' do
+        invalid_inputs.each do |input|
+          result = described_class.parse(input)
+
+          expect(result).to be_a(DomainExtractor::ParsedURL)
+          expect(result.valid?).to be(false)
+          expect(result.domain).to be_nil
+          expect(result.domain?).to be(false)
+          expect(result.host).to be_nil
+          expect(result.host?).to be(false)
+        end
       end
 
-      it 'raises InvalidURLError for invalid domains' do
-        expect { described_class.parse('not_a_url') }.to raise_error(
-          DomainExtractor::InvalidURLError,
-          'Invalid URL Value'
-        )
-      end
+      it 'allows bang accessors to raise explicit errors' do
+        result = described_class.parse('not_a_url')
 
-      it 'raises InvalidURLError for IP addresses' do
-        expect { described_class.parse('192.168.1.1') }.to raise_error(
+        expect { result.domain! }.to raise_error(
           DomainExtractor::InvalidURLError,
-          'Invalid URL Value'
+          'domain not found or invalid'
         )
-      end
 
-      it 'raises InvalidURLError for IPv6 addresses' do
-        expect { described_class.parse('[2001:db8::1]') }.to raise_error(
+        expect { result.host! }.to raise_error(
           DomainExtractor::InvalidURLError,
-          'Invalid URL Value'
+          'host not found or invalid'
         )
       end
 
-      it 'raises InvalidURLError for empty string' do
-        expect { described_class.parse('') }.to raise_error(DomainExtractor::InvalidURLError, 'Invalid URL Value')
-      end
-
-      it 'raises InvalidURLError for nil' do
-        expect { described_class.parse(nil) }.to raise_error(DomainExtractor::InvalidURLError, 'Invalid URL Value')
+      it 'provides strict parsing via parse!' do
+        invalid_inputs.each do |input|
+          expect { described_class.parse!(input) }.to raise_error(
+            DomainExtractor::InvalidURLError,
+            'Invalid URL Value'
+          )
+        end
       end
     end
   end

data/spec/parsed_url_spec.rb

@@ -127,8 +127,8 @@ RSpec.describe DomainExtractor::ParsedURL do
       end
     end
 
-    context 'with invalid URL' do
-      let(:parsed) { DomainExtractor::ParsedURL.new(nil) }
+    context 'with invalid URL input' do
+      let(:parsed) { DomainExtractor.parse('invalid_url_value') }
 
       describe 'default accessor methods' do
         it 'returns nil for subdomain' do
@@ -189,6 +189,50 @@ RSpec.describe DomainExtractor::ParsedURL do
         end
       end
     end
+
+    context 'with nil input' do
+      let(:parsed) { DomainExtractor.parse(nil) }
+
+      it 'returns nil for default accessors' do
+        expect(parsed.domain).to be_nil
+        expect(parsed.host).to be_nil
+        expect(parsed.subdomain).to be_nil
+      end
+
+      it 'returns false for question accessors' do
+        expect(parsed.domain?).to be false
+        expect(parsed.host?).to be false
+        expect(parsed.subdomain?).to be false
+      end
+
+      it 'raises for bang accessors' do
+        expect { parsed.domain! }.to raise_error(
+          DomainExtractor::InvalidURLError,
+          'domain not found or invalid'
+        )
+      end
+    end
+
+    context 'with empty string input' do
+      let(:parsed) { DomainExtractor.parse('') }
+
+      it 'returns nil for default accessors' do
+        expect(parsed.domain).to be_nil
+        expect(parsed.host).to be_nil
+      end
+
+      it 'returns false for question accessors' do
+        expect(parsed.domain?).to be false
+        expect(parsed.host?).to be false
+      end
+
+      it 'raises for bang accessors' do
+        expect { parsed.host! }.to raise_error(
+          DomainExtractor::InvalidURLError,
+          'host not found or invalid'
+        )
+      end
+    end
   end
 
   describe '#www_subdomain?' do
@@ -208,7 +252,7 @@ RSpec.describe DomainExtractor::ParsedURL do
     end
 
     it 'returns false for invalid URL' do
-      parsed = DomainExtractor::ParsedURL.new(nil)
+      parsed = DomainExtractor.parse('invalid_url_value')
       expect(parsed.www_subdomain?).to be false
     end
   end
@@ -220,7 +264,7 @@ RSpec.describe DomainExtractor::ParsedURL do
     end
 
     it 'returns false for invalid URL' do
-      parsed = DomainExtractor::ParsedURL.new(nil)
+      parsed = DomainExtractor.parse('invalid_url_value')
       expect(parsed.valid?).to be false
     end
 
@@ -299,8 +343,7 @@ RSpec.describe DomainExtractor::ParsedURL do
 
     it 'handles example: domain returns nil for invalid URL' do
       # Parser returns ParsedURL with empty result for invalid URLs
-      # But parse() raises error, so we need to construct directly
-      parsed = DomainExtractor::ParsedURL.new(nil)
+      parsed = DomainExtractor.parse('invalid_url_value')
       expect(parsed.domain).to be_nil
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: domain_extractor
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - OpenSite AI