A domain name parser using public suffix list
Ruby
Latest commit 4f5f85d Apr 19, 2015 @asaaki Bump to version v0.3.2
Permalink
Failed to load latest commit information.
data Update data files Apr 19, 2015
lib
spec Update data files Apr 19, 2015
.gitignore
.rspec Add first files + final fetcher specs May 20, 2012
.rubocop.yml Extend rubocop rule exceptions Feb 24, 2015
.travis.yml Move token to env section Feb 24, 2015
Gemfile Update dependencies Apr 19, 2015
Gemfile.lock
LICENSE Overhaul README Feb 25, 2015
README.md Use flat-squared badges Feb 25, 2015
Rakefile Move suffix checker to spec/ Feb 25, 2015
ryodo.gemspec Update dependencies Apr 19, 2015

README.md

ryodo

gem version build status dev dependency status code climate coverage status Support via Gratipay

ryōdo【領土】 りょうど — A domain name parser using public suffix list

Do you ever wanted to know if suspicious.domain.name.blerp is really a valid (registerable) domain?

Do you ever wanted to know what is the actual domain portion of yet.another.awesome.domain.co.jp?

Then you should try ryodo and get the answers!

Notice: This gem does not check DNS records to verify if a name was taken and registered, this is not its purpose. I am a big fan of the UNIX philosophy: »Write programs that do one thing and do it well.«

My blog post about ryodo: ryodo - domain parser (2012-06-02)

Usage

# Gemfile
gem "ryodo"
dom = Ryodo.parse("my.awesome.domain.co.jp")
#=> Ryodo::Domain

                  #    SUBDOMAIN  DOMAIN   TLD
dom.tld           #=>                   "co.jp"  - returns only the public suffix
dom.domain        #=>            "domain.co.jp"  - returns only registered/registrable domain
dom.sld           #=>            "domain"        - returns only registered/registrable domain name w/o TLD
dom.subdomain     #=> "my.awesome"               - returns only subdomain parts
dom               #=> "my.awesome.domain.co.jp"  - returns full domain string
dom.fqdn          #=> "my.awesome.domain.co.jp." - full domain + trailing dot

# all parts also reversable
# mostly used on domain/FQDN
dom.reverse            #=> "jp.co.domain.awesome.my"
dom.fqdn.reverse       #=> ".jp.co.domain.awesome.my"

dom.to_a               #=> ["my","awesome","domain","co","jp"]
dom.domain.to_a        #=> ["domain","co","jp"]
dom.sld.to_a           #=> ["domain"]
dom.subdomain.to_a     #=> ["my","awesome"]
dom.fqdn.to_a          #=> ["my","awesome","domain","co","jp",""]

# .to_a also usable with parameter :reverse (or shorthand :r)
dom.domain.to_a(:reverse) #=> ["jp","co","domain","awesome","my"]
dom.fqdn.to_a(:reverse)   #=> ["","jp","co","domain","awesome","my"]
dom.fqdn.to_a(:r)         #=> ["","jp","co","domain","awesome","my"]

You can call it in different ways:

Ryodo.parse("my.awesome.domain.co.jp")
Ryodo("my.awesome.domain.co.jp")
Ryodo["my.awesome.domain.co.jp"]
ryodo("my.awesome.domain.co.jp")

Quick check (.domain_valid?)

Ryodo.domain_valid?("my.awesome.domain.co.jp") #=> true
Ryodo.domain_valid?("co.jp")                   #=> false

# aliases
Ryodo.valid_domain?("my.awesome.domain.co.jp")
Ryodo.valid?("my.awesome.domain.co.jp")
Ryodo?("my.awesome.domain.co.jp")
ryodo?("my.awesome.domain.co.jp")
valid_domain?("my.awesome.domain.co.jp")

String extension

require "ryodo/ext/string"

"my.awesome.domain.co.jp".to_domain
"my.awesome.domain.co.jp".ryodo

# validation
"my.awesome.domain.co.jp".valid_domain?

In Gemfile:

gem "ryodo", require: %w[ryodo ryodo/ext/string]

UTF-8 junkie?

require "ryodo/convenience/utf8"

ryōdo("my.awesome.domain.co.jp")
領土("my.awesome.domain.co.jp")
りょうど("my.awesome.domain.co.jp")

ryōdo?("my.awesome.domain.co.jp")
領土?("my.awesome.domain.co.jp")
りょうどか("my.awesome.domain.co.jp")

Extension of URI

Ryodo can transparently hook into URI, so you can use every described method on .host.

require "ryodo/ext/uri"

uri = URI.parse("http://my.awesome.domain.jp:5555/path")
uri.host
#=> "my.awesome.domain.jp"

uri.host.class
#=> Ryodo::Domain
# but decorates the String class transparently

uri.host.domain
#=> "domain.com"

# awesome quick check before doing further stuff with URI
# because why you would do a request to an URI with obviously invalid domain?
uri.host.is_valid?
#=> true

In Gemfile:

gem "ryodo", require: %w[ryodo ryodo/ext/uri]

Foo …

"Uh, excuse me Sir … just one more question." — Columbo (Peter Falk †)

License

MIT/X11

2012—2015 Christoph Grabo