ryodo 0.2.7 → 0.3.0

data/lib/ryodo.rb

@@ -1,8 +1,6 @@
-# coding: utf-8
-
 module Ryodo
   RYODO_ROOT             = File.expand_path("../..", __FILE__)
-  PUBLIC_SUFFIX_DATA_URI = "http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1"
+  PUBLIC_SUFFIX_DATA_URI = "https://publicsuffix.org/list/effective_tld_names.dat"
   PUBLIC_SUFFIX_STORE    = "#{RYODO_ROOT}/data/suffix.dat"
 end
 
@@ -15,12 +13,12 @@ require "ryodo/rule_set"
 require "ryodo/suffix_list"
 
 require "ryodo/methods"
-#require "ryodo/ext/string"
-#require "ryodo/ext/uri"
+# require "ryodo/ext/string"
+# require "ryodo/ext/uri"
 
 # Convenient shorthands
 module Ryodo
   extend Ryodo::Methods
   require "ryodo/convenience"
 end
-#require "ryodo/convenience/utf8"
+# require "ryodo/convenience/utf8"

data/lib/ryodo/convenience.rb

@@ -1,8 +1,5 @@
-# coding: utf-8
-
 module Ryodo
   module Convenience
-
     def Ryodo(domain_string)
       Ryodo.parse(domain_string)
     end
@@ -10,7 +7,6 @@ module Ryodo
     def Ryodo?(domain_string)
       Ryodo.valid?(domain_string)
     end
-
   end
 end
 

data/lib/ryodo/convenience/utf8.rb

@@ -1,27 +1,22 @@
-# coding: utf-8
-
 module Ryodo
   module Convenience
     module UTF8
+      alias_method :ryodo, :Ryodo
 
-      alias_method :ryodo,         :Ryodo
-
-      alias_method :ryodo?,        :Ryodo?
+      alias_method :ryodo?, :Ryodo?
       alias_method :valid_domain?, :Ryodo?
 
       # Unicode junkie? ;o)
-      alias_method :"ryōdo",   :Ryodo
-      alias_method :"ryōdo?",  :Ryodo?
+      alias_method :"ryōdo", :Ryodo
+      alias_method :"ryōdo?", :Ryodo?
 
-      alias_method :"領土",    :Ryodo
+      alias_method :"領土", :Ryodo
       alias_method :"りょうど", :Ryodo
 
-      alias_method :"領土?",    :Ryodo?
+      alias_method :"領土?", :Ryodo?
       alias_method :"りょうどか", :Ryodo?
       alias_method :"りょうどか。", :Ryodo?
-
     end
-
   end
 end
 

data/lib/ryodo/domain.rb

@@ -1,8 +1,5 @@
-# coding: utf-8
-
 module Ryodo
   class Domain
-
     # DomainString is a String with extended methods
     class DomainString < String
 
@@ -11,7 +8,7 @@ module Ryodo
       end
       alias_method :r, :reverse
 
-      def to_a option = nil
+      def to_a(option = nil)
         case option
         when :reverse, :r
           dsplit.reverse
@@ -20,59 +17,58 @@ module Ryodo
         end
       end
 
-    private
+      private
 
       def dsplit
-        self.split(".",-1)
+        self.split(".", -1)
       end
-
     end
 
     # remove own class comparison (we will use String#== via method_missing)
     undef_method :==
 
-    def initialize domainStr
-      raise TypeError, "Not a valid domain string!" unless domainStr.is_a?(String)
-      @domain_string = DomainString.new domainStr.downcase
-      no_leading_dot = @domain_string[0] != "."
-
-      parts = Ryodo::Parser.run(@domain_string)
-
-      @suffix    = no_leading_dot && parts                     ?  parts[0].reverse.join(".")             : nil
-      @domain    = no_leading_dot && parts && !parts[1].empty? ? (parts[0] + parts[1]).reverse.join(".") : nil
-      @secondary = no_leading_dot && parts && !parts[1].empty? ?  parts[1].first                         : nil
-      @subdomain = no_leading_dot && parts && !parts[2].empty? ? (parts[2]).reverse.join(".")            : nil
+    def initialize(domainStr)
+      fail TypeError, "Not a valid domain string!" unless domainStr.is_a?(String)
+      @domain_string   = DomainString.new domainStr.downcase
+      no_leading_dot   = @domain_string[0] != "."
+      parts            = Ryodo::Parser.run(@domain_string)
+      no_dot_but_parts = no_leading_dot && parts
+
+      @suffix    = parts[0].reverse.join(".")              if no_dot_but_parts
+      @domain    = (parts[0] + parts[1]).reverse.join(".") if no_dot_but_parts && !parts[1].empty?
+      @secondary = parts[1].first                          if no_dot_but_parts && !parts[1].empty?
+      @subdomain = (parts[2]).reverse.join(".")            if no_dot_but_parts && !parts[2].empty?
     end
 
     def suffix
-      DomainString.new @suffix if @suffix
+      DomainString.new(@suffix) if @suffix
     end
     alias_method :tld, :suffix
 
     def domain
-      DomainString.new @domain if @domain
+      DomainString.new(@domain) if @domain
     end
     alias_method :registered_domain, :domain
     alias_method :regdomain,         :domain
 
     def second_level
-      DomainString.new @secondary if @secondary
+      DomainString.new(@secondary) if @secondary
     end
     alias_method :sld,             :second_level
     alias_method :registered_name, :second_level
 
     def subdomain
-      DomainString.new @subdomain if @subdomain
+      DomainString.new(@subdomain) if @subdomain
     end
 
     def fqdn
-      DomainString.new "#{to_s}."
+      DomainString.new("#{to_s}.")
     end
 
-    def is_valid?
+    def valid?
       !!@suffix && !!@secondary
     end
-    alias_method :valid?, :is_valid?
+    alias_method :is_valid?, :valid?
 
     def to_s
       @domain_string
@@ -91,6 +87,5 @@ module Ryodo
     def send(symbol, *args)
       __send__(symbol, *args)
     end
-
   end
 end

data/lib/ryodo/ext/string.rb

@@ -1,7 +1,6 @@
 class String
-
   def to_domain
-    Ryodo.parse self
+    Ryodo.parse(self)
   end
   alias_method :ryodo,    :to_domain
   alias_method :to_ryodo, :to_domain
@@ -9,5 +8,4 @@ class String
   def valid_domain?
     Ryodo.domain_valid?(self)
   end
-
 end

data/lib/ryodo/ext/uri.rb

@@ -1,12 +1,9 @@
-# coding: utf-8
 require "uri"
 
 class URI::Generic
-
   alias_method :set_host_string, :set_host
 
-  def set_host(v)
-    @host = Ryodo.parse(self.set_host_string(v)) unless self.set_host_string(v).nil?
+  def set_host(value)
+    @host = Ryodo.parse(set_host_string(value)) unless set_host_string(value).nil?
   end
-
 end

data/lib/ryodo/methods.rb

@@ -1,18 +1,15 @@
-# coding: utf-8
-
 module Ryodo
   module Methods
 
-    def parse domain_string
-      Ryodo::Domain.new domain_string
+    def parse(domain_string)
+      Ryodo::Domain.new(domain_string)
     end
     alias_method :[], :parse
 
-    def domain_valid? domain_string
-      self.parse(domain_string).valid?
+    def domain_valid?(domain_string)
+      parse(domain_string).valid?
     end
     alias_method :valid_domain?, :domain_valid?
     alias_method :valid?,        :domain_valid?
-
   end
 end

data/lib/ryodo/parser.rb

@@ -1,32 +1,25 @@
-# coding: utf-8
-
 module Ryodo
   class Parser
-
     def initialize
       @rules = Ryodo::RuleSet.new
     end
 
-    def build_query domain
+    def build_query(domain)
       domain.split(".").reverse
     end
 
-    def parse domain
+    def parse(domain)
       @rules.match build_query(domain)
     end
 
     class << self
-
-      def run domain
+      def run(domain)
         instance.parse domain
       end
 
-
       def instance
         @@instance ||= new
       end
-
     end
-
   end
 end

data/lib/ryodo/rule.rb

@@ -1,15 +1,13 @@
-# coding: utf-8
-
 module Ryodo
-  class Rule < Struct.new(:exception, :stopOK, :children)
-
-    def has_children?
+  class Rule < Struct.new(:exception, :stop_ok, :children)
+    def children?
       !children.empty?
     end
+    alias :has_children? :children?
 
-    def is_suffix?
-      stopOK
+    def suffix?
+      stop_ok
     end
-
+    alias :is_suffix? :suffix?
   end
 end

data/lib/ryodo/rule_set.rb

@@ -1,8 +1,5 @@
-# coding: utf-8
-
 module Ryodo
   class RuleSet
-
     def initialize
       @tree = {}
       build!
@@ -10,26 +7,21 @@ module Ryodo
 
     def build!
       Ryodo::SuffixList.list.each do |line|
-
         line.each.with_index do |node_name, idx|
-
-          stopOK    = node_name == line.last
+          stop_ok   = node_name == line.last
           exception = node_name[0] == "!"
           node_name = node_name[1..-1] if exception
           children  = {}
-          node      = Ryodo::Rule.new(exception, stopOK, children)
+          node      = Ryodo::Rule.new(exception, stop_ok, children)
 
           if idx > 0
             end_idx = idx - 1
-            parent = select_rule(line[0..end_idx])
+            parent  = select_rule(line[0..end_idx])
             parent.children[node_name] = node unless parent.children[node_name]
-
           else
             @tree[node_name] = node unless @tree[node_name]
           end
-
         end
-
       end
     end
 
@@ -60,6 +52,5 @@ module Ryodo
         [ suffix, [domain.shift], domain ]
       end
     end
-
   end
 end

data/lib/ryodo/suffix_list.rb

@@ -1,21 +1,18 @@
-# coding: utf-8
-
 module Ryodo
-
   class SuffixList
-    def initialize suffix_file = Ryodo::PUBLIC_SUFFIX_STORE
+    def initialize(suffix_file = Ryodo::PUBLIC_SUFFIX_STORE)
       load_file(suffix_file)
     end
 
     def parse_data
       # loads and converts to array
       # "baz.bar.foo" => ["baz", "bar", "foo"]
-      File.readlines(@suffix_file).map{ |line| line.strip.split(".") }
+      File.readlines(@suffix_file).map { |line| line.strip.split(".") }
     end
 
-    def load_file suffix_file = Ryodo::PUBLIC_SUFFIX_STORE
+    def load_file(suffix_file = Ryodo::PUBLIC_SUFFIX_STORE)
       @suffix_file = suffix_file
-      @suffix_data = parse_data
+      @suffix_data = parse_data << ["example"]
     end
 
     def list
@@ -27,12 +24,11 @@ module Ryodo
     end
 
     class << self
-
-      def SuffixList suffix_file = Ryodo::PUBLIC_SUFFIX_STORE
+      def SuffixList(suffix_file = Ryodo::PUBLIC_SUFFIX_STORE)
         instance(suffix_file)
       end
 
-      def reload suffix_file = Ryodo::PUBLIC_SUFFIX_STORE
+      def reload(suffix_file = Ryodo::PUBLIC_SUFFIX_STORE)
         instance.load_file(suffix_file) && true
       end
 
@@ -47,11 +43,8 @@ module Ryodo
       def inspect
         instance.inspect
       end
-
     end
 
     private_class_method :new
-
   end
-
 end

data/lib/ryodo/suffix_list_fetcher.rb

@@ -1,33 +1,40 @@
-# coding: utf-8
-
 require "uri"
 require "net/http"
 
 module Ryodo
-
-  class FetchError < StandardError; end
+  FetchError = Class.new(StandardError)
 
   class SuffixListFetcher
+    class << self
+      def fetch_and_save!(uri = Ryodo::PUBLIC_SUFFIX_DATA_URI, store = Ryodo::PUBLIC_SUFFIX_STORE)
+        fetcher = new(uri, store)
+        fetcher.fetch_data
+        fetcher.prepare_data
+        fetcher.save_data
+        true
+      rescue
+        false
+      end
+    end
 
-    def initialize uri = Ryodo::PUBLIC_SUFFIX_DATA_URI, store = Ryodo::PUBLIC_SUFFIX_STORE
-      @uri = URI(uri)
+    def initialize(uri = Ryodo::PUBLIC_SUFFIX_DATA_URI, store = Ryodo::PUBLIC_SUFFIX_STORE)
+      @uri = URI.parse(uri)
       @store = store
     end
 
     def fetch_data
-      res = Net::HTTP.get_response(@uri)
-      raise Ryodo::FetchError, "Could not fetch suffix data! (#{res})" unless res.is_a?(Net::HTTPSuccess)
-      @fetched_data = res.body.lines
+      http         = Net::HTTP.new(@uri.host, @uri.port)
+      http.use_ssl = @uri.scheme == "https"
+      request      = Net::HTTP::Get.new(@uri.request_uri)
+      response     = http.request(request)
+      fail Ryodo::FetchError, "Could not fetch suffix data! (#{response})" unless response.is_a?(Net::HTTPSuccess)
+      @fetched_data = response.body.lines
     end
 
     def prepare_data
       @prepared_data = @fetched_data.inject([]) do |acc, line|
-        next(acc) if line =~ /^\/\/|^\n/
-        dns_line =  line.strip.
-                      split(".").
-                      reverse.
-                      join(".") # "foo.bar.baz" => "baz.bar.foo"
-        acc << dns_line
+        next(acc) if line =~ %r{\A//|\A\n}
+        acc << reverse_dn(line)
       end.sort
     end
 
@@ -37,18 +44,11 @@ module Ryodo
       end if @prepared_data
     end
 
-    class << self
-      def fetch_and_save! uri = Ryodo::PUBLIC_SUFFIX_DATA_URI, store = Ryodo::PUBLIC_SUFFIX_STORE
-        fetcher = self.new uri, store
-        fetcher.fetch_data
-        fetcher.prepare_data
-        fetcher.save_data
-        true
-      rescue
-        false
-      end
-    end
+    private
 
+    def reverse_dn(domain_name)
+      # "foo.bar.baz" => "baz.bar.foo"
+      domain_name.strip.split(".").reverse.join(".")
+    end
   end
-
 end