crm_formatter 1.0.7.pre.rc.1 → 2.0

data/lib/crm_formatter/csv/seed.csv

@@ -0,0 +1,2 @@
+url,act_name,street,city,state,zip,phone
+http://www.courtesyfordsales.com,Courtesy Ford,__����__����____1410 West Pine Street Hattiesburg,Wexford,MS,39401,512-555-1212

data/lib/crm_formatter/phone.rb

@@ -1,38 +1,46 @@
-module CRMFormatter
-  class Phone
+# frozen_string_literal: false
 
-    ## Checks every phone number in table to verify that it meets phone criteria, then calls format_phone method to format Valid results.  Otherwise destroys Invalid phone fields and associations.
+module CrmFormatter
+  class Phone
+    ## Checks every phone number in table to verify that it meets phone criteria, then calls format_phone method to wrap Valid results.  Otherwise destroys Invalid phone fields and associations.
 
-    # Call: Formatter.new.validate_phone(phone)
+    # Call: Wrap.new.validate_phone(phone)
     def validate_phone(phone)
-      phone_hsh = { phone: phone, valid_phone: nil, phone_edit: false }
-      if phone.present?
-        phone = phone&.gsub(/\s/, ' ')&.strip
-        reg = Regexp.new("[(]?[0-9]{3}[ ]?[)-.]?[ ]?[0-9]{3}[ ]?[-. ][ ]?[0-9]{4}")
-        return phone_hsh if phone.first == "0" || phone.include?("(0") || !reg.match(phone)
-        phone_hsh[:valid_phone] = format_phone(phone)
-        phone_hsh[:phone_edit] = phone_hsh[:phone] != phone_hsh[:valid_phone]
-      end
+      phone_hsh = { phone_status: nil, phone: phone, phone_f: nil }
+      return phone_hsh unless phone.present?
+      phone = phone&.gsub(/\s/, ' ')&.strip
+      reg = Regexp.new('[(]?[0-9]{3}[ ]?[)-.]?[ ]?[0-9]{3}[ ]?[-. ][ ]?[0-9]{4}')
+      phone = nil if phone.first == '0' || phone.include?('(0') || !reg.match(phone)
+      phone_hsh[:phone_f] = format_phone(phone) if phone.present?
+      phone_hsh = check_phone_status(phone_hsh)
       phone_hsh
     end
 
+    ####### COMPARE ORIGINAL AND FORMATTED PHONE ######
+    def check_phone_status(hsh)
+      phone = hsh[:phone]
+      phone_f = hsh[:phone_f]
+      status = 'invalid'
+      status = phone != phone_f ? 'formatted' : 'unchanged' if phone && phone_f
+      hsh[:phone_status] = status if status.present?
+      hsh
+    end
+
     #################################
     ## FORMATS PHONE AS: (000) 000-0000
     ## Assumes phone is legitimate, then formats.  Not designed to detect Valid phone number.
 
-    # Call: Formatter.new.format_phone(phone)
+    # Call: Wrap.new.format_phone(phone)
     def format_phone(phone)
-      regex = Regexp.new("[A-Z]+[a-z]+")
-      if !phone.blank? && (phone != "N/A" || phone != "0") && !regex.match(phone)
-        phone_stripped = phone.gsub(/[^0-9]/, "")
-        (phone_stripped && phone_stripped[0] == "1") ? phone_step2 = phone_stripped[1..-1] : phone_step2 = phone_stripped
-
+      regex = Regexp.new('[A-Z]+[a-z]+')
+      if !phone.blank? && (phone != 'N/A' || phone != '0') && !regex.match(phone)
+        phone_stripped = phone.gsub(/[^0-9]/, '')
+        phone_step2 = phone_stripped && phone_stripped[0] == '1' ? phone_stripped[1..-1] : phone_stripped
         final_phone = !(phone_step2 && phone_step2.length < 10) ? "(#{phone_step2[0..2]}) #{(phone_step2[3..5])}-#{(phone_step2[6..9])}" : phone
       else
         final_phone = nil
       end
-      return final_phone
+      final_phone
     end
-
   end
 end

data/lib/crm_formatter/version.rb

@@ -1,3 +1,5 @@
-module CRMFormatter
-  VERSION = "1.0.7-rc.1"
+# frozen_string_literal: false
+
+module CrmFormatter
+  VERSION = "2.0"
 end

data/lib/crm_formatter/web.rb

@@ -1,64 +1,59 @@
+# frozen_string_literal: false
+
+# require 'rubygems'
+# require 'active_support'
 require 'csv'
 
-module CRMFormatter
+# StartCrm.run_webs
+module CrmFormatter
   class Web
-
-    def initialize(args={})
-      @empty_oa = args.empty?
-      @pos_urls = args.fetch(:pos_urls, [])
-      @neg_urls = args.fetch(:neg_urls, [])
-      @pos_links = args.fetch(:pos_links, [])
-      @neg_links = args.fetch(:neg_links, [])
-      @pos_hrefs = args.fetch(:pos_hrefs, [])
-      @neg_hrefs = args.fetch(:neg_hrefs, [])
-      @pos_exts = args.fetch(:pos_exts, [])
-      @neg_exts = args.fetch(:neg_exts, [])
-      @min_length = args.fetch(:min_length, 2)
-      @max_length = args.fetch(:max_length, 100)
-    end
-
-    def banned_symbols
-      banned_symbols = ["!", "$", "%", "'", "(", ")", "*", "+", ",", "<", ">", "@", "[", "]", "^", "{", "}", "~"]
-    end
-
-    ##Call: StartCrm.run_webs
     def format_url(url)
       prep_result = prep_for_uri(url)
       url_hash = prep_result[:url_hash]
       url = prep_result[:url]
-      url = nil if has_errors(url_hash)
-
-      if url.present?
-        uri_result = run_uri(url_hash, url)
-        url_hash = uri_result[:url_hash]
-        url = uri_result[:url]
-        (url = nil if has_errors(url_hash)) if url.present?
+      url = nil if errors?(url_hash)
+
+      if url&.present?
+        url = normalize_url(url)
+        ext_result = validate_extension(url_hash, url)
+        url_hash = ext_result[:url_hash]
+        url = ext_result[:url]
+        (url = nil if errors?(url_hash)) if url.present?
       end
 
-      url_hash[:formatted_url] = url
-      url_hash = check_reformatted_status(url_hash) if url.present?
+      url_hash = consolidate_negs(url_hash)
+      url_hash[:url_f] = url
+      url_hash = extract_path(url_hash) if url.present?
+      url_hash = check_web_status(url_hash)
       url_hash
     end
 
+    ### COMPARE ORIGINAL AND FORMATTED URL ###
+    def check_web_status(hsh)
+      status = 'invalid' if hsh[:web_neg]&.include?('error')
 
-    def check_reformatted_status(url_hash)
-      formatted = url_hash[:formatted_url]
-      if formatted.present?
-        url_hash[:is_reformatted] = url_hash[:url_path] != formatted
+      if hsh[:url] && hsh[:url_f] && status.nil?
+        status = hsh[:url] != hsh[:url_f] ? 'formatted' : 'unchanged'
       end
-      url_hash
+
+      hsh[:web_status] = status if status.present?
+      hsh
     end
 
+    def consolidate_negs(hsh)
+      neg = hsh[:web_neg].join(', ')
+      hsh[:web_neg] = neg.present? ? neg : nil
+      hsh
+    end
 
-    def has_errors(url_hash)
-      errors = url_hash[:neg].map { |neg| neg.include?('error') }
+    def errors?(url_hash)
+      errors = url_hash[:web_neg].map { |web_neg| web_neg.include?('error') }
       errors.any?
     end
 
-
-    ##Call: StartCrm.run_webs
     def prep_for_uri(url)
-      url_hash = { is_reformatted: false, url_path: url, formatted_url: nil, neg: [], pos: [] }
+      url_hash = { web_status: nil, url: url, url_f: nil, url_path: nil, web_neg: [] }
+
       begin
         url = url&.split('|')&.first
         url = url&.split('\\')&.first
@@ -74,236 +69,108 @@ module CRMFormatter
           url = url[0..-2] if url.present? && url[-1] == '/'
         end
 
-        url = nil if url.present? && banned_symbols.any? {|symb| url&.include?(symb) }
-
-        if url.present?
-          url_hash = compare_criteria(url_hash, url, 'pos_urls', 'include') if !@empty_oa
-          url_hash = compare_criteria(url_hash, url, 'neg_urls', 'include') if !@empty_oa
-        else
-          url_hash[:neg] << "error: syntax"
-          url_hash[:formatted_url] = url
+        banned_symbols = ['!', '$', '%', "'", '(', ')', '*', '+', ',', '<', '>', '@', '[', ']', '^', '{', '}', '~']
+        url = nil if url.present? && banned_symbols.any? { |symb| url&.include?(symb) }
+        unless url.present?
+          url_hash[:web_neg] << 'error: syntax'
+          url_hash[:url_f] = url
         end
-
-      rescue Exception => e
-        url_hash[:neg] << "error: #{e}"
-        url = nil
-        url_hash
-      end
-
-      prep_result = { url_hash: url_hash, url: url }
-    end
-
-
-    ##Call: StartCrm.run_webs
-    def run_uri(url_hash, url)
-      begin
-        uri = URI(url)
-        host_parts = uri.host&.split(".")
-
-        url_hash = compare_criteria(url_hash, host_parts, 'pos_exts', 'equal') if !@empty_oa
-        url_hash = compare_criteria(url_hash, host_parts, 'neg_exts', 'equal') if !@empty_oa
-
-        host = uri.host
-        scheme = uri.scheme
-        url = "#{scheme}://#{host}" if host.present? && scheme.present?
-        url = "http://#{url}" if url[0..3] != "http"
-        url = url.gsub("//", "//www.") if !url.include?("www.")
-        samp_url = convert_to_scheme_host(url)
-
-        url = convert_to_scheme_host(url) if url.present?
-        url_extens_result = check_url_extens(url_hash, url)
-        url_hash = url_extens_result[:url_hash]
-        url = url_extens_result[:url]
-
-      rescue Exception => e
-        url_hash[:neg] << "error: #{e}"
+      rescue StandardError => error
+        url_hash[:web_neg] << "error: #{error}"
         url = nil
         url_hash
       end
-
-      uri_result = { url_hash: url_hash, url: url }
-    end
-
-
-    #Source: http://www.iana.org/domains/root/db
-    #Text: http://data.iana.org/TLD/tlds-alpha-by-domain.txt
-    def check_url_extens(url_hash, url)
-      if url.present?
-        url_extens = URI(url).host&.split(".")[2..-1]
-        if url_extens.count > 1
-          file_path = "./lib/crm_formatter/extensions.csv"
-          extens_list = CSV.read(file_path).flatten
-          valid_url_extens = extens_list & url_extens
-
-          if valid_url_extens.count != 1
-            extens_str = valid_url_extens.map { |ext| ".#{ext}" }.join(', ')
-            url_hash[:neg] << "error: exts.count > 1 [#{extens_str}]"
-            url = nil
-          end
-        end
-      end
-
-      url_hash[:formatted_url] = url
-      url_extens_result = {url_hash: url_hash, url: url}
-    end
-
-
-    ## This process, compare_criteria only runs if client OA args were passed at initialization.
-    ## Results listed in url_hash[:neg]/[:pos], and don't impact or hinder final formatted url.
-    ## Simply adds more details about user's preferences and criteria for the url are.
-
-    def compare_criteria(hash, target, list_name, include_or_equal)
-      unless @empty_oa
-        if list_name.present?
-          criteria_list = instance_variable_get("@#{list_name}")
-
-          if criteria_list.present?
-            if target.is_a?(::String)
-              tars = target.split(', ')
-            else
-              tars = target
-            end
-
-            pn_matches = tars.map do |tar|
-              if criteria_list.present?
-                if include_or_equal == 'include'
-                  criteria_list.select { |el| el if tar.include?(el) }.join(', ')
-                elsif include_or_equal == 'equal'
-                  criteria_list.select { |el| el if tar == el }.join(', ')
-                end
-              end
-            end
-
-            pn_match = pn_matches&.uniq&.sort&.join(', ')
-            if pn_match.present?
-              if list_name.include?('neg')
-                hash[:neg] << "#{list_name}: #{pn_match}"
-              else
-                hash[:pos] << "#{list_name}: #{pn_match}"
-              end
-            end
-          end
-
+      hsh = { url_hash: url_hash, url: url }
+      hsh
+    end
+
+    def normalize_url(url)
+      return unless url.present?
+      uri = URI(url)
+      scheme = uri&.scheme
+      host = uri&.host
+      url = "#{scheme}://#{host}" if host.present? && scheme.present?
+      url = "http://#{url}" if url[0..3] != 'http'
+
+      return unless url.present?
+      url.gsub!('//', '//www.') unless url.include?('www.')
+      url
+    end
+
+    # Source: http://www.iana.org/domains/root/db
+    # Text: http://data.iana.org/TLD/tlds-alpha-by-domain.txt
+    def validate_extension(url_hash, url)
+      return unless url.present?
+      uri_parts = URI(url).host&.split('.')
+      url_exts = uri_parts[2..-1]
+
+      ### Finds Errors
+      if url_exts.empty? ## Missing ext.
+        err_msg = 'error: ext.none'
+      else ## Has ext(s), but need to verify validity and count.
+        file_path = './lib/crm_formatter/csv/extensions.csv'
+        iana_list = CSV.read(file_path).flatten
+        matched_exts = iana_list & url_exts
+
+        if matched_exts.empty? ## Has ext, but not valid.
+          err_msg = "error: ext.invalid [#{url_exts.join(', ')}]"
+        elsif matched_exts.count > 1 ## Has too many valid exts, Limit 1.
+          err_msg = "error: ext.valid > 1 [#{matched_exts.join(', ')}]"
         end
       end
-      
-      hash
-    end
-
-    ###### Supporting Methods Below #######
-
-    def extract_link(url_path)
-      url_hash = format_url(url_path)
-      url = url_hash[:formatted_url]
-      link = url_path
-      link_hsh = {url_path: url_path, url: url, link: nil }
-      if url.present? && link.present? && link.length > @min_length
-        url = strip_down_url(url)
-        link = strip_down_url(link)
-        link&.gsub!(url, '')
-        link = link&.split('.net')&.last
-        link = link&.split('.com')&.last
-        link = link&.split('.org')&.last
-        link = "/#{link.split("/").reject(&:empty?).join("/")}" if link.present?
-        link_hsh[:link] = link if link.present? && link.length > @min_length
-      end
-      link_hsh
-    end
 
-
-    def strip_down_url(url)
-      if url.present?
-        url = url.downcase.strip
-        url = url.gsub('www.', '')
-        url = url.split('://')
-        url = url[-1]
-        return url
+      if err_msg
+        url_hash[:web_neg] << err_msg
+        url = nil
+        url_hash[:url_f] = nil
+        return { url_hash: url_hash, url: url }
       end
-    end
-
 
-    def remove_invalid_links(link)
-      link_hsh = {link: link, valid_link: nil, flags: nil }
-      if link.present?
-        @neg_links += get_symbs
-        flags = @neg_links.select { |red| link&.include?(red) }
-        flags << "below #{@min_length}" if link.length < @min_length
-        flags << "over #{@max_length}" if link.length > @max_length
-        flags = flags.flatten.compact
-        flags.any? ? valid_link = nil : valid_link = link
-        link_hsh[:valid_link] = valid_link
-        link_hsh[:flags] = flags.join(', ')
+      ### Only Non-Errors Get Here ###
+      ## Has one valid ext, but need to check if original url exts were > 1.  Replace if so.
+      if url_exts.count > matched_exts.count
+        inv_ext = (url_exts - matched_exts).join
+        url = url.gsub(".#{inv_ext}", '')
       end
-      link_hsh
-    end
-
-
-    def remove_invalid_hrefs(href)
-      href_hsh = {href: href, valid_href: nil, flags: nil }
-      if href.present?
-        @neg_hrefs += get_symbs
-        href = href.split('|').join(' ')
-        href = href.split('/').join(' ')
-        href&.gsub!("(", ' ')
-        href&.gsub!(")", ' ')
-        href&.gsub!("[", ' ')
-        href&.gsub!("]", ' ')
-        href&.gsub!(",", ' ')
-        href&.gsub!("'", ' ')
 
-        flags = []
-        flags << "over #{@max_length}" if href.length > @max_length
-        invalid_text = Regexp.new(/[0-9]/)
-        flags << invalid_text&.match(href)
-        href = href&.downcase
-        href = href&.strip
-
-        flags << @neg_hrefs.select { |red| href&.include?(red) }
-        flags = flags.flatten.compact.uniq
-        href_hsh[:valid_href] = href unless flags.any?
-        href_hsh[:flags] = flags.join(', ')
-      end
-      href_hsh
+      ext_result = { url_hash: url_hash, url: url }
+      ext_result
     end
 
+    ###### Supporting Methods Below #######
 
-    def convert_to_scheme_host(url)
-      if url.present?
-        uri = URI(url)
-        scheme = uri&.scheme
-        host = uri&.host
-        url = "#{scheme}://#{host}" if (scheme.present? && host.present?)
-        return url
+    def extract_path(url_hash)
+      path_parts = url_hash[:url_f].split('//').last.split('/')[1..-1]
+      path = "/#{path_parts.join('/')}"
+      if path&.length > 2
+        url_hash[:url_path] = path
+        url_hash[:url_f] = url_hash[:url_f].gsub(url_hash[:url_path], '')
       end
+      url_hash
     end
 
-
-    #CALL: Formatter.new.remove_ww3(url)
+    # CALL: Wrap.new.remove_ww3(url)
     def remove_ww3(url)
-      if url.present?
-        url.split('.').map { |part| url.gsub!(part,'www') if part.scan(/ww[0-9]/).any? }
-        url&.gsub!("www.www", "www")
-      end
+      return unless url.present?
+      url.split('.').map { |part| url.gsub!(part, 'www') if part.scan(/ww[0-9]/).any? }
+      url&.gsub!('www.www', 'www')
+      url
     end
 
-
     # For rare cases w/ urls with mistaken double slash twice.
     def remove_slashes(url)
-      if url.present? && url.include?('//')
-        parts = url.split('//')
-        return parts[0..1].join if parts.length > 2
-      end
-      return url
-    end
-
-    ##Call: StartCrm.run_webs
-    # def get_ext_list
-    #   # Source: http://www.iana.org/domains/root/db
-    #   # .txt list: http://data.iana.org/TLD/tlds-alpha-by-domain.txt
-    #   file_path = "./lib/crm_formatter/extensions.csv"
-    #   extensions = CSV.read(file_path)
+      return url unless url.present? && url.include?('//')
+      parts = url.split('//')
+      return parts[0..1].join if parts.length > 2
+      url
+    end
+
+    # def strip_down_url(url)
+    #   return unless url.present?
+    #   url = url.downcase.strip
+    #   url = url.gsub('www.', '')
+    #   url = url.split('://')
+    #   url[-1]
     # end
-
-
   end
 end