impressionist-cody 2.0.0

data/CHANGELOG.rdoc

@@ -0,0 +1,96 @@
+== 1.6.1 (2018-04-16)
+* Add belongs_to optional true to setup_association (#264, @josephMG)
+* Add missing field for Mongoid (#254, @Fibrasek)
+* Implemented patch that will add the Rails major version to the migration file (#248, @jordanhudgens)
+* Add params filtering on new column (#246, @rposborne)
+* Add a DB migration to add params to schema. (#245, @rposborne)
+
+== 1.6.0 (2017-05-24)
+* Documentation example for counter_cache (#239, @fwolfst)
+* Green Travis CI builds (#238, @jgrau)
+* Rails 5.1 support (#241, @msimonborg)
+* Use `dependent: :delete_all` instead of `:destroy` for performance gains (#242, @midnightSuyama & @jgrau)
+* Fix counter cache not updating when no `unique` option is set (#243, @sachiotomita & @jgrau)
+
+== 1.5.2 (2016-09-16)
+
+== 1.5.1 (2013-12-31)
+
+== 1.5.0 (2013-12-30)
+* Added message filtering.
+* (@overovermind)
+
+== 1.4.8 (2013-09-01)
+* Fixed #108
+* Clean up
+* (@acnalesso)
+
+== 1.4.7 (2013-08-30)
+* Fixed #103 - Allow impressions to be saved without a Model
+* Fixed #104 - Wrong Documentation
+* (@acnalesso)
+
+== 1.4.6 (2013-08-17)
+* Fixed 106
+* Count unique records in Rails 4
+
+== 1.4.5 (2013-07-17)
+* Fixed update_counters raising an exception #97
+
+== 1.4.4 (2013-07-15)
+* Updated templates/impression.rb
+
+== 1.4.3 (2013-07-15)
+* Fixed Generators #96
+* Remove pending tests, added tags
+
+== 1.4.2 (2013-07-12)
+* Added Mongoid Support
+* Support Rails > 3.1 < 4.0
+* Fixed #93
+* Fixed travis failing
+* Added two new entities
+* Added MiniTest, testing against impressionist ( RSpec still testing test_app, will be removed soon)
+* Clean up
+* Moved all tests into tests dir
+
+== 1.4.1 (2013-07-07)
+* Added test support
+* fix trailing space
+* Created individually rspec files
+* (@nbit001)
+
+== 1.4.0 (2013-07-06)
+* Fixed #92
+* Pass option to unique for updatind counter_cache
+* Clean up code, make it human readable
+* Changed README in order to explain new features
+* (@nbit001)
+
+== 1.3.3 (2013-06-27)
+* Added Rails4 Branch in order to support rails 4
+* Rails 4 and Strong Parameters compability. (@bennick).
+
+== 1.3.1 (non specified)
+* Change controller_path back to controller_name (@johnmcaliley)
+
+
+== 0.4.0 (2011-06-03)
+* Fix postgres bug
+* New impression count method that accepts options for filter, start_date and end_date
+* Add referrer to Impression model.  YOU MUST RUN THE UPGRADE MIGRATION IF YOU ARE UPGRADING FROM 0.3.0
+* UPGRADE MIGRATION = impressionist/upgrade_migrations/version_0_4_0.rb
+* NOTE IF YOU ARE UPGRADING FROM 0.2.5 OR BELOW, YOU MUST RUN BOTH UPGRADE MIGRATIONS
+
+== 0.3.0 (2011-03-06)
+* added session_hash to impression model
+* migration template updated to add session_hash
+* new count instance method for impressionable model - unique_impression_count_session
+* NOTE: if you are upgrading from 0.2.5, then run the migration in the 'upgrade_migrations' dir
+
+== 0.2.5 (2011-02-17)
+* New model method - @widget.unique_impression_count_ip  - This gives you unique impression account filtered by IP (and in turn request_hash since they have same IPs)
+* @widget.unique_impression_count now uses request_hash.  This was incorrectly stated in the README, since it was using ip_address.  The README is correct as a result of the method change.
+
+== 0.2.4 (2011-02-17)
+* Fix issue #1 - action_name and controller_name were not being logged for impressionist method inside action

data/Gemfile

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+gem 'rake', '>= 12.3.3'
+gem 'rdoc', '>= 2.4.2'
+
+platforms :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter'
+  gem 'jdbc-sqlite3'
+  gem 'jruby-openssl'
+end
+
+group :test do
+  gem 'minitest'
+  gem 'pry'
+  gem 'rspec', "~> 3.0"
+  gem 'rubocop-rails', require: false
+  gem 'rubocop-rspec', require: false
+  gem 'simplecov'
+  gem 'systemu'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2018 github.com/johnmcaliley
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,265 @@
+![Impressionist Logo](https://github.com/charlotte-ruby/impressionist/raw/master/logo.png)
+
+[![Build Status](https://secure.travis-ci.org/charlotte-ruby/impressionist.png?branch=master)](http://travis-ci.org/charlotte-ruby/impressionist)
+[![Code Climate](https://codeclimate.com/github/charlotte-ruby/impressionist.png)](https://codeclimate.com/github/charlotte-ruby/impressionist)
+
+WE ARE LOOKING FOR MAINTAINERS.  CONTACT @johnmcaliley IF YOU ARE INTERESTED IN HELPING
+=======================================================================================
+
+impressionist
+=============
+
+A lightweight plugin that logs impressions per action or manually per model
+
+--------------------------------------------------------------------------------
+
+What does this thing do?
+------------------------
+Logs an impression... and I use that term loosely.  It can log page impressions
+(technically action impressions), but it is not limited to that. You can log
+impressions multiple times per request.  And you can also attach it to a model.
+The goal of this project is to provide customizable stats that are immediately
+accessible in your application as opposed to using Google Analytics and pulling
+data using their API.  You can attach custom messages to impressions.  No
+reporting yet.. this thingy just creates the data.
+
+What about bots?
+----------------
+They are ignored.  1200 known bots have been added to the ignore list as of
+February 1, 2011.  Impressionist uses this list:
+http://www.user-agents.org/allagents.xml
+
+Installation
+------------
+Add it to your Gemfile
+
+    #rails 6
+    gem 'impressionist'
+    
+    #rails 5 or lower
+    gem 'impressionist', '~>1.6.1'
+
+Install with Bundler
+
+    bundle install
+
+Generate the impressions table migration
+
+    rails g impressionist
+
+Run the migration
+
+    rake db:migrate
+
+The following fields are provided in the migration:
+
+    t.string   "impressionable_type"  # model type: Widget
+    t.integer  "impressionable_id"    # model instance ID: @widget.id
+    t.integer  "user_id"              # automatically logs @current_user.id
+    t.string   "controller_name"      # logs the controller name
+    t.string   "action_name"          # logs the action_name
+    t.string   "view_name"            # TODO: log individual views (as well as partials and nested partials)
+    t.string   "request_hash"         # unique ID per request, in case you want to log multiple impressions and group them
+    t.string   "session_hash"         # logs the rails session
+    t.string   "ip_address"           # request.remote_ip
+    t.text     "params"               # request.params, except action name, controller name and resource id
+    t.string   "referrer"             # request.referer
+    t.string   "message"              # custom message you can add
+    t.datetime "created_at"           # I am not sure what this is.... Any clue?
+    t.datetime "updated_at"           # never seen this one before either....  Your guess is as good as mine?? ;-)
+
+Usage
+-----
+
+1. Log all actions in a controller
+
+        WidgetsController < ApplicationController
+          impressionist
+        end
+
+2. Specify actions you want logged in a controller
+
+        WidgetsController < ApplicationController
+          impressionist :actions=>[:show,:index]
+        end
+
+3. Make your models impressionable.  This allows you to attach impressions to
+   an AR model instance.  Impressionist will automatically log the Model name
+   (based on action_name) and the id (based on params[:id]), but in order to
+   get the count of impressions (example: @widget.impression_count), you will
+   need to make your model impressionable
+
+        class Widget < ActiveRecord::Base
+          is_impressionable
+        end
+
+4. Log an impression per model instance in your controller.  Note that it is
+   not necessary to specify "impressionist" (usage #1) in the top of you
+   controller if you are using this method.  If you add "impressionist" to the
+   top of your controller and also use this method in your action, it will
+   result in 2 impressions being logged (but associated with one request_hash).
+   If you're using [friendly_id](https://github.com/norman/friendly_id) be sure
+   to log impressionist this way, as params[:id] will return a string(url slug)
+   while impressionable_id is a Integer column in database. Also note that you
+   have to take step #3 for the Widget model for this to work.
+
+        def show
+          @widget = Widget.find
+          impressionist(@widget, "message...") # 2nd argument is optional
+        end
+
+5. Get unique impression count from a model.  This groups impressions by
+   request_hash, so if you logged multiple impressions per request, it will
+   only count them one time.  This unique impression count will not filter out
+   unique users, only unique requests
+
+        @widget.impressionist_count
+        @widget.impressionist_count(:start_date=>"2011-01-01",:end_date=>"2011-01-05")
+        @widget.impressionist_count(:start_date=>"2011-01-01")  #specify start date only, end date = now
+
+6. Get the unique impression count from a model filtered by IP address.  This
+   in turn will give you impressions with unique request_hash, since rows with
+   the same request_hash will have the same IP address.
+
+        @widget.impressionist_count(:filter=>:ip_address)
+
+7. Get the unique impression count from a model filtered by params.  This
+   in turn will give you impressions with unique params.
+
+        @widget.impressionist_count(:filter => :params)
+
+8. Get the unique impression count from a model filtered by session hash.  Same
+   as #6 regarding request hash.  This may be more desirable than filtering by
+   IP address depending on your situation, since filtering by IP may ignore
+   visitors that use the same IP.  The downside to this filtering is that a
+   user could clear session data in their browser and skew the results.
+
+        @widget.impressionist_count(:filter=>:session_hash)
+
+9. Get total impression count.  This may return more than 1 impression per http
+   request, depending on how you are logging impressions
+
+        @widget.impressionist_count(:filter=>:all)
+
+10. Get impression count by message.  This only counts impressions of the given message.
+
+        @widget.impressionist_count(:message=>"pageview", :filter=>:all)
+
+Logging impressions for authenticated users happens automatically.  If you have
+a current_user helper or use @current_user in your before_filter (or before_action in Rails >= 5.0) to set your
+authenticated user, current_user.id will be written to the user_id field in the
+impressions table.
+
+Adding a counter cache
+----------------------
+Impressionist makes it easy to add a `counter_cache` column to your model. The
+most basic configuration looks like:
+
+    is_impressionable :counter_cache => true
+
+This will automatically increment the `impressions_count` column in the
+included model. <b>Note: You'll need to add that column to your model. If you'd
+like specific a different column name, you can:</b>
+
+    is_impressionable :counter_cache => true, :column_name => :my_column_name
+
+If you'd like to include only unique impressions in your count:
+
+    # default will be filtered by ip_address
+    is_impressionable :counter_cache => true, :column_name => :my_column_name, :unique => true
+
+If you'd like to specify what sort of unique impression you'd like to save? Fear not,
+Any option you pass to unique, impressionist_count will use it as its filter to update_counters based on that unique option.
+
+    # options are any column in the impressions' table.
+    is_impressionable :counter_cache => true, :column_name => :my_column_name, :unique => :request_hash
+    is_impressionable :counter_cache => true, :column_name => :my_column_name, :unique => :all
+
+
+Adding column to model
+----------------------
+It is as simple as this:
+
+    t.integer :my_column_name, :default => 0
+
+If you want to use the typical Rails 4 migration generator, you can:
+
+    rails g migration AddImpressionsCountToBook impressions_count:int
+
+What if I only want to record unique impressions?
+-------------------------------------------------
+Maybe you only care about unique impressions and would like to avoid
+unnecessary database records. You can specify conditions for recording
+impressions in your controller:
+
+    # only record impression if the request has a unique combination of type, id, and session
+    impressionist :unique => [:impressionable_type, :impressionable_id, :session_hash]
+
+    # only record impression if the request has a unique combination of controller, action, and session
+    impressionist :unique => [:controller_name, :action_name, :session_hash]
+
+    # only record impression if session is unique
+    impressionist :unique => [:session_hash]
+
+    # only record impression if param is unique
+    impressionist :unique => [:params]
+
+Or you can use the `impressionist` method directly:
+
+    impressionist(impressionable, "some message", :unique => [:session_hash])
+
+Are you using Mongoid?
+---------------------
+
+Execute this command on your terminal/console:
+
+    rails g impressionist --orm mongoid
+
+This command create a file `impression.rb` on `config/initializer` folder. Add `config.orm = :mongoid` to this file:
+
+    # 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
+      config.orm = :mongoid
+    end
+
+
+Contributing to impressionist
+-----------------------------
+* Check out the latest master to make sure the feature hasn't been implemented
+  or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it
+  and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add rpsec tests for it. Patches or features without tests will
+  be ignored.  Also, try to write better tests than I do ;-)
+* If adding engine controller or view functionality, use HAML and Inherited
+  Resources.
+* All testing is done inside a small Rails app (test_app).  You will find specs
+  within this app.
+
+
+Want to run the tests? Ok mummy
+-------------------------------
+* bundle install
+* rails g impressionist
+* rake db:migrate && rake db:test:prepare
+* Run rake or rspec spec inside test_app dir
+* nothing else.
+* :wq
+
+Contributors
+------------
+WE ARE CURRENTLY LOOKING FOR SOMEONE TO HELP MAINTAIN THIS REPOSITORY.  IF YOU ARE INTERESTED, MESSAGE @johnmcaliley.
+
+* [johnmcaliley - creator](https://github.com/johnmcaliley)
+* [jgrau](https://github.com/jgrau)
+* [acnalesso](https://github.com/acnalesso)
+* [coryschires](https://github.com/coryschires)
+* [georgmittendorfer](https://github.com/georgmittendorfer)
+
+
+Copyright (c) 2011 John McAliley. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+
+require 'rspec'
+require 'rspec/core/rake_task'
+require 'rake/testtask'
+
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+Bundler::GemHelper.install_tasks
+
+namespace :impressionist do
+  require "#{File.dirname(__FILE__)}/lib/impressionist/bots"
+
+  desc "output the list of bots from http://www.user-agents.org/"
+  task :bots do
+    p Impressionist::Bots.consume
+  end
+end

data/UPGRADE_GUIDE.md

@@ -0,0 +1,13 @@
+# Upgrade guide
+
+## v1.5.1 -> v1.5.2
+
+Version 1.5.2 adds are new column to the `impressions` table. If you're on v1.5.1 you need to manually add the new column using
+
+```
+add_column :impressions, :params, :text
+
+add_index :impressions, [:impressionable_type, :impressionable_id, :params], :name => "poly_params_request_index", :unique => false
+```
+
+before upgrading.

data/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/app/controllers/impressionist_controller.rb

@@ -0,0 +1,166 @@
+require 'digest/sha2'
+
+
+module ImpressionistController
+  module ClassMethods
+    def impressionist(opts={})
+      if Rails::VERSION::MAJOR >= 5
+        before_action { |c| c.impressionist_subapp_filter(opts) }
+      else
+        before_filter { |c| c.impressionist_subapp_filter(opts) }
+      end
+    end
+  end
+
+  module InstanceMethods
+    def self.included(base)
+      if Rails::VERSION::MAJOR >= 5
+        base.before_action :impressionist_app_filter
+      else
+        base.before_filter :impressionist_app_filter
+      end
+    end
+
+    def impressionist(obj,message=nil,opts={})
+      if should_count_impression?(opts)
+        if obj.respond_to?("impressionable?")
+          if unique_instance?(obj, opts[:unique])
+            obj.impressions.create(associative_create_statement({:message => message}))
+          end
+        else
+          # we could create an impression anyway. for classes, too. why not?
+          raise "#{obj.class.to_s} is not impressionable!"
+        end
+      end
+    end
+
+    def impressionist_app_filter
+      @impressionist_hash = Digest::SHA2.hexdigest(Time.now.to_f.to_s+rand(10000).to_s)
+    end
+
+    def impressionist_subapp_filter(opts = {})
+      if should_count_impression?(opts)
+        actions = opts[:actions]
+        actions.collect!{|a|a.to_s} unless actions.blank?
+        if (actions.blank? || actions.include?(action_name)) && unique?(opts[:unique])
+          Impression.create(direct_create_statement)
+        end
+      end
+    end
+
+    protected
+
+    # creates a statment hash that contains default values for creating an impression via an AR relation.
+    def associative_create_statement(query_params={})
+        # support older versions of rails:
+        # see https://github.com/rails/rails/pull/34039
+      if Rails::VERSION::MAJOR < 6
+        filter = ActionDispatch::Http::ParameterFilter.new(Rails.application.config.filter_parameters)
+      else
+        filter = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+      end
+
+      query_params.reverse_merge!(
+        :controller_name => controller_name,
+        :action_name => action_name,
+        :user_id => user_id,
+        :request_hash => @impressionist_hash,
+        :session_hash => session_hash,
+        :ip_address => request.remote_ip,
+        :referrer => request.referer,
+        :params => filter.filter(params_hash)
+        )
+    end
+
+    private
+
+    def bypass
+      Impressionist::Bots.bot?(request.user_agent)
+    end
+
+    def should_count_impression?(opts)
+      !bypass && condition_true?(opts[:if]) && condition_false?(opts[:unless])
+    end
+
+    def condition_true?(condition)
+      condition.present? ? conditional?(condition) : true
+    end
+
+    def condition_false?(condition)
+      condition.present? ? !conditional?(condition) : true
+    end
+
+    def conditional?(condition)
+      condition.is_a?(Symbol) ? self.send(condition) : condition.call
+    end
+
+    def unique_instance?(impressionable, unique_opts)
+      return unique_opts.blank? || !impressionable.impressions.where(unique_query(unique_opts, impressionable)).exists?
+    end
+
+    def unique?(unique_opts)
+      return unique_opts.blank? || check_impression?(unique_opts)
+    end
+
+    def check_impression?(unique_opts)
+      impressions = Impression.where(unique_query(unique_opts - [:params]))
+      check_unique_impression?(impressions, unique_opts)
+    end
+
+    def check_unique_impression?(impressions, unique_opts)
+      impressions_present = impressions.exists?
+      impressions_present && unique_opts_has_params?(unique_opts) ? check_unique_with_params?(impressions) : !impressions_present
+    end
+
+    def unique_opts_has_params?(unique_opts)
+      unique_opts.include?(:params)
+    end
+
+    def check_unique_with_params?(impressions)
+      request_param = params_hash
+      impressions.detect{|impression| impression.params == request_param }.nil?
+    end
+
+    # creates the query to check for uniqueness
+    def unique_query(unique_opts,impressionable=nil)
+      full_statement = direct_create_statement({},impressionable)
+      # reduce the full statement to the params we need for the specified unique options
+      unique_opts.reduce({}) do |query, param|
+        query[param] = full_statement[param]
+        query
+      end
+    end
+
+    # creates a statment hash that contains default values for creating an impression.
+    def direct_create_statement(query_params={},impressionable=nil)
+      query_params.reverse_merge!(
+        :impressionable_type => controller_name.singularize.camelize,
+        :impressionable_id => impressionable.present? ? impressionable.id : params[:id]
+        )
+      associative_create_statement(query_params)
+    end
+
+    def session_hash
+      id = session.id || request.session_options[:id]
+
+      if id.respond_to?(:cookie_value)
+        id.cookie_value
+      elsif id.is_a?(Rack::Session::SessionId)
+        id.public_id
+      else
+        id.to_s
+      end
+    end
+
+    def params_hash
+      request.params.except(:controller, :action, :id)
+    end
+
+    #use both @current_user and current_user helper
+    def user_id
+      user_id = @current_user ? @current_user.id : nil rescue nil
+      user_id = current_user ? current_user.id : nil rescue nil if user_id.blank?
+      user_id
+    end
+  end
+end

data/app/models/impression.rb

@@ -0,0 +1,2 @@
+class Impression
+end