ryodo 0.0.2

data/lib/ryodo/convenience/.u.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Ryodo
+  module Convenience
+    module U
+
+      alias_method :ryodo, :Ryodo
+
+      # Unicode junkie? ;o)
+      alias_method :"ryōdo",  :Ryodo
+      alias_method :"領土",    :Ryodo
+      alias_method :"りょうど", :Ryodo
+
+    end
+
+  end
+end
+
+include Ryodo::Convenience::U

data/lib/ryodo/convenience.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Ryodo
+  module Convenience
+
+    def Ryodo(domain_string)
+      Ryodo.parse(domain_string)
+    end
+
+  end
+end
+
+include Ryodo::Convenience

data/lib/ryodo/domain.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module Ryodo
+  class Domain
+
+    # DomainString is a String with extended methods
+    class DomainString < String
+
+      def reverse
+        to_a(:r).join(".")
+      end
+      alias_method :r, :reverse
+
+      def to_a option = nil
+        case option
+        when :reverse, :r
+          dsplit.reverse
+        else
+          dsplit
+        end
+      end
+
+    private
+
+      def dsplit
+        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
+
+      parts = Ryodo::Parser.run(@domain_string)
+
+      @suffix    = parts ? parts[0].reverse.join(".") : nil
+      @domain    = parts && !parts[1].empty? ? (parts[0] + parts[1]).reverse.join(".") : nil
+      @subdomain = parts && !parts[2].empty? ? (parts[2]).reverse.join(".") : nil
+    end
+
+    def suffix
+      DomainString.new @suffix if @suffix
+    end
+    alias_method :tld, :suffix
+
+    def domain
+      DomainString.new @domain if @domain
+    end
+    alias_method :registered_domain, :domain
+    alias_method :regdomain,         :domain
+
+    def subdomain
+      DomainString.new @subdomain if @subdomain
+    end
+
+    def fqdn
+      DomainString.new "#{to_s}."
+    end
+
+    def to_s
+      @domain_string
+    end
+
+    def inspect
+      @domain_string.inspect
+    end
+
+    # pass all missings to @domain_string (String class)
+    def method_missing(name, *args, &block)
+      @domain_string.send(name, *args, &block)
+    end
+
+    # explicit definition of class' send
+    def send(symbol, *args)
+      __send__(symbol, *args)
+    end
+
+  end
+end

data/lib/ryodo/ext/string.rb

@@ -0,0 +1,9 @@
+class String
+
+  def to_domain
+    Ryodo.parse self
+  end
+  alias_method :ryodo,    :to_domain
+  alias_method :to_ryodo, :to_domain
+
+end

data/lib/ryodo/methods.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Ryodo
+  module Methods
+
+    def parse domain_string
+      Ryodo::Domain.new domain_string
+    end
+    alias_method :[], :parse
+
+  end
+end

data/lib/ryodo/parser.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Ryodo
+  class Parser
+
+    def initialize
+      @rules = Ryodo::RuleSet.new
+    end
+
+    def build_query domain
+      if domain.to_s[0] == "."
+        # FQDN in reversed order
+        domain.downcase[1..-1].split(".")
+      else
+        domain.downcase.split(".").reverse
+      end
+    end
+
+    def parse domain
+      @rules.match build_query(domain)
+    end
+
+    class << self
+
+      def run domain
+        instance.parse domain
+      end
+
+
+      def instance
+        @@instance ||= new
+      end
+
+    end
+
+  end
+end

data/lib/ryodo/rule.rb

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

data/lib/ryodo/rule_set.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+module Ryodo
+  class RuleSet
+
+    def initialize
+      @tree = {}
+      build!
+    end
+
+    def build!
+
+      Ryodo::SuffixList.list.each do |line|
+
+        line.each.with_index do |node_name, idx|
+
+          stopOK = node_name == line.last
+          exception = node_name[0] == "!"
+          node_name = node_name[1..-1] if exception
+          children = {}
+
+          node = Ryodo::Rule.new(exception, stopOK, children)
+
+          if idx > 0
+            end_idx = idx - 1
+            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
+
+    def select_rule(rule_path)
+
+      path = rule_path.dup
+
+      if current = path.pop
+
+        if path.empty?
+          @tree[current]
+
+        else
+          rule = select_rule(path)
+          rule.children[current] if rule
+        end
+
+      end
+
+    end
+
+    def match(path)
+      suffix, domain, match = [], [], nil
+
+      until match || path.empty?
+        match = select_rule(path) || select_rule(path.dup.fill("*",-1))
+        match = nil if match && !match.is_suffix?
+        domain.unshift path.pop
+        suffix = path
+      end
+
+      suffix.push(domain.shift) if match && !match.exception
+
+      # only if match has no children with domain and domain is present
+      if match && !match.children.keys.include?(domain[0]) && domain[0]
+        [ suffix, [domain.shift], domain ]
+      end
+
+    end
+
+  end
+end

data/lib/ryodo/suffix_list.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module Ryodo
+
+  class SuffixList
+    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(".") }
+    end
+
+    def load_file suffix_file = Ryodo::PUBLIC_SUFFIX_STORE
+      @suffix_file = suffix_file
+      @suffix_data = parse_data
+    end
+
+    def list
+      @suffix_data
+    end
+
+    def inspect
+      "#<#{self.class} FILE:#{@suffix_file} ENTRIES:#{@suffix_data.size}>"
+    end
+
+    class << self
+
+      def SuffixList suffix_file = Ryodo::PUBLIC_SUFFIX_STORE
+        instance(suffix_file)
+      end
+
+      def reload suffix_file = Ryodo::PUBLIC_SUFFIX_STORE
+        instance.load_file(suffix_file) && true
+      end
+
+      def list
+        instance.list
+      end
+
+      def instance
+        @@instance ||= new
+      end
+
+      def inspect
+        instance.inspect
+      end
+
+    end
+
+    private_class_method :new
+
+  end
+
+end

data/lib/ryodo/suffix_list_fetcher.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require "uri"
+require "net/http"
+
+module Ryodo
+
+  class FetchError < StandardError; end
+
+  class SuffixListFetcher
+
+    def initialize uri = Ryodo::PUBLIC_SUFFIX_DATA_URI, store = Ryodo::PUBLIC_SUFFIX_STORE
+      @uri = URI(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
+    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
+      end.sort
+    end
+
+    def save_data
+      File.open(Ryodo::PUBLIC_SUFFIX_STORE, "w") do |fh|
+        fh.write @prepared_data.join("\n")
+      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
+
+  end
+
+end

data/lib/ryodo.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Ryodo
+
+  VERSION_FILE = File.expand_path("../../VERSION", __FILE__)
+  VERSION      = File.exist?(VERSION_FILE) ? File.read(VERSION_FILE) : "(could not find VERSION file)"
+
+  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_STORE    = "#{RYODO_ROOT}/data/suffix.dat"
+
+end
+
+require "ryodo/domain"
+require "ryodo/parser"
+require "ryodo/rule"
+require "ryodo/rule_set"
+require "ryodo/suffix_list"
+
+require "ryodo/methods"
+require "ryodo/ext/string"
+
+# Convenient shorthands
+module Ryodo
+  extend Ryodo::Methods
+  require "ryodo/convenience"
+  require "ryodo/convenience/.u" unless Kernel.const_defined?("RYODO_NO_U") || ENV['RYODO_NO_U']
+end