browsing_history 0.0.2

data/lib/browsing_history/storage.rb

@@ -0,0 +1,44 @@
+require 'browsing_history/storages/base'
+
+module BrowsingHistory::Storage
+  class InvalidStorage < BrowsingHistory::Error; end
+  class StoragesNotSet < BrowsingHistory::Error; end
+
+  def self.included(klass)
+    klass.extend ConfigureMethods
+    klass.init_storages
+  end
+
+  module ConfigureMethods
+    attr_reader :current_storage_type
+
+    def current_storage
+      storages[current_storage_type]
+    end
+
+    def storages
+      @storages ||= {}
+    end
+
+    def attach_storage(storage_type, **opts)
+      storage = storages[storage_type]
+
+      if storage
+        storage.connect(opts)
+        @current_storage_type = storage_type
+      else
+        raise InvalidStorage
+      end
+    end
+
+    def init_storages
+      BrowsingHistory.storage_types.each do |key|
+        storages[key] =
+          "BrowsingHistory::Storages::#{key.to_s.camelize}".constantize
+      end
+
+      raise StoragesNotSet if storages.empty?
+      attach_storage(storages.keys.first)
+    end
+  end
+end

data/lib/browsing_history/storages/active_record.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+
+class BrowsingHistory::Storages::ActiveRecord < BrowsingHistory::Storages::Base
+  class << self
+    def connect(_opts = {})
+      self
+    end
+
+    def default_connect_option
+    end
+  end
+end

data/lib/browsing_history/storages/base.rb

@@ -0,0 +1,40 @@
+module BrowsingHistory::Storages
+  IOMethods = %i(fetch add update clear count interface).freeze
+
+  class NotOverideError < BrowsingHistory::Error; end
+
+  class Base
+    attr_accessor :browser, :historizable, :options
+
+    def initialize(browser, historizable)
+      @browser      = browser
+      @historizable = historizable
+    end
+
+    def method_missing(method, *args)
+      if method.in?(IOMethods)
+        raise NotOverideError
+      else
+        super
+      end
+    end
+
+    class << self
+      def connect
+        IOMethods.each do |method|
+          define_singleton_method(method) do |browser, historizable, *_args|
+            opts = _args.dup.extract_options!.merge(default_options)
+            new(browser, historizable).send(method, **opts)
+          end
+        end
+      end
+
+      def default_options
+        {}
+      end
+    end
+  end
+
+  require 'browsing_history/storages/redis'
+  require 'browsing_history/storages/active_record'
+end

data/lib/browsing_history/storages/redis.rb

@@ -0,0 +1,113 @@
+require 'redis'
+require 'redis-objects'
+require 'redis-namespace'
+
+class BrowsingHistory::Storages::Redis < BrowsingHistory::Storages::Base
+  def fetch(opts)
+    if opts[:between]
+      fetch_between(**opts)
+    elsif opts[:at]
+      history.at(opts[:at])
+    else
+      limit = opts[:limit].try(:-, 1) || opts.delete(:end)
+      history.revrange(opts.delete(:start), limit, **opts)
+    end
+  end
+
+  def add(_opts)
+    history.add(historizable, score)
+  end
+
+  def update(opts)
+  end
+
+  def clear(opts)
+    if opts[:expiration]
+      clear_expiration(opts)
+    elsif opts[:all]
+      clear_all
+    else
+      history.delete(historizable)
+    end
+  end
+
+  def count(opts)
+    if opts[:between]
+      count_between(opts)
+    else
+      history.range_size(
+        history.score(history.first),
+        history.score(history.last)
+      )
+    end
+  end
+
+  def interface(_opts)
+    history
+  end
+
+  private
+
+  def history
+    key = %(\
+      #{browser.browser_type}/\
+      #{browser.browser_id}/\
+      #{historizable.historizable_type}\
+    ).delete(' ')
+
+    self.class.set.new(key, marshal: true)
+  end
+
+  def fetch_between(opts)
+    start_date, end_date = parse_between(opts.delete(:between))
+
+    history.revrangebyscore(start_date, end_date, **opts)
+  end
+
+  def clear_expiration(opts)
+    min_score = history.score(history.first)
+
+    history.remrangebyscore(min_score, score(opts[:expiration]))
+  end
+
+  def clear_all
+    history.remrangebyrank(0, -1)
+  end
+
+  def count_between(opts)
+    end_date, start_date = parse_between(opts.delete(:between))
+
+    history.range_size(start_date, end_date)
+  end
+
+  def score(time = nil)
+    time ? time.to_f : Time.now.to_f
+  end
+
+  def parse_between(range)
+    [range.first.to_f, range.last.to_f]
+  end
+
+  class << self
+    attr_reader :redis, :set
+
+    def connect(opts = {})
+      @redis = Redis::Namespace.new(
+        BrowsingHistory.namespace,
+        redis: Redis.new(default_connect_options.merge(opts))
+      )
+      Redis::Objects.redis = @redis
+      @set = Redis::SortedSet
+
+      super()
+    end
+
+    def default_options
+      { start: 0, end: -1 }
+    end
+
+    def default_connect_options
+      { host:  '127.0.0.1', port: 6379, db: 0 }
+    end
+  end
+end

data/lib/browsing_history/version.rb

@@ -0,0 +1,3 @@
+module BrowsingHistory
+  VERSION = '0.0.2'.freeze
+end

data/lib/browsing_history.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+module BrowsingHistory
+  require 'browsing_history/error'
+  require 'browsing_history/configuration'
+  extend Configuration
+
+  require 'browsing_history/history'
+  require 'browsing_history/browser'
+  require 'browsing_history/historizable'
+end

data/lib/generators/active_record/migration_generator.rb

@@ -0,0 +1,12 @@
+require 'rails/generators'
+require 'rails/generators/actions'
+require 'rails/generators/active_record'
+
+class BrowsingHistory::MigrationGenerator < ActiveRecord::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+
+  argument :name, type: :string, default: 'browsing_histories'
+  def generate_files
+    migration_template 'migration.rb', "db/migrate/create_#{name}.rb"
+  end
+end

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,15 @@
+class CreateBrowsingHistories < ActiveRecord::Migration
+  # Create table
+  def up
+    create_table :browsing_histories do |t|
+      t.references :browser,      polymorphic: true, index: true
+      t.references :historizable, polymorphic: true, index: true
+      t.text       :object,       null: false
+      t.timestamps                null: false
+    end
+  end
+
+  # Drop table
+  def down
+  end
+end

data/lib/tasks/browsing_history_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :browsing_history do
+#   # Task goes here
+# end

data/spec/browsing_history/browser_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+require 'fixtures/user'
+require 'fixtures/article'
+
+describe BrowsingHistory::Browser do
+  articles_size = 50
+
+  let(:user)    { User.new }
+  let(:article) { Article.new }
+  let(:articles) do
+    articles_size.times.map.with_index(1) { |i| Article.new(i) }
+  end
+  let(:histories) { user.browsing_histories }
+
+  describe 'respond_to' do
+    context 'instance' do
+      subject { user }
+
+      it { is_expected.to respond_to(:browsing_histories) }
+      it { is_expected.to respond_to(:browser_id) }
+      it { is_expected.to respond_to(:browser_type) }
+      it { is_expected.to respond_to(:browser_class) }
+      it { is_expected.to respond_to(:browser_instance?) }
+    end
+
+    context 'singleton' do
+      subject { user.class }
+
+      it { is_expected.to respond_to(:browser_id) }
+      it { is_expected.to respond_to(:browser_type) }
+      it { is_expected.to respond_to(:browser_class) }
+      it { is_expected.to respond_to(:browser_instance?) }
+    end
+  end
+
+  describe 'assosiation' do
+    describe 'respond_to' do
+      subject { user.browsing_histories }
+
+      it { is_expected.to respond_to(:recent) }
+      it { is_expected.to respond_to(:previous) }
+      it { is_expected.to respond_to(:add) }
+      it { is_expected.to respond_to(:<<) }
+      it { is_expected.to respond_to(:count) }
+    end
+
+    describe '#initialize' do
+      subject { user.browsing_histories }
+      it { is_expected.to be_a("#{described_class}::Association".constantize) }
+    end
+
+    describe '#recent' do
+      context 'default' do
+        it 'should default empty' do
+          expect(histories.recent(article)).to be_empty
+        end
+      end
+
+      context 'when histories exist' do
+        before(:each) do
+          articles.each { |article| histories << article }
+        end
+        let(:recent_articles) { histories.recent(article, limit: articles.size) }
+
+        it 'should equal original' do
+          recent_articles.each_with_index do |article, i|
+            original = articles.reverse[i]
+
+            expect(article.id).to eq(original.id)
+            expect(article.title).to eq(original.title)
+          end
+        end
+      end
+    end
+
+    describe '#previous' do
+      context 'default' do
+        it 'should default empty' do
+          expect(histories.previous(article, Time.now..1.day.ago)).to be_empty
+        end
+      end
+
+      context 'when histories exist' do
+        before do
+          articles.each { |article| histories << article }
+        end
+
+        let(:recent_article) { Article.new(100) }
+        let(:previous_article) do
+          histories.previous(article, Time.now..5.seconds.ago)
+        end
+
+        it 'should return 1 historizable' do
+          sleep(6)
+          histories << recent_article
+
+          expect(previous_article.size).to eq(1)
+          expect(previous_article.first.id).to eq(recent_article.id)
+          expect(previous_article.first.title).to eq(recent_article.title)
+        end
+      end
+    end
+
+    describe '#add' do
+      context 'add' do
+        it 'should return historizable' do
+          expect(histories.add(article)).to be_truthy
+        end
+
+        context 'before add historizable' do
+          before { histories.add(article) }
+
+          let(:saved_article) { histories.recent(article).first }
+          it 'should equal original' do
+            expect(saved_article.id).to eq(article.id)
+            expect(saved_article.title).to eq(article.title)
+          end
+        end
+      end
+
+      context '<<' do
+        it 'should return historizable' do
+          expect(histories << article).to be_truthy
+        end
+
+        context 'before << historizable' do
+          before { histories << article }
+
+          let(:saved_article) { histories.recent(article).first }
+          it 'should equal original' do
+            expect(saved_article.id).to eq(article.id)
+            expect(saved_article.title).to eq(article.title)
+          end
+        end
+      end
+
+      describe '#count' do
+        context 'default' do
+          it 'should default empty' do
+            expect(histories.count(article)).to eq(0)
+          end
+        end
+
+        context 'when histories exist' do
+          before do
+            articles.each { |article| histories << article }
+          end
+
+          it 'should return historizables count' do
+            expect(histories.count(article)).to eq(articles.size)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/browsing_history/configration_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe BrowsingHistory::Configuration do
+  let(:storage_types) { %i(redis active_record) }
+  let(:storage_type) { storage_types.first }
+
+  describe '#configure' do
+    it 'should have default attributes' do
+      BrowsingHistory.configure do |configuration|
+        expect(configuration.storage_types).to eql(storage_types)
+        expect(configuration.storage_type).to eql(storage_type)
+        expect(configuration.namespace).to eql('browsing_history')
+      end
+    end
+  end
+end

data/spec/browsing_history/fixtures/article.rb

@@ -0,0 +1,10 @@
+class Article
+  include BrowsingHistory::Historizable
+
+  attr_reader :id, :title
+
+  def initialize(id = nil)
+    @id    = id || rand(1000)
+    @title = random_string
+  end
+end

data/spec/browsing_history/fixtures/user.rb

@@ -0,0 +1,10 @@
+class User
+  include BrowsingHistory::Browser
+
+  attr_reader :id, :title
+
+  def initialize
+    @id   = rand(1000)
+    @name = random_string
+  end
+end

data/spec/browsing_history/historizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'fixtures/user'
+require 'fixtures/article'
+
+describe BrowsingHistory::Browser do
+  let(:article) { Article.new }
+
+  describe 'respond_to' do
+    context 'instance' do
+      subject { article }
+
+      it { is_expected.to respond_to(:historizable_id) }
+      it { is_expected.to respond_to(:historizable_type) }
+      it { is_expected.to respond_to(:historizable_class) }
+      it { is_expected.to respond_to(:historizable_instance?) }
+    end
+
+    context 'singleton' do
+      subject { article.class }
+
+      it { is_expected.to respond_to(:historizable_id) }
+      it { is_expected.to respond_to(:historizable_type) }
+      it { is_expected.to respond_to(:historizable_class) }
+      it { is_expected.to respond_to(:historizable_instance?) }
+    end
+  end
+end