impressionist-cody 2.0.0

data/app/models/impressionist/impressionable.rb

@@ -0,0 +1,62 @@
+module Impressionist
+  module Impressionable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_accessor :impressionist_cache_options
+
+      DEFAULT_CACHE ||= {
+        :counter_cache => false,
+        :column_name => :impressions_count,
+        :unique => :all
+      }
+
+      def impressionist_counter_cache_options
+        @impressionist_cache_options ||= {}
+        @impressionist_cache_options.reverse_merge!(DEFAULT_CACHE)
+      end
+
+      # asks impressionable entity whether or not it is counter_caching
+      def impressionist_counter_caching?
+        impressionist_counter_cache_options[:counter_cache]
+      end
+
+      def counter_caching?
+          ::ActiveSupport::Deprecation.warn("#counter_caching? is deprecated; please use #impressionist_counter_caching? instead")
+          impressionist_counter_caching?
+      end
+
+    end # end of ClassMethods
+
+    def impressionist_count(options={})
+      # Uses these options as defaults unless overridden in options hash
+      options.reverse_merge!(:filter => :request_hash, :start_date => nil, :end_date => Time.now)
+
+      # If a start_date is provided, finds impressions between then and the end_date. Otherwise returns all impressions
+      imps = options[:start_date].blank? ? impressions : impressions.where("created_at >= ? and created_at <= ?", options[:start_date], options[:end_date])
+
+      if options[:message]
+        imps = imps.where("impressions.message = ?", options[:message])
+      end
+
+      # Count all distinct impressions unless the :all filter is provided.
+      distinct = options[:filter] != :all
+      if Rails::VERSION::MAJOR >= 4
+        distinct ? imps.select(options[:filter]).distinct.count : imps.count
+      else
+        distinct ? imps.count(options[:filter], :distinct => true) : imps.count
+      end
+    end
+
+    def update_impressionist_counter_cache
+      slave = Impressionist::UpdateCounters.new(self)
+      slave.update
+    end
+
+    def impressionable?
+      true
+    end
+
+  end
+
+end

data/impressionist.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'impressionist/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'impressionist-cody'
+  s.version       = Impressionist::VERSION.dup
+  s.platform      = Gem::Platform::RUBY
+  s.licenses      = ['MIT']
+  s.summary       = 'Easy way to log impressions'
+  s.email         = 'john.mcaliley@gmail.com'
+  s.homepage      = 'http://github.com/charlotte-ruby/impressionist'
+  s.description   = 'Log impressions from controller actions or from a model'
+  s.authors       = ['johnmcaliley']
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- tests/**/*`.split("\n")
+  s.require_path  = 'lib'
+
+  s.add_dependency "friendly_id"
+  s.add_dependency 'nokogiri', RUBY_VERSION < '2.1.0' ? '~> 1.6.0' : '~> 1'
+  s.add_dependency 'rails', '>= 3.2.15'
+  s.add_dependency 'zeitwerk'
+
+  s.add_development_dependency 'bundler', '~> 2.0'
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'rspec-rails'
+  s.add_development_dependency 'sqlite3', '~> 1.4'
+end

data/lib/generators/active_record/impressionist_generator.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Generators
+    class ImpressionistGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.join(File.dirname(__FILE__), 'templates')
+
+      # FIX, why is this implementing rails behaviour?
+      def self.next_migration_number(dirname)
+        sleep 1
+        if ActiveRecord::Base.timestamped_migrations
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def create_migration_file
+        migration_template 'create_impressions_table.rb.erb', 'db/migrate/create_impressions_table.rb'
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/create_impressions_table.rb.erb

@@ -0,0 +1,32 @@
+class CreateImpressionsTable < ActiveRecord::Migration<%= Rails::VERSION::MAJOR >= 5 ? "[#{Rails.version.to_f}]" : "" %>
+  def self.up
+    create_table :impressions, :force => true do |t|
+      t.string :impressionable_type
+      t.integer :impressionable_id
+      t.integer :user_id
+      t.string :controller_name
+      t.string :action_name
+      t.string :view_name
+      t.string :request_hash
+      t.string :ip_address
+      t.string :session_hash
+      t.text :message
+      t.text :referrer
+      t.text :params
+      t.timestamps
+    end
+    add_index :impressions, [:impressionable_type, :message, :impressionable_id], :name => "impressionable_type_message_index", :unique => false, :length => {:message => 255 }
+    add_index :impressions, [:impressionable_type, :impressionable_id, :request_hash], :name => "poly_request_index", :unique => false
+    add_index :impressions, [:impressionable_type, :impressionable_id, :ip_address], :name => "poly_ip_index", :unique => false
+    add_index :impressions, [:impressionable_type, :impressionable_id, :session_hash], :name => "poly_session_index", :unique => false
+    add_index :impressions, [:controller_name,:action_name,:request_hash], :name => "controlleraction_request_index", :unique => false
+    add_index :impressions, [:controller_name,:action_name,:ip_address], :name => "controlleraction_ip_index", :unique => false
+    add_index :impressions, [:controller_name,:action_name,:session_hash], :name => "controlleraction_session_index", :unique => false
+    add_index :impressions, [:impressionable_type, :impressionable_id, :params], :name => "poly_params_request_index", :unique => false, :length => {:params => 255 }
+    add_index :impressions, :user_id
+  end
+
+  def self.down
+    drop_table :impressions
+  end
+end

data/lib/generators/impressionist_generator.rb

@@ -0,0 +1,13 @@
+module Impressionist
+  module Generators
+    class ImpressionistGenerator < Rails::Generators::Base
+      hook_for :orm
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_config_file
+        template 'impression.rb.erb', 'config/initializers/impression.rb'
+      end
+
+    end
+  end
+end

data/lib/generators/mongo_mapper/impressionist_generator.rb

@@ -0,0 +1,8 @@
+module MongoMapper
+  module Generators
+    class ImpressionistGenerator < Rails::Generators::Base
+      # Empty for now, need it for generating the config file without
+      # triggering other ORM's generators.
+    end
+  end
+end

data/lib/generators/mongoid/impressionist_generator.rb

@@ -0,0 +1,8 @@
+module Mongoid
+  module Generators
+    class ImpressionistGenerator < Rails::Generators::Base
+      # Empty for now, need it for generating the config file without
+      # triggering other ORM's generators.
+    end
+  end
+end

data/lib/generators/templates/impression.rb.erb

@@ -0,0 +1,8 @@
+# Use this hook to configure impressionist parameters
+#Impressionist.setup do |config|
+  # Define ORM. Could be :active_record (default), :mongo_mapper or :mongoid
+  # config.orm = :active_record
+#end
+
+<% orm = options.orm.match(/mongoid|active_record|mongomapper/) %>
+<%= "Impressionist.orm = :#{options.orm}" if  String === options.orm %>

data/lib/impressionist/bots.rb

@@ -0,0 +1,21 @@
+require 'timeout'
+require 'net/http'
+require 'nokogiri'
+
+module Impressionist
+  module Bots
+    LIST_URL = "http://www.user-agents.org/allagents.xml"
+    def self.consume
+      Timeout.timeout(4) do
+        response = Net::HTTP.get(URI.parse(LIST_URL))
+        doc = Nokogiri::XML(response)
+        list = []
+        doc.xpath('//user-agent').each do |agent|
+          type = agent.xpath("Type").text
+          list << agent.xpath("String").text.gsub("&lt;","<") if ["R","S"].include?(type) #gsub hack for badly formatted data
+        end
+        list
+      end
+    end
+  end
+end

data/lib/impressionist/controllers/mongoid/impressionist_controller.rb

@@ -0,0 +1,10 @@
+ImpressionistController::InstanceMethods.send(:define_method, :direct_create_statement) do |query_params={}|
+	# creates a statment hash that contains default values for creating an impression.
+	# if :impressionable_id is a valid ObjectId then convert it into one
+	base = (defined? Moped) ? Moped::BSON : BSON
+	query_params.reverse_merge!(
+		:impressionable_type => controller_path.singularize.camelize,
+		:impressionable_id=> !base::ObjectId.legal?(params[:id]) ? params[:id] : base::ObjectId.from_string(params[:id])
+	)
+	associative_create_statement(query_params)
+end

data/lib/impressionist/counter_cache.rb

@@ -0,0 +1,76 @@
+module Impressionist
+  module CounterCache
+
+    attr_reader :impressionable_class, :entity
+
+    private
+
+      # A valid impression must
+      # have a valid impressionable class
+      # be counter_caching
+      # have a record saved in the db
+      # then it should give it a try
+      def impressionable_counter_cache_updatable?
+        updatable? && impressionable_try
+      end
+
+      def updatable?
+        valid_impressionable_class? && impressionable_find
+      end
+
+      def valid_impressionable_class?
+        set_impressionable_class && counter_caching?
+      end
+
+      def set_impressionable_class
+        klass = self.impressionable_type  || false
+        @impressionable_class = klass.
+          to_s.safe_constantize           || false
+      end
+
+      def impressionist_log(str, mode=:error)
+        Rails.logger.send(mode.to_s, str)
+      end
+
+      # receives an entity(instance of a Model) and then tries to update
+      # counter_cache column
+      # entity is a impressionable instance model
+      def impressionable_try
+        entity.try(:update_impressionist_counter_cache)
+      end
+
+      def impressionable_find
+        exeception_rescuer {
+          @entity = impressionable_class.find(self.impressionable_id)
+        }
+        @entity
+
+      end
+
+      def counter_caching?
+        if impressionable_class.respond_to?(:impressionist_counter_caching?)
+          impressionable_class.impressionist_counter_caching?
+        else
+          false
+        end
+      end
+
+
+      # Returns false, as it is only handling one exeception
+      # It would make updatable to fail thereafter it would not try
+      # to update cache_counter
+      def exeception_rescuer
+          begin
+            yield
+          rescue ActiveRecord::RecordNotFound
+            exeception_to_log
+            false
+          end
+      end
+
+      def exeception_to_log
+        impressionist_log("Couldn't find Widget with id=#{self.impressionable_id}")
+      end
+
+  end
+end

data/lib/impressionist/engine.rb

@@ -0,0 +1,45 @@
+module Impressionist
+  class Engine < ::Rails::Engine
+    attr_accessor :orm
+
+  initializer 'impressionist.model' do |app|
+    @orm = Impressionist.orm
+    include_orm
+  end
+
+
+  initializer 'impressionist.controller' do
+    require "impressionist/controllers/mongoid/impressionist_controller" if orm == :mongoid.to_s
+
+    ActiveSupport.on_load(:action_controller) do
+     include ImpressionistController::InstanceMethods
+     extend ImpressionistController::ClassMethods
+   end
+  end
+
+
+ private
+
+    def include_orm
+      require "#{root}/app/models/impressionist/impressionable.rb"
+      require "impressionist/models/#{orm}/impression.rb"
+      require "impressionist/models/#{orm}/impressionist/impressionable.rb"
+    end
+
+  end
+
+end
+
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.new
+impression = Impressionist::Engine.root
+impression_lib = impression.join('lib')
+impression_con = impression.join('app', 'controllers')
+impression_mod = impression.join('app', 'models')
+
+
+loader.push_dir(impression_lib, namespace: Impressionist)
+loader.push_dir(impression_con, namespace: Impressionist)
+loader.push_dir(impression_mod, namespace: Impressionist)
+loader.setup

data/lib/impressionist/is_impressionable.rb

@@ -0,0 +1,23 @@
+module Impressionist
+  module IsImpressionable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def is_impressionable(options={})
+        define_association
+        @impressionist_cache_options = options
+
+        true
+      end
+
+      private
+
+      def define_association
+        has_many(:impressions,
+        :as => :impressionable,
+        :dependent => :delete_all)
+      end
+    end
+
+  end
+end

data/lib/impressionist/load.rb

@@ -0,0 +1,11 @@
+require 'impressionist/setup_association'
+
+require 'impressionist/counter_cache'
+
+require 'impressionist/update_counters'
+
+require 'impressionist/rails_toggle'
+
+require 'impressionist/is_impressionable'
+
+require 'impressionist/engine'

data/lib/impressionist/models/active_record/impression.rb

@@ -0,0 +1,14 @@
+# Responsability
+# * logs an error if imps_id and imps_type can not be found
+# * asks updatable? whether it may or may not be updated
+
+class Impression < ActiveRecord::Base
+
+  include Impressionist::CounterCache
+
+  # sets belongs_to and attr_accessible depending on Rails version
+  Impressionist::SetupAssociation.new(self).set
+
+  store :params
+  after_save :impressionable_counter_cache_updatable?
+end

data/lib/impressionist/models/active_record/impressionist/impressionable.rb

@@ -0,0 +1,12 @@
+module Impressionist
+
+  module Impressionable
+
+  # extends AS::Concern
+  include Impressionist::IsImpressionable
+  end
+
+end
+
+ActiveRecord::Base.
+send(:include, Impressionist::Impressionable)

data/lib/impressionist/models/mongo_mapper/impression.rb

@@ -0,0 +1,18 @@
+class Impression
+  include MongoMapper::Document
+
+  key :impressionable_type, String
+  key :impressionable_id, String
+  key :user_id, String
+  key :controller_name, String
+  key :action_name, String
+  key :view_name, String
+  key :request_hash, String
+  key :ip_address, String
+  key :session_hash, String
+  key :message, String
+  key :referrer, String
+  timestamps!
+
+  belongs_to :impressionable, :polymorphic=>true
+end

data/lib/impressionist/models/mongo_mapper/impressionist/impressionable.rb

@@ -0,0 +1,21 @@
+MongoMapper::Document.plugin Impressionist::Impressionable
+
+module Impressionist
+  module Impressionable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+        def is_impressionable(options={})
+          many(:impressions,
+          :as => :impressionable,
+          :dependent => :delete_all)
+
+          @impressionist_cache_options = options
+        end
+
+    end
+
+  end
+
+end

data/lib/impressionist/models/mongoid/impression.rb

@@ -0,0 +1,26 @@
+##
+# see active_record/impression.rb
+# same doc applies to here
+class Impression
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  include Impressionist::CounterCache
+  Impressionist::SetupAssociation.new(self).set
+
+  field :impressionable_id, type: BSON::ObjectId
+  field :impressionable_type
+  field :user_id
+  field :controller_name
+  field :action_name
+  field :view_name
+  field :request_hash
+  field :ip_address
+  field :session_hash
+  field :message
+  field :referrer
+  field :params
+
+  after_save :impressionable_counter_cache_updatable?
+
+end

data/lib/impressionist/models/mongoid/impressionist/impressionable.rb

@@ -0,0 +1,28 @@
+module Impressionist
+  module Impressionable
+
+  # extends AS::Concern
+  include Impressionist::IsImpressionable
+
+    # Overides impressionist_count in order to provide mongoid compability
+    def impressionist_count(options={})
+
+      # Uses these options as defaults unless overridden in options hash
+      options.reverse_merge!(:filter => :request_hash, :start_date => nil, :end_date => Time.now)
+
+      # If a start_date is provided, finds impressions between then and the end_date.
+      # Otherwise returns all impressions
+      imps = options[:start_date].blank? ? impressions :
+        impressions.between(created_at: options[:start_date]..options[:end_date])
+
+
+      # Count all distinct impressions unless the :all filter is provided
+      distinct = options[:filter] != :all
+      distinct ? imps.where(options[:filter].ne => nil).distinct(options[:filter]).count : imps.count
+    end
+
+  end
+end
+
+Mongoid::Document.
+send(:include, Impressionist::Impressionable)

data/lib/impressionist/rails_toggle.rb

@@ -0,0 +1,26 @@
+module Impressionist
+  # Responsibility
+  # Toggles between rails > 3.1 < 4
+  # In order to make attr_accessible available in a rails app < 4
+
+  class RailsToggle
+    # decides where or not to include attr_accessible
+    def should_include?
+      supported_by_rails? && (not using_strong_parameters?)
+    end
+
+    private
+
+      def using_strong_parameters?
+        defined?(StrongParameters)
+      end
+
+      # returns false if rails >= 4
+      # true if rails < 4
+      def supported_by_rails?
+        ::Rails::VERSION::MAJOR.to_i < 4
+      end
+
+  end
+
+end

data/lib/impressionist/setup_association.rb

@@ -0,0 +1,53 @@
+module Impressionist
+  # Impressionist::SetupAssociation.new(entity).set
+  class SetupAssociation
+    def initialize(receiver)
+      @receiver = receiver
+    end
+
+    # True or False
+    # Note toggle returns false if rails >= 4
+    def include_attr_acc?
+      toggle && make_accessible
+    end
+
+    def define_belongs_to
+      if ::Rails::VERSION::MAJOR.to_i >= 5
+        receiver.belongs_to(:impressionable, :polymorphic => true, :optional => true)	         
+      else
+        receiver.belongs_to(:impressionable, :polymorphic => true)
+      end
+    end
+
+    def set
+      define_belongs_to
+      include_attr_acc?
+    end
+
+    private
+      attr_reader :receiver, :toggle
+
+      def make_accessible
+       receiver.
+        attr_accessible(:impressionable_type,
+                        :impressionable_id,
+                        :controller_name,
+                        :request_hash,
+                        :session_hash,
+                        :action_name,
+                        :ip_address,
+                        :view_name,
+                        :referrer,
+                        :message,
+                        :user_id,
+                        :params)
+      end
+
+      def toggle
+        t = RailsToggle.new
+        t.should_include?
+      end
+  end
+end
+
+

data/lib/impressionist/update_counters.rb

@@ -0,0 +1,77 @@
+# Note
+# If impressionist_counter_cache_options[:counter_cache] is false(default)
+# it won't even run this class
+module Impressionist
+
+  class UpdateCounters
+    attr_reader :receiver, :klass
+
+    def initialize(receiver)
+      @receiver = receiver
+      @klass = receiver.class
+    end
+
+    def update
+      klass.
+      update_counters(id, column_name => result)
+    end
+
+    private
+
+    def result
+      impressions_total - impressions_cached
+    end
+
+    # Count impressions based on unique_filter
+    # default is :ip_address when unique: true
+    def impressions_total
+      receiver.impressionist_count filter
+    end
+
+    # Fetch impressions from a receiver's column
+    def impressions_cached
+      receiver.send(column_name) || 0
+    end
+
+    def filter
+      {:filter => unique_filter}
+    end
+
+    # :filter gets assigned to :ip_address as default
+    # One could do
+    # is_impressionable :counter_cache => true,
+    # :unique => :any_other_filter
+    def unique_filter
+      # Support `is_impressionable :counter_cache => true, :unique => true`
+      # defaulting to `:ip_address` for counting unique impressions.
+      return :ip_address if unique == true
+
+      # Should a user try `is_impressionable :counter_cache => true, :unique => false`
+      # then support that as well
+      return :all if unique == false
+
+      # Otherwise set the filter to either what the user supplied as the `unique` option
+      # or the default (`:all`)
+      unique
+    end
+
+    def unique
+      cache_options[:unique]
+    end
+
+    def column_name
+      cache_options[:column_name].to_s
+    end
+
+    def cache_options
+      klass.
+      impressionist_counter_cache_options
+    end
+
+    def id
+      receiver.id
+    end
+
+  end
+
+end

data/lib/impressionist/version.rb

@@ -0,0 +1,3 @@
+module Impressionist
+  VERSION = "2.0.0"
+end