landable 1.7.0

data/lib/landable/mime_types.rb

@@ -0,0 +1,15 @@
+# Re-register application/json, adding our own vendored mime types as aliases
+
+# TODO Be more generous about accepting version constraints. Currently,
+# requesting v1.5 when we're running v1.5.2 will return a 406.
+
+api_mime_types = %W(
+  application/vnd.landable.v#{Landable::VERSION::MAJOR}+json
+  application/vnd.landable.v#{Landable::VERSION::STRING}+json
+  application/vnd.landable+json
+  text/x-json
+  application/jsonrequest
+)
+
+Mime::Type.unregister :json
+Mime::Type.register 'application/json', :json, api_mime_types

data/lib/landable/partial.rb

@@ -0,0 +1,46 @@
+module Landable
+  class Partial
+    def initialize(file)
+      @file = file
+    end
+
+    def process
+      @name        = @file.gsub('/',' ').titlecase
+      @description = "Defined in Source Code at #{@file}"
+      @slug        = @file.gsub(/[^\w]/, '_')
+
+      @processed = true
+    end
+
+    def to_template
+      process unless @processed
+
+      template                 = Template.where(file: @file).first_or_initialize
+      template.body            = ''
+      template.name            = @name
+      template.slug            = @slug
+      template.description     = @description
+      template.editable        = false
+      template.is_layout       = false
+      template.thumbnail_url ||= "http://placehold.it/300x200"
+
+      template.save!
+
+      template
+    end
+
+    class << self
+      def all
+        files.map { |file| new(file) }
+      end
+
+      def files
+        files = []
+
+        Landable.configuration.partials_to_templates.each do |path|
+          files << path
+        end
+      end
+    end
+  end
+end

data/lib/landable/seeds.rb

@@ -0,0 +1,36 @@
+# Stop-gap solution to allow us to keep mission-critical seed data somewhere
+# accessible. Not too thrilled about it; refactor away.
+module Landable
+  module Seeds
+
+    def self.seed key
+      method_key = "seed_#{key}".to_sym
+      if respond_to? method_key
+        send method_key if ActiveRecord::Base.connection.schema_exists? "#{Landable.configuration.database_schema_prefix}landable"
+      else
+        raise NotImplementedError, "No seeds for key '#{key}'"
+      end
+    end
+
+    private
+
+    # Required data.
+    def self.seed_required
+      # categories ('Uncategorized' is mandatory)
+      Landable::Category.where(name: 'Uncategorized').first_or_create!
+      Landable.configuration.categories.each do |category_name, category_description|
+        Landable::Category.where(name: category_name).first_or_create!(description: category_description)
+      end
+    end
+
+    # Less required data.
+    def self.seed_extras
+      # themes
+      Landable::Theme.where(name: 'Blank').first_or_create!(
+        body: '',
+        description: 'A completely blank theme; only the page body will be rendered.',
+        thumbnail_url: 'http://placehold.it/300x200',
+      )
+    end
+  end
+end

data/lib/landable/traffic.rb

@@ -0,0 +1,34 @@
+require 'landable/traffic/tracker'
+require 'landable/traffic/crawl_tracker'
+require 'landable/traffic/ping_tracker'
+require 'landable/traffic/scan_tracker'
+require 'landable/traffic/scrape_tracker'
+require 'landable/traffic/user_tracker'
+require 'landable/traffic/noop_tracker'
+
+module Landable
+  module Traffic
+    def track_with_landable!
+      begin
+        @tracker = Tracker.for self
+        @tracker.track
+      rescue => e
+        Rails.logger.error e
+        if respond_to? :newrelic_notice_error
+          newrelic_notice_error e
+        end
+      end
+
+      yield
+
+      begin
+        @tracker.save
+      rescue => e
+        Rails.logger.error e
+        if respond_to? :newrelic_notice_error
+          newrelic_notice_error e
+        end
+      end
+    end
+  end
+end

data/lib/landable/traffic/crawl_tracker.rb

@@ -0,0 +1,9 @@
+module Landable
+  module Traffic
+    class CrawlTracker < Tracker
+      def save
+        record_access
+      end
+    end
+  end
+end

data/lib/landable/traffic/noop_tracker.rb

@@ -0,0 +1,8 @@
+module Landable
+  module Traffic
+    class NoopTracker < Tracker
+      def save
+      end
+    end
+  end
+end

data/lib/landable/traffic/ping_tracker.rb

@@ -0,0 +1,9 @@
+module Landable
+  module Traffic
+    class PingTracker < Tracker
+      def save
+        record_access
+      end
+    end
+  end
+end

data/lib/landable/traffic/scan_tracker.rb

@@ -0,0 +1,9 @@
+module Landable
+  module Traffic
+    class ScanTracker < Tracker
+      def save
+        record_access
+      end
+    end
+  end
+end

data/lib/landable/traffic/scrape_tracker.rb

@@ -0,0 +1,9 @@
+module Landable
+  module Traffic
+    class ScrapeTracker < Tracker
+      def save
+        record_access
+      end
+    end
+  end
+end

data/lib/landable/traffic/tracker.rb

@@ -0,0 +1,283 @@
+require 'digest/sha2'
+require 'uri'
+
+module Landable
+  module Traffic
+    class Tracker
+      TRACKING_PARAMS = {
+        "ad_type"        => %w[ad_type adtype],
+        "ad_group"       => %w[ad_group adgroup ovadgrpid ysmadgrpid],
+        "bid_match_type" => %w[bidmatchtype bid_match_type bmt],
+        "campaign"       => %w[campaign utm_campaign ovcampgid ysmcampgid],
+        "content"        => %w[content utm_content],
+        "creative"       => %w[creative adid ovadid],
+        "device_type"    => %w[device_type devicetype device],
+        "click_id"       => %w[gclid click_id clickid],
+        "experiment"     => %w[experiment aceid],
+        "keyword"        => %w[keyword kw utm_term ovkey ysmkey],
+        "match_type"     => %w[match_type matchtype match ovmtc ysmmtc],
+        "medium"         => %w[medium utm_medium],
+        "network"        => %w[network],
+        "placement"      => %w[placement],
+        "position"       => %w[position adposition ad_position],
+        "search_term"    => %w[search_term searchterm q querystring ovraw ysmraw],
+        "source"         => %w[source utm_source],
+        "target"         => %w[target],
+      }.freeze
+
+      TRACKING_KEYS    = TRACKING_PARAMS.values.flatten.freeze
+      ATTRIBUTION_KEYS = TRACKING_PARAMS.except("click_id").keys
+
+      TRACKING_PARAMS_TRANSFORM = {
+        "ad_type"        => { 'pe'  => 'product_extensions',
+                              'pla' => 'product_listing' },
+
+        "bid_match_type" => { 'bb'  => 'bidded broad',
+                              'bc'  => 'bidded content',
+                              'be'  => 'bidded exact',
+                              'bp'  => 'bidded phrase' },
+
+        "device_type"    => { 'c'   => 'computer',
+                              'm'   => 'mobile',
+                              't'   => 'tablet' },
+
+        "match_type"     => { 'b'   => 'broad',
+                              'c'   => 'content',
+                              'e'   => 'exact',
+                              'p'   => 'phrase',
+                              'std' => 'standard',
+                              'adv' => 'advanced',
+                              'cnt' => 'content' },
+
+        "network"        => { 'g'   => 'google_search',
+                              's'   => 'search_partner',
+                              'd'   => 'display_network' },
+      }.freeze
+
+      UUID_REGEX       = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\Z/
+      UUID_REGEX_V4    = /\A\h{8}-\h{4}-4\h{3}-[89aAbB]\h{3}-\h{12}\Z/
+
+      # Save space in the session by shortening names
+      KEYS = {
+        visit_id:         'vid',
+        visitor_id:       'vsid',
+        visit_time:       'vt',
+        visitor_hash:     'vh',
+        attribution_hash: 'ah',
+        referer_hash:     'rh'
+      }.freeze
+
+      attr_reader :controller
+
+      delegate :request, :response, :session, to: :controller
+      delegate :headers, :path, :query_parameters, :referer, :remote_ip, to: :request
+
+      class << self
+        def for(controller)
+          type = controller.request.user_agent.presence && Landable::Traffic::UserAgent[controller.request.user_agent].user_agent_type
+          type = 'noop' if Landable.configuration.traffic_enabled == :html and not controller.request.format.html?
+          type = 'user'if type.nil?
+          type = 'user'if controller.request.query_parameters.slice(*TRACKING_KEYS).any?
+
+          "Landable::Traffic::#{type.classify}Tracker".constantize.new(controller)
+        end
+      end
+
+      def initialize(controller)
+        # Allow subclasses to super from initialize
+        raise NotImplementedError, "You must subclass Tracker" if self.class == Tracker
+        @controller = controller
+        @start_time = Time.now
+      end
+
+      def track
+        raise NotImplementedError, "You must subclass Tracker" if self.class == Tracker
+      end
+
+      def visitor_id
+        @visitor_id = visitor.id if visitor_changed?
+        @visitor_id
+      end
+
+      def create_event(type, meta = {})
+        return unless @visit_id
+
+        Event.create(visit_id: @visit_id, event_type: type, meta: meta)
+      end
+
+      def landing_path
+        @visit_id and PageView.where(visit_id: @visit_id).order(:page_view_id).first.try(:path)
+      end
+
+    protected
+      def cookies
+        request.cookie_jar
+      end
+
+      def cookie
+        validate_cookie
+
+        @cookie_id ||= Cookie.create.id
+
+        set_cookie
+      end
+
+      def validate_cookie
+        return unless @cookie_id
+        return if @cookie_id =~ UUID_REGEX_V4 && Cookie[@cookie_id]
+
+        # add_ip_to_graylist
+        @cookie_id = nil
+      end
+
+      def set_cookie
+        cookies.permanent[:landable] = cookie_defaults.merge(value: @cookie_id)
+      end
+
+      def cookie_defaults
+        { domain: :all, secure: false, httponly: true }
+      end
+
+      def do_not_track
+        return unless headers["DNT"]
+
+        headers["DNT"] == "1"
+      end
+
+      def user_agent
+        @user_agent ||= UserAgent[request.user_agent]
+      end
+
+      def referer
+        return @referer if @referer
+        return unless referer_uri
+
+        params      = Rack::Utils.parse_query referer_uri.query
+        attribution = Attribution.lookup params.slice(*ATTRIBUTION_KEYS)
+        query       = params.except(*ATTRIBUTION_KEYS)
+
+        @referer = Referer.where(domain_id:       Domain[referer_uri.host],
+                                 path_id:         Path[referer_uri.path],
+                                 query_string_id: QueryString[query.to_query],
+                                 attribution_id:  attribution.id).first_or_create
+      end
+
+      def ip_address
+        @ip_address ||= IpAddress[remote_ip]
+      end
+
+      def attribution_hash
+        Attribution.digest attribution_parameters
+      end
+
+      def visitor_hash
+        Digest::SHA2.base64digest [remote_ip, request.user_agent].join
+      end
+
+      def referer_hash
+        Digest::SHA2.base64digest request.referer
+      end
+
+      def tracking?
+        tracking_parameters.any?
+      end
+
+      def attribution?
+        attribution_parameters.any?
+      end
+
+      def record_visit
+        create_visit if new_visit?
+      end
+
+      def record_access
+        access = Access.where(visitor_id: visitor_id, path_id: Path[request.path]).first_or_initialize
+        access.last_accessed_at = Time.current
+        access.save!
+      end
+
+      def create_visit
+        visit = Visit.new
+        visit.attribution  = attribution
+        visit.cookie_id    = @cookie_id
+        visit.referer_id   = referer.try(:id)
+        visit.visitor_id   = visitor_id
+        visit.do_not_track = do_not_track
+        visit.save!
+
+        @visit_id = visit.id
+      end
+
+      def new_visit?
+        @visit_id.nil? || referer_changed? || attribution_changed? || visitor_changed? || visit_stale?
+      end
+
+      def referer_changed?
+        external_referer? && referer_hash != @referer_hash
+      end
+
+      def referer_uri
+        @referer_uri ||= URI(URI.encode(request.referer)) if request.referer
+      end
+
+      def external_referer?
+        referer_uri && referer_uri.host != request.host
+      end
+
+      def visitor_changed?
+        visitor_hash != @visitor_hash
+      end
+
+      def attribution_changed?
+        attribution? && attribution_hash != @attribution_hash
+      end
+
+      def visit_stale?
+        return false unless @last_visit_time
+
+        Time.current - @last_visit_time > 30.minutes
+      end
+
+      def extract_tracking(params)
+        hash = {}
+
+        TRACKING_PARAMS.each do |key, names|
+          next unless param = names.find { |name| params.key?(name) }
+          hash[key] = params[param]
+        end
+
+        TRACKING_PARAMS_TRANSFORM.each do |key, transform|
+          next unless hash.key? key
+
+          hash[key] = transform[hash[key]] if transform.key? hash[key]
+        end
+
+        hash
+      end
+
+      def tracking_parameters
+        @tracking_parameters ||= extract_tracking(query_parameters)
+      end
+
+      def untracked_parameters
+        query_parameters.except(*TRACKING_PARAMS.values.flatten)
+      end
+
+      def attribution_parameters
+        @attribution_parameters ||= tracking_parameters.slice(*ATTRIBUTION_KEYS)
+      end
+
+      def attribution
+        @attribution ||= Attribution.lookup attribution_parameters
+      end
+
+      def visitor
+        @visitor ||= Visitor.with_ip_address(ip_address).with_user_agent(user_agent).first_or_create
+      end
+
+      def visit
+        @visit ||= @visit_id && Visit.find(@visit_id)
+      end
+    end
+  end
+end