nano-pure-pkg 0.0.1

data/ahoy_matey-5.5.0/lib/ahoy/tracker.rb

@@ -0,0 +1,287 @@
+require "active_support/core_ext/digest/uuid"
+
+module Ahoy
+  class Tracker
+    UUID_NAMESPACE = "a82ae811-5011-45ab-a728-569df7499c5f"
+
+    attr_reader :request, :controller
+
+    def initialize(**options)
+      @store = Ahoy::Store.new(options.merge(ahoy: self))
+      @controller = options[:controller]
+      @request = options[:request] || @controller.try(:request)
+      @visit_token = options[:visit_token]
+      @user = options[:user]
+      @options = options
+    end
+
+    # can't use keyword arguments here
+    def track(name, properties = {}, options = {})
+      if exclude?
+        debug "Event excluded"
+      else
+        data = {
+          visit_token: visit_token,
+          user_id: user.try(:id),
+          name: name.to_s,
+          properties: properties,
+          time: trusted_time(options[:time]),
+          event_id: options[:id] || generate_id
+        }.select { |_, v| v }
+
+        @store.track_event(data)
+      end
+      true
+    rescue => e
+      report_exception(e)
+    end
+
+    def track_visit(defer: false, started_at: nil)
+      if exclude?
+        debug "Visit excluded"
+      else
+        if defer
+          set_cookie("ahoy_track", true, nil, false)
+        else
+          delete_cookie("ahoy_track", false)
+
+          data = {
+            visit_token: visit_token,
+            visitor_token: visitor_token,
+            user_id: user.try(:id),
+            started_at: trusted_time(started_at)
+          }.merge(visit_properties).select { |_, v| v }
+
+          @store.track_visit(data)
+
+          Ahoy::GeocodeV2Job.perform_later(visit_token, data[:ip]) if Ahoy.geocode && data[:ip]
+        end
+      end
+      true
+    rescue => e
+      report_exception(e)
+    end
+
+    def geocode(data)
+      data = {
+        visit_token: visit_token
+      }.merge(data).select { |_, v| v }
+
+      @store.geocode(data)
+      true
+    rescue => e
+      report_exception(e)
+    end
+
+    def authenticate(user)
+      if exclude?
+        debug "Authentication excluded"
+      else
+        @store.user = user
+
+        data = {
+          visit_token: visit_token,
+          user_id: user.try(:id)
+        }
+        @store.authenticate(data)
+      end
+      true
+    rescue => e
+      report_exception(e)
+    end
+
+    def visit
+      @visit ||= @store.visit
+    end
+
+    def visit_or_create
+      @visit ||= @store.visit_or_create
+    end
+
+    def new_visit?
+      Ahoy.cookies? ? !existing_visit_token : visit.nil?
+    end
+
+    def new_visitor?
+      !existing_visitor_token
+    end
+
+    def set_visit_cookie
+      set_cookie("ahoy_visit", visit_token, Ahoy.visit_duration)
+    end
+
+    def set_visitor_cookie
+      if new_visitor?
+        set_cookie("ahoy_visitor", visitor_token, Ahoy.visitor_duration)
+      end
+    end
+
+    def user
+      @user ||= @store.user
+    end
+
+    def visit_properties
+      @visit_properties ||= request ? Ahoy::VisitProperties.new(request, api: api?).generate : {}
+    end
+
+    def visit_token
+      @visit_token ||= ensure_token(visit_token_helper)
+    end
+    alias_method :visit_id, :visit_token
+
+    def visitor_token
+      @visitor_token ||= ensure_token(visitor_token_helper)
+    end
+    alias_method :visitor_id, :visitor_token
+
+    def reset
+      reset_visit
+      delete_cookie("ahoy_visitor")
+    end
+
+    def reset_visit
+      delete_cookie("ahoy_visit")
+      delete_cookie("ahoy_events")
+      delete_cookie("ahoy_track", false)
+    end
+
+    def exclude?
+      unless defined?(@exclude)
+        @exclude = @store.exclude?
+      end
+      @exclude
+    end
+
+    protected
+
+    def api?
+      @options[:api]
+    end
+
+    # private, but used by API
+    def missing_params?
+      if Ahoy.cookies? && api? && Ahoy.protect_from_forgery
+        !(existing_visit_token && existing_visitor_token)
+      else
+        false
+      end
+    end
+
+    def set_cookie(name, value, duration = nil, use_domain = true)
+      # safety net
+      return unless Ahoy.cookies? && request
+
+      cookie = Ahoy.cookie_options.merge(value: value)
+      cookie[:expires] = duration.from_now if duration
+      # prefer cookie_options[:domain] over cookie_domain
+      cookie[:domain] ||= Ahoy.cookie_domain if Ahoy.cookie_domain
+      cookie.delete(:domain) unless use_domain
+      request.cookie_jar[name] = cookie
+    end
+
+    def delete_cookie(name, use_domain = true)
+      if request && request.cookie_jar[name]
+        options = Ahoy.cookie_options.slice(:path)
+        if use_domain
+          domain = Ahoy.cookie_options[:domain] || Ahoy.cookie_domain
+          options[:domain] = domain if domain
+        end
+        request.cookie_jar.delete(name, **options)
+      end
+    end
+
+    def trusted_time(time = nil)
+      if !time || (api? && !(1.minute.ago..Time.now).cover?(time))
+        Time.current
+      else
+        time
+      end
+    end
+
+    def report_exception(e)
+      if defined?(ActionDispatch::RemoteIp::IpSpoofAttackError) && e.is_a?(ActionDispatch::RemoteIp::IpSpoofAttackError)
+        debug "Tracking excluded due to IP spoofing"
+      else
+        raise e if !defined?(Rails) || Rails.env.development? || Rails.env.test?
+        Safely.report_exception(e)
+      end
+    end
+
+    def generate_id
+      @store.generate_id
+    end
+
+    def visit_token_helper
+      @visit_token_helper ||= begin
+        token = existing_visit_token
+        token ||= visit&.visit_token unless Ahoy.cookies?
+        token ||= generate_id unless Ahoy.api_only
+        token
+      end
+    end
+
+    def visitor_token_helper
+      @visitor_token_helper ||= begin
+        token = existing_visitor_token
+        token ||= visitor_anonymity_set unless Ahoy.cookies?
+        token ||= generate_id unless Ahoy.api_only
+        token
+      end
+    end
+
+    def existing_visit_token
+      @existing_visit_token ||= begin
+        token = visit_header
+        token ||= visit_cookie if Ahoy.cookies? && !(api? && Ahoy.protect_from_forgery)
+        token ||= visit_param if api?
+        token
+      end
+    end
+
+    def existing_visitor_token
+      @existing_visitor_token ||= begin
+        token = visitor_header
+        token ||= visitor_cookie if Ahoy.cookies? && !(api? && Ahoy.protect_from_forgery)
+        token ||= visitor_param if api?
+        token
+      end
+    end
+
+    def visitor_anonymity_set
+      @visitor_anonymity_set ||= request && Digest::UUID.uuid_v5(UUID_NAMESPACE, ["visitor", Ahoy.mask_ip(request.remote_ip), request.user_agent].join("/"))
+    end
+
+    def visit_cookie
+      @visit_cookie ||= request && request.cookies["ahoy_visit"]
+    end
+
+    def visitor_cookie
+      @visitor_cookie ||= request && request.cookies["ahoy_visitor"]
+    end
+
+    def visit_header
+      @visit_header ||= request && request.headers["Ahoy-Visit"]
+    end
+
+    def visitor_header
+      @visitor_header ||= request && request.headers["Ahoy-Visitor"]
+    end
+
+    def visit_param
+      @visit_param ||= request && request.params["visit_token"]
+    end
+
+    def visitor_param
+      @visitor_param ||= request && request.params["visitor_token"]
+    end
+
+    def ensure_token(token)
+      token = Ahoy::Utils.ensure_utf8(token)
+      token.to_s.gsub(/[^a-z0-9\-]/i, "").first(64) if token
+    end
+
+    def debug(message)
+      Ahoy.log message
+    end
+  end
+end

data/ahoy_matey-5.5.0/lib/ahoy/utils.rb

@@ -0,0 +1,7 @@
+module Ahoy
+  module Utils
+    def self.ensure_utf8(str)
+      str.encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "") if str
+    end
+  end
+end

data/ahoy_matey-5.5.0/lib/ahoy/version.rb

@@ -0,0 +1,3 @@
+module Ahoy
+  VERSION = "5.5.0"
+end

data/ahoy_matey-5.5.0/lib/ahoy/visit_properties.rb

@@ -0,0 +1,122 @@
+require "cgi"
+require "device_detector"
+require "uri"
+
+module Ahoy
+  class VisitProperties
+    attr_reader :request, :params, :referrer, :landing_page
+
+    def initialize(request, api:)
+      @request = request
+      @params = request.params
+      @referrer = api ? params["referrer"] : request.referer
+      @landing_page = api ? params["landing_page"] : request.original_url
+    end
+
+    def generate
+      @generate ||= request_properties.merge(tech_properties).merge(traffic_properties).merge(utm_properties)
+    end
+
+    private
+
+    def utm_properties
+      landing_params = {}
+      begin
+        landing_uri = URI.parse(landing_page)
+        # could also use Rack::Utils.parse_nested_query
+        landing_params = CGI.parse(landing_uri.query) if landing_uri
+      rescue
+        # do nothing
+      end
+
+      props = {}
+      %w(utm_source utm_medium utm_term utm_content utm_campaign).each do |name|
+        props[name.to_sym] = params[name] || landing_params[name].try(:first)
+      end
+      props
+    end
+
+    def traffic_properties
+      uri = URI.parse(referrer) rescue nil
+      {
+        referring_domain: uri.try(:host).try(:first, 255)
+      }
+    end
+
+    def tech_properties
+      if Ahoy.user_agent_parser == :device_detector
+        client = DeviceDetector.new(request.user_agent)
+        device_type =
+          case client.device_type
+          when "smartphone"
+            "Mobile"
+          when "tv"
+            "TV"
+          else
+            client.device_type.try(:titleize)
+          end
+
+        {
+          browser: client.name,
+          os: client.os_name,
+          device_type: device_type
+        }
+      else
+        raise "Add browser to your Gemfile to use legacy user agent parsing" unless defined?(Browser)
+        raise "Add user_agent_parser to your Gemfile to use legacy user agent parsing" unless defined?(UserAgentParser)
+
+        # cache for performance
+        @@user_agent_parser ||= UserAgentParser::Parser.new
+
+        user_agent = request.user_agent
+        agent = @@user_agent_parser.parse(user_agent)
+        browser = Browser.new(user_agent)
+        device_type =
+          if browser.bot?
+            "Bot"
+          elsif browser.device.tv?
+            "TV"
+          elsif browser.device.console?
+            "Console"
+          elsif browser.device.tablet?
+            "Tablet"
+          elsif browser.device.mobile?
+            "Mobile"
+          else
+            "Desktop"
+          end
+
+        {
+          browser: agent.name,
+          os: agent.os.name,
+          device_type: device_type
+        }
+      end
+    end
+
+    # masking based on Google Analytics anonymization
+    # https://support.google.com/analytics/answer/2763052
+    def ip
+      ip = request.remote_ip
+      if ip && Ahoy.mask_ips
+        Ahoy.mask_ip(ip)
+      else
+        ip
+      end
+    end
+
+    def request_properties
+      {
+        ip: ip,
+        user_agent: Ahoy::Utils.ensure_utf8(request.user_agent),
+        referrer: referrer,
+        landing_page: landing_page,
+        platform: params["platform"],
+        app_version: params["app_version"],
+        os_version: params["os_version"],
+        screen_height: params["screen_height"],
+        screen_width: params["screen_width"]
+      }
+    end
+  end
+end

data/ahoy_matey-5.5.0/lib/ahoy/warden.rb

@@ -0,0 +1,5 @@
+Warden::Manager.after_set_user except: :fetch do |user, auth, _|
+  request = ActionDispatch::Request.new(auth.env)
+  ahoy = Ahoy::Tracker.new(request: request)
+  ahoy.authenticate(user)
+end

data/ahoy_matey-5.5.0/lib/ahoy.rb

@@ -0,0 +1,167 @@
+# stdlib
+require "ipaddr"
+
+# dependencies
+require "active_support"
+require "active_support/core_ext"
+require "safely/core"
+
+# modules
+require_relative "ahoy/utils"
+require_relative "ahoy/base_store"
+require_relative "ahoy/controller"
+require_relative "ahoy/database_store"
+require_relative "ahoy/helper"
+require_relative "ahoy/model"
+require_relative "ahoy/query_methods"
+require_relative "ahoy/tracker"
+require_relative "ahoy/version"
+require_relative "ahoy/visit_properties"
+
+require_relative "ahoy/engine" if defined?(Rails)
+
+module Ahoy
+  # activejob optional
+  autoload :GeocodeV2Job, "ahoy/geocode_v2_job"
+
+  mattr_accessor :visit_duration
+  self.visit_duration = 4.hours
+
+  mattr_accessor :visitor_duration
+  self.visitor_duration = 2.years
+
+  def self.cookies=(value)
+    if value == false
+      if defined?(Mongoid::Document) && defined?(Ahoy::Visit) && Ahoy::Visit < Mongoid::Document
+        raise <<~EOS
+          This feature requires a new index in Ahoy 5. Set:
+
+            class Ahoy::Visit
+              index({visitor_token: 1, started_at: 1})
+            end
+
+          Create the index before upgrading, and set:
+
+            Ahoy.cookies = :none
+        EOS
+      else
+        raise <<~EOS
+          This feature requires a new index in Ahoy 5. Create a migration with:
+
+            add_index :ahoy_visits, [:visitor_token, :started_at]
+
+          Run it before upgrading, and set:
+
+            Ahoy.cookies = :none
+        EOS
+      end
+    end
+    @@cookies = value
+  end
+
+  mattr_reader :cookies
+  self.cookies = true
+
+  # TODO deprecate in favor of cookie_options
+  mattr_accessor :cookie_domain
+
+  mattr_accessor :cookie_options
+  self.cookie_options = {}
+
+  mattr_accessor :server_side_visits
+  self.server_side_visits = true
+
+  mattr_accessor :quiet
+  self.quiet = true
+
+  mattr_accessor :geocode
+  self.geocode = false
+
+  mattr_accessor :max_content_length
+  self.max_content_length = 8192
+
+  mattr_accessor :max_events_per_request
+  self.max_events_per_request = 10
+
+  mattr_accessor :job_queue
+  self.job_queue = :ahoy
+
+  mattr_accessor :api
+  self.api = false
+
+  mattr_accessor :api_only
+  self.api_only = false
+
+  mattr_accessor :protect_from_forgery
+  self.protect_from_forgery = true
+
+  mattr_accessor :preserve_callbacks
+  self.preserve_callbacks = [:load_authlogic, :activate_authlogic]
+
+  mattr_accessor :user_method
+  self.user_method = lambda do |controller|
+    (controller.respond_to?(:current_user, true) && controller.send(:current_user)) || (controller.respond_to?(:current_resource_owner, true) && controller.send(:current_resource_owner)) || nil
+  end
+
+  mattr_accessor :exclude_method
+
+  mattr_accessor :track_bots
+  self.track_bots = false
+
+  mattr_accessor :bot_detection_version
+  self.bot_detection_version = 2
+
+  mattr_accessor :token_generator
+  self.token_generator = -> { SecureRandom.uuid }
+
+  mattr_accessor :mask_ips
+  self.mask_ips = false
+
+  mattr_accessor :user_agent_parser
+  self.user_agent_parser = :device_detector
+
+  mattr_accessor :logger
+
+  def self.log(message)
+    logger.info { "[ahoy] #{message}" } if logger
+  end
+
+  def self.cookies?
+    cookies && cookies != :none
+  end
+
+  def self.mask_ip(ip)
+    addr = IPAddr.new(ip)
+    if addr.ipv4?
+      # set last octet to 0
+      addr.mask(24).to_s
+    else
+      # set last 80 bits to zeros
+      addr.mask(48).to_s
+    end
+  end
+
+  def self.instance
+    Thread.current[:ahoy]
+  end
+
+  def self.instance=(value)
+    Thread.current[:ahoy] = value
+  end
+end
+
+ActiveSupport.on_load(:action_controller) do
+  include Ahoy::Controller
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend Ahoy::Model
+end
+
+ActiveSupport.on_load(:action_view) do
+  include Ahoy::Helper
+end
+
+ActiveSupport.on_load(:mongoid) do
+  Mongoid::Document::ClassMethods.include(Ahoy::Model)
+end

data/ahoy_matey-5.5.0/lib/ahoy_matey.rb

@@ -0,0 +1 @@
+require_relative "ahoy"

data/ahoy_matey-5.5.0/lib/generators/ahoy/activerecord_generator.rb

@@ -0,0 +1,59 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Ahoy
+  module Generators
+    class ActiverecordGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      source_root File.join(__dir__, "templates")
+
+      class_option :database, type: :string, aliases: "-d"
+
+      def copy_templates
+        template "database_store_initializer.rb", "config/initializers/ahoy.rb"
+        template "active_record_visit_model.rb", "app/models/ahoy/visit.rb"
+        template "active_record_event_model.rb", "app/models/ahoy/event.rb"
+        migration_template "active_record_migration.rb", "db/migrate/create_ahoy_visits_and_events.rb", migration_version: migration_version
+        puts "\nAlmost set! Last, run:\n\n    rails db:migrate"
+      end
+
+      def properties_type
+        case adapter
+        when /postg/i # postgres, postgis
+          "jsonb"
+        when /mysql|trilogy/i
+          "json"
+        else
+          "text"
+        end
+      end
+
+      # requires database connection to check for MariaDB
+      def serialize_properties?
+        properties_type == "text" || (properties_type == "json" && ActiveRecord::Base.connection.try(:mariadb?))
+      end
+
+      # use connection_db_config instead of connection.adapter
+      # so database connection isn't needed
+      def adapter
+        ActiveRecord::Base.connection_db_config.adapter.to_s
+      end
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+
+      def primary_key_type
+        ", id: :#{key_type}" if key_type
+      end
+
+      def foreign_key_type
+        ", type: :#{key_type}" if key_type
+      end
+
+      def key_type
+        Rails.configuration.generators.options.dig(:active_record, :primary_key_type)
+      end
+    end
+  end
+end

data/ahoy_matey-5.5.0/lib/generators/ahoy/base_generator.rb

@@ -0,0 +1,13 @@
+require "rails/generators"
+
+module Ahoy
+  module Generators
+    class BaseGenerator < Rails::Generators::Base
+      source_root File.join(__dir__, "templates")
+
+      def copy_templates
+        template "base_store_initializer.rb", "config/initializers/ahoy.rb"
+      end
+    end
+  end
+end