ubi 0.0.3

data/lib/ubi/datum.rb

@@ -0,0 +1,43 @@
+module Ubi
+  # Suppose to be html reader
+  class Datum
+    attr_accessor :data, :words, :links
+
+    def initialize(data, words, links)
+      # binding.pry
+      @data = data
+      @words = data.xpath(words).text
+      @links = data.xpath(links).map { |a| a.values.join(' ') }
+    end
+
+    def xpath(path)
+      data.xpath(path)
+    end
+
+    def read_div(div)
+      data.xpath("//#{div}").text
+    end
+
+    def read_list(list, args = [])
+      s = struct_for(args)
+      data.xpath(list).map { |i| s.new(*i.xpath) }
+    end
+
+    def read_table(table, args = [], subs = '')
+      s = struct_for(*args)
+      data.xpath(table).map do |r|
+        s.new(*r.xpath('td/text()').map { |t| normalize(t, subs) })
+      end
+    end
+
+    def normalize(txt, subs = '')
+      txt.to_s.gsub(subs, '').strip.chomp
+    end
+
+    private
+
+    def struct_for(*keys)
+      @struct = Struct.new(*keys)
+    end
+  end
+end

data/lib/ubi/impero.rb

@@ -0,0 +1,20 @@
+require 'paint'
+
+module Ubi
+  # Impero: I command!
+  class Impero < Thor
+    class_option :verbose, type: :boolean, aliases: :v
+
+    # desc 'init', 'creates settings on ~'
+    desc 'find', 'Lookup for something'
+    long_desc <<-LONG
+
+    Find something based only on name
+
+    LONG
+    option :address, type: :string # 'Subject\'s address'
+    def find(name)
+      Ubi::Artifex.new(name).spec
+    end
+  end
+end

data/lib/ubi/memoria.rb

@@ -0,0 +1,72 @@
+module Ubi
+  module Memoria
+    # Memoria Base
+    class Base
+      include ActiveModel::Validations
+      attr_accessor :value
+
+      def initialize(value, aranea = nil, thema = nil)
+        @value = value
+        @aranea = aranea
+        @thema = thema
+      end
+
+      # Format for #to_s
+      def format
+        value.downcase
+      end
+
+      def to_s
+        format
+      end
+
+      class << self
+        #
+        # Account for memorias
+        #
+        def inherited(base)
+          fail "Already defined #{base.key}" if Ubi.memorias.include?(base)
+          puts "With memoria #{base}"
+          Ubi.memorias << base
+        end
+
+        def extract_text(datum)
+          case datum
+          when String then datum
+          when Nokogiri::HTML then datum.data.text
+          else fail "Can't parse `#{datum.class}`"
+          end
+        end
+
+        def parse(datum)
+          fail "Not implemented by #{self}" unless regex
+          extract_text(datum).scan(regex).map { |r| new(r.first) }
+        end
+
+        #
+        # Human-readable name of the aranea
+        #
+        def key
+          @key ||= to_s.split('::').last.downcase.to_sym
+          # fail "Not implemented by #{self}"
+        end
+
+        #
+        # Human-readable name of the aranea
+        #
+        def name
+          to_s.split('::').last
+        end
+
+        def plural
+          "#{key}s"
+        end
+
+        def ==(other)
+          return unless other.respond_to?(:key)
+          key == other.key
+        end
+      end
+    end
+  end
+end

data/lib/ubi/memorias/address.rb

@@ -0,0 +1,71 @@
+module Ubi
+  module Memoria
+    # An adress in this world
+    class Address < Base
+      DIVIDERS = /[,\-\|\/]/
+      SPLIT = /(?<=\D)#{DIVIDERS}|#{DIVIDERS}(?=\D)/
+      REGEXES = {
+        br: {
+          prefix: %w( r rua av avenida pç pça praça pc pca praca tv travessa est estrada rod rodovia ),
+          number: %w( n no nº num numero km ),
+          ext: %w( comp obs ap apto apart apartamento andar  ),
+          zip: /\d{5}[-]\d{3}/
+        },
+        us: {
+          prefix: %w( st street av avenue road ),
+          zip: /\d{5}/
+        }
+      }
+
+      attr_accessor :name, :parts, :words, :zip, :place, :number,
+                    :city, :region, :nation, :extra
+      #
+      #
+      # Init, remove non word chars
+      #
+      def initialize(val, _location = :br)
+        @value = Address.sanitize(val)
+        # @zip = value.match(REGEXES[location][:zip])
+        # @region = value.match(/\W([A-Z]{2})\W/)[1]
+        # @number = value.match(/\w*\d+\w*/)
+
+        @parts = value.split(SPLIT).map { |v| v.strip.chomp }
+        @words = parts.map { |pt| pt.split(/\s+/) }
+      end
+
+      def format(location = :br)
+        value.sub(*self.class.formats[location])
+      end
+
+      class << self
+        #
+        # Sanitizing
+        #
+        # ".." -> "."
+        # "\n" -> "-"
+        # " -" -> "-"
+        #
+        def sanitize(value)
+          value.gsub(/\s+/, ' ').gsub(/\\n/, '-')
+            .gsub(/\s?(#{DIVIDERS})\s?/, '\1')
+        end
+
+        def formats
+          {
+            # br: '%a, %n - %c %z %r',
+            # br: '%a, %n - %c %z %r',
+            br: '%a, %n - %c %z %r'
+          }
+        end
+
+        def regex
+          /((?:#{REGEXES[:br][:prefix].join('|')}).*)/i
+        end
+
+        def plural
+          :addresses
+        end
+      end
+    end
+  end
+end

data/lib/ubi/memorias/document.rb

@@ -0,0 +1,50 @@
+module Ubi
+  module Memoria
+    # Show me your papers!
+    #
+    # https://en.wikipedia.org/wiki/National_identification_number
+    #
+    # br: CNPJ
+    # us: SSN
+    # cl: RUN/RUT
+    #
+    class Document < Base
+      #
+      #
+      # Init, remove non word chars
+      #
+      def initialize(value)
+        @value = value.gsub(/\W/, '')
+      end
+
+      def format(location = :br)
+        value.sub(*self.class.formats[location])
+      end
+
+      #
+      # Class methods
+      #
+      class << self
+        def regexes
+          {
+            br: /(\d{14}|\d{2}\.?\d{3}\.?\d{3}\/?\d{4}[-]?\d{2})/,
+            cl: /\d{2}\.\d{3}\.\d{3}[-][0-9kK]/,
+            us: /\d{3}[-]\d{2}[-]\d{4}/
+          }
+        end
+
+        def formats
+          {
+            br: [/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, '\1.\2.\3/\4-\5'],
+            cl: [/(\d{2})(\d{3})(\d{3})(\d{1})/, '\1.\2.\3-\4'],
+            us: [/(\d{3})(\d{2})(\d{4})/, '\1-\2-\3']
+          }
+        end
+
+        def regex(location = :br)
+          regexes[location]
+        end
+      end
+    end
+  end
+end

data/lib/ubi/memorias/email.rb

@@ -0,0 +1,19 @@
+module Ubi
+  module Memoria
+    # An Electronic Mail
+    class Email < Base
+      #
+      #
+      # Class methods
+      #
+      class << self
+        #
+        # Email regex
+        #
+        def regex
+          %r{([a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)} # rubocop:disable Metrics/LineLength
+        end
+      end
+    end
+  end
+end

data/lib/ubi/memorias/phone.rb

@@ -0,0 +1,33 @@
+module Ubi
+  module Memoria
+    # A Phone! mobile? landline? who is calling???
+    class Phone < Base
+      attr_reader :number, :chunk
+
+      def initialize(chunk, hint = nil)
+        @hint = hint
+        @chunk = chunk
+        parse_number
+      end
+
+      def parse_number
+        @number = Phonelib.parse(chunk.gsub(/\D/, ''), @hint)
+      end
+
+      def to_s
+        number && number.national
+      end
+
+      def rfc
+        number && number.international
+      end
+
+      class << self
+        # http://rubular.com/r/tEHB6KcZzk
+        def regex
+          /(?:^|\s)((?:\+\(?\d{1,3}\W)?[\._\-\/\s]*\(?\s*?\d{2,3}\s*?\)?[\._\-\/\s]*\d{3,5}[\._\-\/\s]*\d{4,5})(?:\s|$)/
+        end
+      end
+    end
+  end
+end

data/lib/ubi/memorias/site.rb

@@ -0,0 +1,29 @@
+module Ubi
+  module Memoria
+    # A site, url and title?
+    class Site < Base
+      #
+      # Prefix http:// if there isn't one defined
+      def format
+        value =~ /http/ ? value : "http://#{value}"
+      end
+
+      class << self
+        #
+        # Regex only for *.tld
+        def regex
+          # %r{https?://((?:\w+[\./]?)+)(?:/|\.)}
+          # (?:\??)[a-zA-Z0-9\-\._\?\,\'\/\\\+&%\$#\=~]+
+          # %r{(?:https?\://)?(?:www\.)?[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}}
+          # ((?:https\:\/\/)|(?:http\:\/\/)|(?:www\.))?([a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(?:\??)[a-zA-Z0-9\-\._\?\,\'\/\\\+&%\$#\=~]+)
+          # http://www.regexr.com/3bkne
+          /([(https?):\/\/(www\.)?a-zA-Z0-9@:%\._\+~#=]{2,256}\.[a-z]{2,6}\b(?:[-a-zA-Z0-9@:%_\+.~#?&\/\/?=]*))/
+        end
+
+        def key
+          :site
+        end
+      end
+    end
+  end
+end

data/lib/ubi/memorias/social.rb

@@ -0,0 +1,20 @@
+module Ubi
+  module Memoria
+    # Social account
+    class Social < Base
+      class << self
+        def apps
+          {
+            twitter: 'twitter.com',
+            facebook: 'facebook.com',
+            foursquare: 'foursquare.com'
+          }
+        end
+
+        def regex
+          %r{https?://(?:\w+\.)*(#{url}/.*)}
+        end
+      end
+    end
+  end
+end

data/lib/ubi/memorias/who.rb

@@ -0,0 +1,20 @@
+module Ubi
+  module Memoria
+    # Whoami
+    class Who < Base
+      class << self
+        def apps
+          {
+            twitter: 'twitter.com',
+            facebook: 'facebook.com',
+            foursquare: 'foursquare.com'
+          }
+        end
+
+        def regex
+          %r{https?://(?:\w+\.)*(#{url}/.*)}
+        end
+      end
+    end
+  end
+end

data/lib/ubi/thema.rb

@@ -0,0 +1,62 @@
+module Ubi
+  #
+  # Thema -> subject, matter, case
+  #
+  class Thema
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Serialization
+    include ActiveModel::Dirty
+
+    attr_accessor :name, :urls, :opts, :ascii, :clean
+
+    def initialize(name, urls = [], opts = {})
+      @name = name
+      @urls = urls
+      @opts = opts
+      @cache = Ubi.memorias.reduce({}) { |a, e| a.merge(e => opts[e]) }
+      reduce_names
+    end
+
+    def araneas
+      @araneas ||= urls.map { |u| Aranea.new(self, u) }
+    end
+
+    def reduce_names
+      @ascii = name.mb_chars.downcase
+      @downcase = name.mb_chars.downcase
+      @clean = @downcase.gsub(/\W/, ' ')
+    end
+
+    Ubi.memorias.each do |memoria|
+      define_method memoria.plural do
+        instance_variable_get('@' + memoria.plural) ||
+          instance_variable_set('@' + memoria.plural, [])
+      end
+    end
+
+    def [](arg)
+      @cache[arg]
+    end
+
+    def spec
+      puts self
+      Ubi.memorias.each do |memoria|
+        print Paint[memoria.name, :black]
+        puts self[memoria.key]
+      end
+    end
+
+    def try_consultor(a)
+      a = a.new(self)
+      Ubi.memorias.each do |m|
+        puts Paint["Trying to find #{m} in #{a.class}", :green]
+        @cache[m] = matches = m.parse(a.datum)
+        puts matches if matches && !matches.empty?
+      end
+    end
+
+    def to_s
+      name
+    end
+  end
+end