ahoy_captain 0.1.0 → 0.76

data/config/routes.rb

@@ -0,0 +1,56 @@
+AhoyCaptain::Engine.routes.draw do
+  root to: 'roots#show'
+  %w{utm_source utm_medium utm_term utm_content utm_campaign}.each do |utm|
+    get "campaigns/#{utm}" => "campaigns#index", defaults: { campaigns_type: utm }, as: "campaign_#{utm}"
+  end
+
+  {
+    browsers: :browser,
+    operating_systems: :os,
+    device_types: :device_type
+  }.each do |k,v|
+    get "/devices/#{k}" => 'devices#index', defaults: { devices_type: v }, as: "devices_#{k}"
+  end
+
+  resource :realtime, only: [:show]
+  resources :funnels, only: [:show]
+  resources :goals, only: [:index]
+  resource :stats, only: [:show]
+  resources :countries, only: [:index]
+  resources :regions, only: [:index]
+  resources :cities, only: [:index]
+  resources :campaigns, only: [:index]
+  resources :sources, only: [:index]
+  resources :exit_pages, only: [:index]
+  resources :top_pages, only: [:index]
+  resources :entry_pages, only: [:index]
+
+  namespace :stats do
+    resources :unique_visitors, only: [:index]
+    resources :total_visits, only: [:index]
+    resources :total_pageviews, only: [:index]
+    resources :views_per_visits, only: [:index]
+    resources :bounce_rates, only: [:index]
+    resources :visit_durations, only: [:index]
+  end
+  namespace :filters do
+    %w{source medium term content campaign}.each do |utm|
+      get "utm/#{utm}s" => "utms#index", defaults: { type: "utm_#{utm}" }
+    end
+
+    %w{country region city}.each do |type|
+      get "locations/#{type.pluralize}" => "locations#index", defaults: { type: type }
+    end
+    resources :sources, only: [:index]
+    resources :screens, only: [:index]
+    scope :operating_systems, module: :operating_systems do
+      resources :names, only: [:index]
+      resources :versions, only: [:index]
+    end
+    scope :pages, module: :pages do
+      resources :actions, only: [:index]
+      resources :entry_pages, only: [:index]
+      resources :exit_pages, only: [:index]
+    end
+  end
+end

data/lib/ahoy_captain/active_record.rb

@@ -0,0 +1,108 @@
+module ActiveRecord
+  module Querying
+    delegate :with, to: :all
+  end
+
+  module WithMerger
+    def merge
+      super
+      merge_withs
+      relation
+    end
+
+    private
+
+    def merge_withs
+      relation.recursive_with = true if other.recursive_with?
+      other_values = other.with_values.reject { |value| relation.with_values.include?(value) }
+      relation.with!(*other_values) if other_values.any?
+    end
+  end
+
+  class Relation
+    class Merger
+      prepend WithMerger
+    end
+
+    def with(opts, *rest)
+      spawn.with!(opts, *rest)
+    end
+
+    def with!(opts, *rest)
+      if opts == :recursive
+        self.recursive_with = true
+        self.with_values += rest
+      else
+        self.with_values += [opts] + rest
+      end
+      self
+    end
+
+    def with_values
+      @values[:with] || []
+    end
+
+    def with_values=(values)
+      raise ImmutableRelation if @loaded
+
+      @values[:with] = values
+    end
+
+    def recursive_with?
+      @values[:recursive_with]
+    end
+
+    def recursive_with=(value)
+      raise ImmutableRelation if @loaded
+
+      @values[:recursive_with] = value
+    end
+
+    private
+
+    def build_arel(*args)
+      arel = super
+      build_with(arel) if @values[:with]
+      arel
+    end
+
+    def build_with(arel) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      return if with_values.empty?
+
+      with_statements = with_values.map do |with_value|
+        case with_value
+        when String then Arel::Nodes::SqlLiteral.new(with_value)
+        when Arel::Nodes::As then with_value
+        when Hash then build_with_value_from_hash(with_value)
+        when Array then build_with_value_from_array(with_value)
+        else
+          raise ArgumentError, "Unsupported argument type: #{with_value} #{with_value.class}"
+        end
+      end
+
+      recursive_with? ? arel.with(:recursive, with_statements) : arel.with(with_statements)
+    end
+
+    def build_with_value_from_array(array)
+      unless array.map(&:class).uniq == [Arel::Nodes::As]
+        raise ArgumentError, "Unsupported argument type: #{array} #{array.class}"
+      end
+
+      array
+    end
+
+    def build_with_value_from_hash(hash) # rubocop:disable Metrics/MethodLength
+      hash.map do |name, value|
+        table = Arel::Table.new(name)
+        expression = case value
+                     when String then Arel::Nodes::SqlLiteral.new("(#{value})")
+                     when ActiveRecord::Relation then value.arel
+                     when Arel::SelectManager, Arel::Nodes::Union then value
+                     else
+                       raise ArgumentError, "Unsupported argument type: #{value} #{value.class}"
+                     end
+        Arel::Nodes::As.new(table, expression)
+      end
+    end
+  end
+end

data/lib/ahoy_captain/ahoy/event_methods.rb

@@ -0,0 +1,114 @@
+module AhoyCaptain
+  module Ahoy
+    module EventMethods
+      extend ActiveSupport::Concern
+
+      included do
+        ransacker :route do |parent|
+          Arel.sql(AhoyCaptain.config.event[:url_column].gsub("properties", "ahoy_events.properties"))
+        end
+
+        scope :with_routes, -> { where(AhoyCaptain.config.event[:url_exists]) }
+
+        scope :with_url, -> {
+          select(Arel.sql("#{AhoyCaptain.config.event.url_column} AS url"))
+        }
+
+        scope :distinct_url, -> {
+          distinct(Arel.sql("#{AhoyCaptain.config.event.url_column}"))
+        }
+
+        scope :url_in, ->(*args) {
+          where("#{AhoyCaptain.config.event.url_column} IN (?)", args)
+        }
+
+        scope :url_eq, ->(arg) {
+          if arg.is_a?(Array)
+            arg = arg[0]
+          end
+          where("#{AhoyCaptain.config.event.url_column} = ?", arg)
+        }
+
+        scope :url_not_in, ->(*args) {
+          where("#{AhoyCaptain.config.event.url_column} NOT IN (?)", args)
+        }
+
+        scope :url_i_cont, ->(arg) {
+          where("#{AhoyCaptain.config.event.url_column} ILIKE ?", "%#{arg}%")
+        }
+
+        scope :route_eq, ->(arg) {
+          url_eq(arg)
+        }
+
+        scope :route_in, ->(*args) {
+          url_in(*args)
+        }
+
+        scope :route_not_in, ->(*args) {
+          url_not_in(*args)
+        }
+
+        scope :route_i_cont, ->(arg) {
+          url_i_cont(arg)
+        }
+
+        scope :entry_page_in, ->(*args) {
+          table_alias = "first_events_#{SecureRandom.hex.first(6)}"
+
+          subquery = self.select("MIN(id) as min_id").where(name: AhoyCaptain.config.event[:view_name]).route_in(*args).group(:visit_id)
+          joins("INNER JOIN (#{subquery.to_sql}) #{table_alias} ON #{::AhoyCaptain.event.table_name}.id = #{table_alias}.min_id")
+        }
+
+        scope :entry_page_not_in, ->(*args) {
+          table_alias = "first_events_#{SecureRandom.hex.first(6)}"
+          subquery = self.select("MIN(id) as min_id").where(name: AhoyCaptain.config.event[:view_name]).route_not_in(*args).group(:visit_id)
+          joins("INNER JOIN (#{subquery.to_sql}) #{table_alias} ON #{::AhoyCaptain.event.table_name}.id = #{table_alias}.min_id")
+        }
+
+        scope :entry_page_i_cont, ->(arg) {
+          table_alias = "first_events_#{SecureRandom.hex.first(6)}"
+          subquery = self.select("MIN(id) as min_id").where(name: AhoyCaptain.config.event[:view_name]).route_i_cont(arg).group(:visit_id)
+          joins("INNER JOIN (#{subquery.to_sql}) #{table_alias} ON #{::AhoyCaptain.event.table_name}.id = #{table_alias}.min_id")
+        }
+
+        scope :exit_page_in, ->(*args) {
+          table_alias = "last_events_#{SecureRandom.hex.first(6)}"
+
+          subquery = self.select("MAX(id) as max_id").where(name: AhoyCaptain.config.event[:view_name]).route_in(*args).group(:visit_id)
+          joins("INNER JOIN (#{subquery.to_sql}) #{table_alias} ON #{::AhoyCaptain.event.table_name}.id = #{table_alias}.max_id")
+        }
+
+        scope :exit_page_not_in, ->(*args) {
+          table_alias = "last_events_#{SecureRandom.hex.first(6)}"
+
+          subquery = self.select("MAX(id) as max_id").where(name: AhoyCaptain.config.event[:view_name]).route_not_in(*args).group(:visit_id)
+          joins("INNER JOIN (#{subquery.to_sql}) #{table_alias} ON #{::AhoyCaptain.event.table_name}.id = #{table_alias}.max_id")
+        }
+
+        scope :exit_page_i_cont, ->(arg) {
+          table_alias = "last_events_#{SecureRandom.hex.first(6)}"
+
+          subquery = self.select("MAX(id) as max_id").where(name: AhoyCaptain.config.event[:view_name]).route_i_cont(*arg).group(:visit_id)
+          joins("INNER JOIN (#{subquery.to_sql}) #{table_alias} ON #{::AhoyCaptain.event.table_name}.id = #{table_alias}.max_id")
+        }
+
+      end
+
+      class_methods do
+        def ransackable_attributes(auth_object = nil)
+          super + ["action", "controller", "id", "id_property", "name", "name_property", "page", "properties", "time", "url", "user_id", "visit_id"] + self._ransackers.keys
+        end
+
+        def ransackable_scopes(auth_object = nil)
+          super + [:entry_page_in, :entry_page_not_in, :exit_page_in, :entry_page_not_in, :route_in, :route_not_in, :route_i_cont, :entry_page_i_cont, :exit_page_i_cont]
+        end
+
+        def ransackable_associations(auth_object = nil)
+          super + [:visit]
+        end
+      end
+    end
+  end
+end
+

data/lib/ahoy_captain/ahoy/visit_methods.rb

@@ -0,0 +1,23 @@
+module AhoyCaptain
+  module Ahoy
+    module VisitMethods
+      extend ActiveSupport::Concern
+
+      included do
+        ransacker :ref_domain do
+          Arel.sql("(substring(referring_domain from '(?:.*://)?(?:www\.)?([^/?]*)'))")
+        end
+      end
+
+      class_methods do
+        def ransackable_attributes(auth = nil)
+          columns_hash.keys + ["ref_domain"]
+        end
+
+        def ransackable_associations(auth = nil)
+          super + ["events"]
+        end
+      end
+    end
+  end
+end

data/lib/ahoy_captain/configuration.rb

@@ -0,0 +1,43 @@
+require 'ahoy_captain/period_collection'
+
+module AhoyCaptain
+  class Configuration
+    attr_accessor :view_name, :theme
+    attr_reader :goals, :funnels, :cache, :ranges, :disabled_widgets, :event, :models
+    def initialize
+      @goals = GoalCollection.new
+      @funnels = FunnelCollection.new
+      @theme = "dark"
+      @ranges = ::AhoyCaptain::PeriodCollection.load_default
+      @cache = ActiveSupport::OrderedOptions.new.tap do |option|
+        option.enabled = false
+        option.store = Rails.cache
+        option.ttl = 1.minute
+      end
+      @event = ActiveSupport::OrderedOptions.new.tap do |option|
+        option.view_name = "$view"
+        option.url_column = "CONCAT(properties->>'controller', '#', properties->>'action')"
+        option.url_exists = "JSONB_EXISTS(properties, 'controller') AND JSONB_EXISTS(properties, 'action')"
+      end
+      @models = ActiveSupport::OrderedOptions.new.tap do |option|
+        option.event = "::Ahoy::Event"
+        option.visit = "::Ahoy::Visit"
+      end
+      @disabled_widgets = []
+    end
+
+    def goal(id, &block)
+      instance = Goal.new
+      instance.id = id
+      instance.instance_exec(&block)
+      @goals.register(instance)
+    end
+
+    def funnel(id, &block)
+      instance = Funnel.new
+      instance.id = id
+      instance.instance_exec(&block)
+      @funnels.register(instance)
+    end
+  end
+end

data/lib/ahoy_captain/engine.rb

@@ -0,0 +1,24 @@
+require 'ahoy'
+require 'turbo-rails'
+require 'stimulus-rails'
+require 'ransack'
+require 'view_component'
+require 'chartkick'
+require 'groupdate'
+require 'pagy'
+
+module AhoyCaptain
+  class Engine < Rails::Engine
+    isolate_namespace ::AhoyCaptain
+
+    initializer "ahoy_captain.precompile" do |app|
+      app.config.assets.paths << AhoyCaptain::Engine.root.join("app/javascript")
+      app.config.assets.paths << AhoyCaptain::Engine.root.join("app/images")
+      app.config.assets.precompile << "ahoy_captain/application.js"
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      require "ahoy_captain/active_record"
+    end
+  end
+end

data/lib/ahoy_captain/funnels.rb

@@ -0,0 +1,44 @@
+module AhoyCaptain
+  class Funnel
+    attr_accessor :id
+    attr_reader :goals
+
+    def initialize
+      @id = nil
+      @label = nil
+      @goals = []
+    end
+
+    def goal(id)
+      @goals << AhoyCaptain.config.goals[id]
+    end
+
+    def label(value)
+      @label = value
+    end
+
+    def title
+      @label
+    end
+  end
+
+  class FunnelCollection
+    include Enumerable
+
+    def initialize
+      @funnels = {}
+    end
+
+    def register(funnel)
+      @funnels[funnel.id] = funnel
+    end
+
+    def each(&block)
+      @funnels.each(&block)
+    end
+
+    def [](value)
+      @funnels[value.to_sym]
+    end
+  end
+end

data/lib/ahoy_captain/goals.rb

@@ -0,0 +1,39 @@
+module AhoyCaptain
+  class Goal
+    attr_accessor :id
+    attr_reader :title, :event_name
+    def initialize
+      @id = nil
+      @title = nil
+      @event_name = nil
+    end
+
+    def label(value)
+      @title = value
+    end
+
+    def event(value)
+      @event_name = value
+    end
+  end
+
+  class GoalCollection
+    include Enumerable
+
+    def initialize
+      @goals = {}
+    end
+
+    def register(goal)
+      @goals[goal.id] = goal
+    end
+
+    def each(&block)
+      @goals.values.each(&block)
+    end
+
+    def [](value)
+      @goals[value]
+    end
+  end
+end

data/lib/ahoy_captain/period_collection.rb

@@ -0,0 +1,115 @@
+module AhoyCaptain
+  class PeriodCollection
+    class Period
+      attr_reader :param, :label, :range
+      def initialize(param:, label:, range:)
+        @param = param
+        @label = label
+        @range = range
+      end
+    end
+
+    def self.load_default
+      instance = new
+      {
+        realtime: {
+          label: "Realtime",
+          range: -> { [1.minute.ago] },
+        },
+        day: {
+          label: "Day",
+          range: -> { [Time.current.beginning_of_day, Time.current] },
+        },
+        '7d': {
+          label: "7 Days",
+          range: -> {  [7.days.ago, Time.current] },
+        },
+        '30d': {
+          label: "30 Days",
+          range: -> { [30.days.ago, Time.current] },
+        },
+        mtd: {
+          label: "Month-to-date",
+          range: -> { [Time.current.beginning_of_month, Time.current] },
+        },
+        lastmonth: {
+          label: "Last month",
+          range: -> { [1.month.ago.beginning_of_month, 1.month.ago.end_of_month] },
+        },
+        ytd: {
+          label: "This year",
+          range: -> { [Time.current.beginning_of_year, Time.current] },
+        },
+        '12mo': {
+          label: "12 months",
+          range: -> { [12.months.ago.to_datetime, Time.current] },
+        },
+        all: {
+          label: "All-time",
+          range: -> { [Date.new(2004, 8, 1).to_datetime, Time.current] },
+        },
+      }.each do |param, options|
+        instance.add(param, options[:label], options[:range])
+      end
+      instance.default = :mtd
+      instance
+    end
+
+    attr_reader :default, :max
+    def initialize
+      @periods = {}
+      @default = nil
+      @max = nil
+    end
+
+    def add(param, label, range_proc)
+      raise ArgumentError, "range must be a proc, or respond to .call" unless range_proc.respond_to?(:call)
+      raise ArgumentError, "range.call must return a range or an array" unless range_proc.call.is_a?(Range) || range_proc.call.is_a?(Array)
+
+      @periods[param.to_sym] = Period.new(param: param, label: label, range: range_proc)
+    end
+
+    def delete(param)
+      @periods.delete(param.to_sym)
+    end
+
+    def reset
+      @periods = {}
+      @default = nil
+    end
+
+    def each(&block)
+      @periods.each(&block)
+    end
+
+    def find(value)
+      @periods[value.try(:to_sym)]
+    end
+
+    def all
+      @periods
+    end
+
+    def default=(val)
+      @default = val.to_sym
+    end
+
+    def max=(amount)
+      @max = amount
+    end
+
+    def for(value)
+      if value.nil?
+        period = @periods[@default]
+      else
+        period = (@periods[value.to_sym] || @periods[@default])
+      end
+
+      if period
+        period.range.call
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/ahoy_captain/railtie.rb

@@ -0,0 +1,7 @@
+module AhoyCaptain
+  class Railtie < ::Rails::Railtie
+    initializer "ahoy_captain.assets.precompile" do |app|
+      app.config.assets.precompile += %w[ahoy_captain/manifest]
+    end
+  end
+end

data/lib/ahoy_captain/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module AhoyCaptain
-  VERSION = "0.1.0"
+  VERSION = "0.76"
 end

data/lib/ahoy_captain.rb

@@ -1,8 +1,54 @@
-# frozen_string_literal: true
+require "ahoy_captain/version"
+require "ahoy_captain/railtie"
+require "ahoy_captain/engine"
+require "ahoy_captain/goals"
+require "ahoy_captain/funnels"
+require "ahoy_captain/configuration"
+require 'ahoy_captain/ahoy/visit_methods'
+require 'ahoy_captain/ahoy/event_methods'
 
-require_relative "ahoy_captain/version"
+require 'importmap-rails'
 
 module AhoyCaptain
-  class Error < StandardError; end
-  # Your code goes here...
+  class << self
+    attr_accessor :configuration
+
+    def cache
+      @cache ||= if config.cache[:enabled]
+                   config.cache[:store]
+                 else
+                   ActiveSupport::Cache::NullStore.new
+                 end
+    end
+
+    def importmap
+      Importmap::Map.new.draw do
+        pin "@hotwired/turbo-rails", to: "turbo.min.js", preload: true
+        pin "@hotwired/stimulus", to: "stimulus.min.js", preload: true
+        pin "@hotwired/stimulus-loading", to: "stimulus-loading.js", preload: true
+        pin "application", to: "ahoy_captain/application.js", preload: true
+        pin "slim-select", to: "https://ga.jspm.io/npm:slim-select@2.6.0/dist/slimselect.es.js", preload: true
+        pin "chartkick", to: "chartkick.js"
+        pin "Chart.bundle", to: "Chart.bundle.js"
+        pin "chartjs-plugin-datalabels", to: "https://cdn.jsdelivr.net/npm/chartjs-plugin-datalabels@2", preload: true
+        pin_all_from AhoyCaptain::Engine.root.join("app/assets/javascript/ahoy_captain/controllers"), under: "controllers", to: "ahoy_captain/controllers"
+      end
+    end
+
+    def config
+      self.configuration ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+
+    def event
+      @event ||= config.models[:event].constantize
+    end
+
+    def visit
+      @visit ||= config.models[:visit].constantize
+    end
+  end
 end

data/lib/generators/ahoy_captain/install_generator.rb

@@ -0,0 +1,18 @@
+require "rails/generators"
+
+module AhoyCaptain
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.join(__dir__, "templates")
+
+      def copy_templates
+        insert_into_file ::Rails.root.join("app/models/ahoy/event.rb").to_s, "  include AhoyCaptain::Ahoy::EventMethods\n", after: "class Ahoy::Event < ApplicationRecord\n"
+        insert_into_file ::Rails.root.join("app/models/ahoy/visit.rb").to_s, "  include AhoyCaptain::Ahoy::VisitMethods\n", after: "class Ahoy::Visit < ApplicationRecord\n"
+
+        template "config.rb", "config/initializers/ahoy_captain.rb"
+
+        route "mount AhoyCaptain::Engine => '/ahoy_captain'"
+      end
+    end
+  end
+end