nano-pure-pkg 0.0.1

data/ahoy_matey-5.5.0/app/controllers/ahoy/base_controller.rb

@@ -0,0 +1,44 @@
+module Ahoy
+  class BaseController < ApplicationController
+    filters = _process_action_callbacks.map(&:filter) - Ahoy.preserve_callbacks
+    skip_before_action(*filters, raise: false)
+    skip_after_action(*filters, raise: false)
+    skip_around_action(*filters, raise: false)
+
+    if respond_to?(:protect_from_forgery)
+      protect_from_forgery with: :null_session, if: -> { Ahoy.protect_from_forgery }
+    end
+
+    before_action :verify_request_size
+    before_action :check_params
+    before_action :renew_cookies
+
+    protected
+
+    def ahoy
+      @ahoy ||= Ahoy::Tracker.new(controller: self, api: true)
+    end
+
+    def check_params
+      if ahoy.send(:missing_params?)
+        logger.info "[ahoy] Missing required parameters"
+        render plain: "Missing required parameters\n", status: :bad_request
+      end
+    end
+
+    # set proper ttl if cookie generated from JavaScript
+    # approach is not perfect, as user must reload the page
+    # for new cookie settings to take effect
+    def renew_cookies
+      set_ahoy_cookies if params[:js] && !Ahoy.api_only
+    end
+
+    def verify_request_size
+      if request.content_length > Ahoy.max_content_length
+        logger.info "[ahoy] Payload too large"
+        status = Rack::RELEASE.to_f >= 3.1 ? :content_too_large : :payload_too_large
+        render plain: "Payload too large\n", status: status
+      end
+    end
+  end
+end

data/ahoy_matey-5.5.0/app/controllers/ahoy/events_controller.rb

@@ -0,0 +1,51 @@
+module Ahoy
+  class EventsController < Ahoy::BaseController
+    def create
+      events =
+        if params[:name]
+          # legacy API and AMP
+          [request.params]
+        elsif params[:events]
+          request.params[:events]
+        else
+          data =
+            if params[:events_json]
+              request.params[:events_json]
+            else
+              request.body.read
+            end
+          begin
+            ActiveSupport::JSON.decode(data)
+          rescue ActiveSupport::JSON.parse_error
+            # TODO change to nil in Ahoy 6
+            []
+          end
+        end
+
+      max_events_per_request = Ahoy.max_events_per_request
+
+      # check before creating any events
+      unless events.is_a?(Array) && events.first(max_events_per_request).all? { |v| v.is_a?(Hash) }
+        logger.info "[ahoy] Invalid parameters"
+        # :unprocessable_entity is probably more correct
+        # but keep consistent with missing parameters for now
+        render plain: "Invalid parameters\n", status: :bad_request
+        return
+      end
+
+      events.first(max_events_per_request).each do |event|
+        time = Time.zone.parse(event["time"]) rescue nil
+
+        # timestamp is deprecated
+        time ||= Time.zone.at(event["time"].to_f) rescue nil
+
+        options = {
+          id: event["id"],
+          time: time
+        }
+        ahoy.track event["name"], event["properties"], options
+      end
+      render json: {}
+    end
+  end
+end

data/ahoy_matey-5.5.0/app/controllers/ahoy/visits_controller.rb

@@ -0,0 +1,15 @@
+module Ahoy
+  class VisitsController < BaseController
+    def create
+      ahoy.track_visit
+
+      render json: {
+        visit_token: ahoy.visit_token,
+        visitor_token: ahoy.visitor_token,
+        # legacy
+        visit_id: ahoy.visit_token,
+        visitor_id: ahoy.visitor_token
+      }
+    end
+  end
+end

data/ahoy_matey-5.5.0/config/routes.rb

@@ -0,0 +1,10 @@
+Rails.application.routes.draw do
+  mount Ahoy::Engine => "/ahoy" if Ahoy.api
+end
+
+Ahoy::Engine.routes.draw do
+  scope module: "ahoy" do
+    resources :visits, only: [:create]
+    resources :events, only: [:create]
+  end
+end

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

@@ -0,0 +1,104 @@
+module Ahoy
+  class BaseStore
+    attr_writer :user
+
+    def initialize(options)
+      @user = options[:user]
+      @options = options
+    end
+
+    def track_visit(data)
+    end
+
+    def track_event(data)
+    end
+
+    def geocode(data)
+    end
+
+    def authenticate(data)
+    end
+
+    def visit
+    end
+
+    def user
+      @user ||= begin
+        if Ahoy.user_method.respond_to?(:call)
+          if Ahoy.user_method.arity == 1
+            Ahoy.user_method.call(controller)
+          else
+            Ahoy.user_method.call(controller, request)
+          end
+        else
+          controller.send(Ahoy.user_method) if controller.respond_to?(Ahoy.user_method, true)
+        end
+      end
+    end
+
+    def exclude?
+      (!Ahoy.track_bots && bot?) ||
+        exclude_by_method? ||
+        (defined?(Rails::HealthController) && controller.is_a?(Rails::HealthController))
+    end
+
+    def generate_id
+      Ahoy.token_generator.call
+    end
+
+    def visit_or_create
+      visit
+    end
+
+    protected
+
+    def bot?
+      unless defined?(@bot)
+        @bot = begin
+          if request
+            if Ahoy.user_agent_parser == :device_detector
+              detector = DeviceDetector.new(request.user_agent)
+              if Ahoy.bot_detection_version == 2
+                detector.bot? || (detector.device_type.nil? && detector.os_name.nil?)
+              else
+                detector.bot?
+              end
+            else
+              # no need to throw friendly error if browser isn't defined
+              # since will error in visit_properties
+              Browser.new(request.user_agent).bot?
+            end
+          else
+            false
+          end
+        end
+      end
+
+      @bot
+    end
+
+    def exclude_by_method?
+      if Ahoy.exclude_method
+        if Ahoy.exclude_method.arity == 1
+          Ahoy.exclude_method.call(controller)
+        else
+          Ahoy.exclude_method.call(controller, request)
+        end
+      else
+        false
+      end
+    end
+
+    def request
+      @request ||= @options[:request] || controller.try(:request)
+    end
+
+    def controller
+      @controller ||= @options[:controller]
+    end
+
+    def ahoy
+      @ahoy ||= @options[:ahoy]
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Ahoy
+  module Controller
+    def self.included(base)
+      if base.respond_to?(:helper_method)
+        base.helper_method :current_visit
+        base.helper_method :ahoy
+      end
+      base.before_action :track_ahoy_visit, unless: -> { Ahoy.api_only }
+      base.around_action :set_ahoy_request_store, unless: -> { Ahoy.api_only }
+    end
+
+    def ahoy
+      @ahoy ||= Ahoy::Tracker.new(controller: self)
+    end
+
+    def current_visit
+      ahoy.visit
+    end
+
+    def set_ahoy_cookies
+      if Ahoy.cookies?
+        ahoy.set_visitor_cookie
+        ahoy.set_visit_cookie
+      else
+        # delete cookies if exist
+        ahoy.reset
+      end
+    end
+
+    def track_ahoy_visit
+      defer = Ahoy.server_side_visits != true
+
+      if defer && !Ahoy.cookies?
+        # avoid calling new_visit?, which triggers a database call
+      elsif !Ahoy.cookies? && ahoy.exclude?
+        # avoid calling new_visit?, which triggers a database call
+        # may or may not be a new visit
+        Ahoy.log("Request excluded")
+      elsif ahoy.new_visit?
+        ahoy.track_visit(defer: defer)
+      end
+
+      set_ahoy_cookies
+    end
+
+    def set_ahoy_request_store
+      previous_value = Ahoy.instance
+      begin
+        Ahoy.instance = ahoy
+        yield
+      ensure
+        Ahoy.instance = previous_value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module Ahoy
+  class DatabaseStore < BaseStore
+    def track_visit(data)
+      @visit = visit_model.create!(slice_data(visit_model, data))
+    rescue => e
+      raise e unless unique_exception?(e)
+
+      # so next call to visit will try to fetch from DB
+      if defined?(@visit)
+        remove_instance_variable(:@visit)
+      end
+    end
+
+    def track_event(data)
+      visit = visit_or_create(started_at: data[:time])
+      if visit
+        event = event_model.new(slice_data(event_model, data))
+        event.visit = visit
+        event.time = visit.started_at if event.time < visit.started_at
+        begin
+          event.save!
+        rescue => e
+          raise e unless unique_exception?(e)
+        end
+      else
+        Ahoy.log "Event excluded since visit not created: #{data[:visit_token]}"
+      end
+    end
+
+    def geocode(data)
+      visit_token = data.delete(:visit_token)
+      data = slice_data(visit_model, data)
+      if defined?(Mongoid::Document) && visit_model < Mongoid::Document
+        # upsert since visit might not be found due to eventual consistency
+        visit_model.where(visit_token: visit_token).find_one_and_update({"$set": data}, {upsert: true})
+      elsif visit
+        visit.update!(data)
+      else
+        Ahoy.log "Visit for geocode not found: #{visit_token}"
+      end
+    end
+
+    def authenticate(_)
+      if visit && visit.respond_to?(:user) && !visit.user
+        begin
+          visit.user = user
+          visit.save!
+        rescue ActiveRecord::AssociationTypeMismatch
+          # do nothing
+        end
+      end
+    end
+
+    def visit
+      unless defined?(@visit)
+        if ahoy.send(:existing_visit_token) || ahoy.instance_variable_get(:@visit_token)
+          # find_by raises error by default with Mongoid when not found
+          @visit = visit_model.where(visit_token: ahoy.visit_token).take if ahoy.visit_token
+        elsif !Ahoy.cookies? && ahoy.visitor_token
+          @visit = visit_model.where(visitor_token: ahoy.visitor_token).where(started_at: Ahoy.visit_duration.ago..).order(started_at: :desc).first
+        else
+          @visit = nil
+        end
+      end
+      @visit
+    end
+
+    # if we don't have a visit, let's try to create one first
+    def visit_or_create(started_at: nil)
+      ahoy.track_visit(started_at: started_at) if !visit && Ahoy.server_side_visits
+      visit
+    end
+
+    protected
+
+    def visit_model
+      ::Ahoy::Visit
+    end
+
+    def event_model
+      ::Ahoy::Event
+    end
+
+    def slice_data(model, data)
+      column_names = model.try(:column_names) || model.attribute_names
+      data.slice(*column_names.map(&:to_sym)).select { |_, v| !v.nil? }
+    end
+
+    def unique_exception?(e)
+      return true if defined?(ActiveRecord::RecordNotUnique) && e.is_a?(ActiveRecord::RecordNotUnique)
+      return true if defined?(PG::UniqueViolation) && e.is_a?(PG::UniqueViolation)
+      return true if defined?(Mongo::Error::OperationFailure) && e.is_a?(Mongo::Error::OperationFailure) && e.message.include?("duplicate key error")
+      false
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Ahoy
+  class Engine < ::Rails::Engine
+    initializer "ahoy", after: "sprockets.environment" do
+      Ahoy.logger ||= Rails.logger
+
+      # allow Devise to be loaded after Ahoy
+      require "ahoy/warden" if defined?(Warden)
+
+      next unless Ahoy.quiet
+
+      # Parse PATH_INFO by assets prefix
+      AHOY_PREFIX = "/ahoy/".freeze
+
+      # Just create an alias for call in middleware
+      Rails::Rack::Logger.class_eval do
+        def call_with_quiet_ahoy(env)
+          if env["PATH_INFO"].start_with?(AHOY_PREFIX) && logger.respond_to?(:silence)
+            logger.silence do
+              call_without_quiet_ahoy(env)
+            end
+          else
+            call_without_quiet_ahoy(env)
+          end
+        end
+        alias_method :call_without_quiet_ahoy, :call
+        alias_method :call, :call_with_quiet_ahoy
+      end
+    end
+
+    # for importmap
+    initializer "ahoy.importmap" do |app|
+      if app.config.respond_to?(:assets) && defined?(Importmap) && defined?(Sprockets)
+        app.config.assets.precompile << "ahoy.js"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Ahoy
+  class GeocodeV2Job < ActiveJob::Base
+    queue_as { Ahoy.job_queue }
+
+    def perform(visit_token, ip)
+      location =
+        begin
+          Geocoder.search(ip).first
+        rescue NameError
+          raise "Add the geocoder gem to your Gemfile to use geocoding"
+        rescue => e
+          Ahoy.log "Geocode error: #{e.class.name}: #{e.message}"
+          nil
+        end
+
+      if location && location.country.present?
+        data = {
+          country: location.country,
+          country_code: location.try(:country_code).presence,
+          region: location.try(:state).presence,
+          city: location.try(:city).presence,
+          postal_code: location.try(:postal_code).presence,
+          latitude: location.try(:latitude).presence,
+          longitude: location.try(:longitude).presence
+        }
+
+        Ahoy::Tracker.new(visit_token: visit_token).geocode(data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Ahoy
+  module Helper
+    def amp_event(name, properties = {})
+      url = Ahoy::Engine.routes.url_helpers.events_url(
+        url_options.slice(:host, :port, :protocol).merge(
+          name: name,
+          properties: properties,
+          screen_width: "SCREEN_WIDTH",
+          screen_height: "SCREEN_HEIGHT",
+          platform: "Web",
+          landing_page: "AMPDOC_URL",
+          referrer: "DOCUMENT_REFERRER",
+          random: "RANDOM"
+        )
+      )
+      url = "#{url}&visit_token=${clientId(ahoy_visit)}&visitor_token=${clientId(ahoy_visitor)}"
+
+      content_tag "amp-analytics" do
+        content_tag "script", type: "application/json" do
+          json_escape({
+            requests: {
+              pageview: url
+            },
+            triggers: {
+              trackPageview: {
+                on: "visible",
+                request: "pageview"
+              }
+            },
+            transport: {
+              beacon: true,
+              xhrpost: true,
+              image: false
+            }
+          }.to_json).html_safe
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Ahoy
+  module Model
+    def visitable(name = :visit, **options)
+      class_eval do
+        belongs_to(name, class_name: "Ahoy::Visit", optional: true, **options)
+        before_create :set_ahoy_visit
+      end
+      class_eval %{
+        def set_ahoy_visit
+          self.#{name} ||= Ahoy.instance.try(:visit_or_create)
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Ahoy
+  module QueryMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def where_event(name, properties = {})
+        where(name: name).where_props(properties)
+      end
+
+      def where_props(properties)
+        return all if properties.empty?
+
+        adapter_name = respond_to?(:connection_db_config) ? connection_db_config.adapter.to_s : "mongoid"
+        case adapter_name
+        when "mongoid"
+          where(properties.to_h { |k, v| ["properties.#{k}", v] })
+        when /mysql|trilogy/i
+          where("JSON_CONTAINS(properties, ?, '$') = 1", properties.to_json)
+        when /postg/i
+          case columns_hash["properties"].type
+          when :hstore
+            properties.inject(all) do |relation, (k, v)|
+              if v.nil?
+                relation.where("properties -> ? IS NULL", k.to_s)
+              else
+                relation.where("properties -> ? = ?", k.to_s, v.to_s)
+              end
+            end
+          when :jsonb
+            where("properties @> ?", properties.to_json)
+          else
+            where("properties::jsonb @> ?", properties.to_json)
+          end
+        when /sqlite/i
+          properties.inject(all) do |relation, (k, v)|
+            if v.nil?
+              relation.where("JSON_EXTRACT(properties, ?) IS NULL", "$.#{k}")
+            else
+              relation.where("JSON_EXTRACT(properties, ?) = ?", "$.#{k}", v.as_json)
+            end
+          end
+        else
+          raise "Adapter not supported: #{adapter_name}"
+        end
+      end
+      alias_method :where_properties, :where_props
+
+      def group_prop(*props)
+        # like with group
+        props.flatten!
+
+        relation = all
+        adapter_name = respond_to?(:connection_db_config) ? connection_db_config.adapter.to_s : "mongoid"
+        case adapter_name
+        when "mongoid"
+          raise "Adapter not supported: #{adapter_name}"
+        when /mysql|trilogy/i
+          props.each do |prop|
+            quoted_prop = connection_pool.with_connection { |c| c.quote("$.#{prop}") }
+            relation = relation.group("JSON_UNQUOTE(JSON_EXTRACT(properties, #{quoted_prop}))")
+          end
+        when /postg/i
+          # convert to jsonb to fix
+          # could not identify an equality operator for type json
+          # and for text columns
+          column_type = columns_hash["properties"].type
+          cast = [:jsonb, :hstore].include?(column_type) ? "" : "::jsonb"
+
+          props.each do |prop|
+            quoted_prop = connection_pool.with_connection { |c| c.quote(prop) }
+            relation = relation.group("properties#{cast} -> #{quoted_prop}")
+          end
+        when /sqlite/i
+          props.each do |prop|
+            quoted_prop = connection_pool.with_connection { |c| c.quote("$.#{prop}") }
+            relation = relation.group("JSON_EXTRACT(properties, #{quoted_prop})")
+          end
+        else
+          raise "Adapter not supported: #{adapter_name}"
+        end
+        relation
+      end
+    end
+  end
+end
+
+# backward compatibility
+Ahoy::Properties = Ahoy::QueryMethods