rails-queue-it 0.1.0

data/lib/queue_it.rb

@@ -0,0 +1,25 @@
+require "queue_it/engine"
+
+module QueueIt
+  extend self
+
+  # You can add, in this module, your own configuration options as in the example below...
+  #
+  # attr_writer :my_option
+  #
+  # def my_option
+  #   return "Default Value" unless @my_option
+  #   @my_option
+  # end
+  #
+  # Then, you can customize the default behaviour (typically in a Rails initializer) like this:
+  #
+  # QueueIt.setup do |config|
+  #   config.root_url = "Another value"
+  # end
+
+  def setup
+    yield self
+    require "queue_it"
+  end
+end

data/lib/queue_it/engine.rb

@@ -0,0 +1,15 @@
+module QueueIt
+  class Engine < ::Rails::Engine
+    isolate_namespace QueueIt
+
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      g.fixture_replacement :factory_bot, dir: "spec/factories"
+    end
+
+    initializer "initialize" do
+      # Require here all your engine's classes.
+      require_relative "./example_class"
+    end
+  end
+end

data/lib/queue_it/example_class.rb

@@ -0,0 +1,7 @@
+module QueueIt
+  class ExampleClass
+    def self.say_hi
+      "Hello Platanus developer!"
+    end
+  end
+end

data/lib/queue_it/version.rb

@@ -0,0 +1,3 @@
+module QueueIt
+  VERSION = '0.1.0'
+end

data/lib/tasks/auto_annotate_models.rake

@@ -0,0 +1,67 @@
+if Rails.env.development?
+  task :set_annotation_options do
+    # You can override any of these by setting an environment variable of the
+    # same name.
+    Annotate.set_defaults(
+      'routes' => 'false',
+      'position_in_routes' => 'after',
+      'position_in_class' => 'after',
+      'position_in_test' => 'after',
+      'position_in_fixture' => 'after',
+      'position_in_factory' => 'after',
+      'position_in_serializer' => 'after',
+      'show_foreign_keys' => 'true',
+      'show_indexes' => 'true',
+      'simple_indexes' => 'false',
+      'model_dir' => 'app/models',
+      'root_dir' => '',
+      'include_version' => 'false',
+      'require' => '',
+      'exclude_tests' => 'true',
+      'exclude_fixtures' => 'true',
+      'exclude_factories' => 'true',
+      'exclude_serializers' => 'true',
+      'exclude_scaffolds' => 'true',
+      'exclude_controllers' => 'true',
+      'exclude_helpers' => 'false',
+      'ignore_model_sub_dir' => 'false',
+      'ignore_columns' => nil,
+      'ignore_unknown_models' => 'false',
+      'hide_limit_column_types' => 'integer,boolean',
+      'skip_on_db_migrate' => 'false',
+      'format_bare' => 'true',
+      'format_rdoc' => 'false',
+      'format_markdown' => 'false',
+      'sort' => 'false',
+      'force' => 'false',
+      'trace' => 'false',
+      'wrapper_open' => nil,
+      'wrapper_close' => nil,
+      'models' => true
+    )
+  end
+
+  Annotate.load_tasks
+
+  data_migrate_tasks = %w(
+    db:migrate
+    db:migrate:up
+    db:migrate:down
+    db:migrate:redo
+    db:rollback
+  )
+
+  data_migrate_tasks.each do |task|
+    Rake::Task[task].enhance do
+      Rake::Task[Rake.application.top_level_tasks.last].enhance do
+        annotation_options_task = if Rake::Task.task_defined?('app:set_annotation_options')
+                                    'app:set_annotation_options'
+                                  else
+                                    'set_annotation_options'
+                                  end
+        Rake::Task[annotation_options_task].invoke
+        Annotate::Migration.update_annotations
+      end
+    end
+  end
+end

data/lib/tasks/queue_it_tasks.rake

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

data/queue_it.gemspec

@@ -0,0 +1,38 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem"s version:
+require "queue_it/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name          = "rails-queue-it"
+  s.version       = QueueIt::VERSION
+  s.authors       = ["Platanus", "Gabriel Lyon"]
+  s.email         = ["rubygems@platan.us", "gabriel@platan.us"]
+  s.homepage      = "https://github.com/platanus/queue_it/master"
+  s.summary       = ""
+  s.description   = ""
+  s.license       = "MIT"
+
+  s.files = `git ls-files`.split($/).reject { |fn| fn.start_with? "spec" }
+  s.bindir = "exe"
+  s.executables = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.test_files = Dir["spec/**/*"]
+
+  s.add_dependency "rails", ">= 6.0"
+  s.add_development_dependency "annotate", "~> 3.0"
+  s.add_development_dependency "bundler", "~> 2.2.15"
+  s.add_development_dependency "coveralls"
+  s.add_development_dependency "factory_bot_rails"
+  s.add_development_dependency "faker"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "pg"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "pry-rails"
+  s.add_development_dependency "rspec_junit_formatter"
+  s.add_development_dependency "rspec-rails"
+  s.add_development_dependency "rubocop", "~> 1.9"
+  s.add_development_dependency "rubocop-rails"
+  s.add_development_dependency "shoulda-matchers"
+  s.add_development_dependency "sqlite3"
+end

data/spec/concerns/queue_it/queable_spec.rb

@@ -0,0 +1,492 @@
+describe 'Concerns::Queable' do
+  let(:task) { create(:task) }
+
+  describe '#find_or_create_queue!' do
+    before do
+      task.find_or_create_queue!
+    end
+
+    it { expect(task.queue).not_to be(nil) }
+  end
+
+  describe '#push_to_queue' do
+    context 'when queue is empty or not created' do
+      let(:nodable) { create(:user) }
+
+      before do
+        task.push_to_queue(nodable)
+      end
+
+      it 'expect queue to not be empty' do
+        expect(task.queue).not_to be(nil)
+      end
+
+      it 'expect head_node to be defined' do
+        expect(task.queue.head_node).not_to be(nil)
+      end
+
+      it "expect head_node to be 'head' kind" do
+        expect(task.queue.head_node.kind).to eq('head')
+      end
+    end
+
+    context 'when queue has one previous node' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+      end
+
+      context 'when node addition is in head (in_head is true)' do
+        it "expects to add second_nodable as head and first_nodable to be kind 'tail'" do
+          expect(task.queue.head_node.kind).to eq('head')
+          expect(task.queue.tail_node.kind).to eq('tail')
+        end
+
+        it 'expects first_noable to have second_nodable as parent_node' do
+          expect(task.queue.nodes.find_by(kind: :head).nodable).to eq(second_nodable)
+          expect(task.queue.nodes.find_by(kind: :tail).nodable).to eq(first_nodable)
+          expect(task.queue.nodes.find_by(kind: :tail).parent_node.nodable).to eq(second_nodable)
+        end
+      end
+
+      context 'when node adition is in tail (in_head is false)' do
+        let(:in_head) { false }
+
+        it "expects to add second_nodable as kind 'tail' and first_nodable to still be head" do
+          expect(task.queue.head_node.kind).to eq('head')
+          expect(task.queue.tail_node.kind).to eq('tail')
+        end
+
+        it 'expects second_noable to have first_nodable as parent_node' do
+          expect(task.queue.nodes.find_by(kind: :head).nodable).to eq(first_nodable)
+          expect(task.queue.nodes.find_by(kind: :tail).nodable).to eq(second_nodable)
+          expect(task.queue.nodes.find_by(kind: :tail).parent_node.nodable).to eq(first_nodable)
+        end
+      end
+    end
+
+    context 'when queue has more than one node' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:third_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+        task.push_to_queue(third_nodable, in_head)
+      end
+
+      context 'when node addition is in head (in_head is true)' do
+        it 'expects first_noable to have second_nodable as parent_node and second_nodable to\
+            have third_nodable as parent_node' do
+          expect(task.queue.nodes.find_by(kind: :head).nodable).to eq(third_nodable)
+          expect(task.queue.nodes.find_by(kind: :any).nodable).to eq(second_nodable)
+          expect(task.queue.nodes.find_by(kind: :any).parent_node.nodable).to eq(third_nodable)
+          expect(task.queue.nodes.find_by(kind: :tail).nodable).to eq(first_nodable)
+          expect(task.queue.nodes.find_by(kind: :tail).parent_node.nodable).to eq(second_nodable)
+        end
+      end
+    end
+  end
+
+  describe '#get_next_node_in_queue' do
+    context "when queue dosen't exist or is empty" do
+      it { expect(task.get_next_node_in_queue).to be(nil) }
+    end
+
+    context 'when queue has one node' do
+      let(:nodable) { create(:user) }
+
+      before { task.push_to_queue(nodable) }
+
+      it "expects to find head_node and do not change it's kind value" do
+        expect(task.get_next_node_in_queue.nodable).to eq(nodable)
+        expect(task.queue.nodes.find_by(kind: :head).nodable).to eq(nodable)
+      end
+    end
+
+    context 'when queue has two nodes' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+      end
+
+      it "expects to return second_nodable node and to change node 'head' for 'tail' and reverse" do
+        expect(task.get_next_node_in_queue.nodable).to eq(second_nodable)
+        expect(task.queue.nodes.find_by(kind: :head).nodable).to eq(first_nodable)
+        expect(task.queue.nodes.find_by(kind: :tail).nodable).to eq(second_nodable)
+      end
+    end
+
+    context 'when queue is generic (has more than two nodes)' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:third_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+        task.push_to_queue(third_nodable, in_head)
+      end
+
+      it "expects to get third nodable and to correctly move the queue" do
+        expect(task.get_next_node_in_queue.nodable).to eq(third_nodable)
+        expect(task.queue.nodes.find_by(kind: :head).nodable).to eq(second_nodable)
+        expect(task.queue.nodes.find_by(kind: :any).nodable).to eq(first_nodable)
+        expect(task.queue.nodes.find_by(kind: :tail).nodable).to eq(third_nodable)
+      end
+    end
+  end
+
+  describe '#formatted_queue' do
+    let(:action_to_call) { 'name' }
+
+    context "when queue dosen't exist or is empty" do
+      it { expect(task.formatted_queue(action_to_call)).to be(nil) }
+    end
+
+    context 'when queue has one node' do
+      let(:nodable) { create(:user) }
+
+      before { task.push_to_queue(nodable) }
+
+      it "expects to receive an array with nodable name" do
+        expect(task.formatted_queue(action_to_call)).to eq([nodable.name])
+      end
+    end
+
+    context 'when queue has two nodes' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+      end
+
+      it "expects to receive array with second and first nodable's names" do
+        expect(
+          task.formatted_queue(action_to_call)
+        ).to eq([second_nodable.name, first_nodable.name])
+      end
+    end
+
+    context 'when queue is generic (has more than two nodes)' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:third_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+        task.push_to_queue(third_nodable, in_head)
+      end
+
+      it "expect to receive array with third, second and frist nodable's names" do
+        expect(
+          task.formatted_queue(action_to_call)
+        ).to eq([third_nodable.name, second_nodable.name, first_nodable.name])
+      end
+    end
+  end
+
+  describe '#delete_queue_nodes' do
+    context 'when queue is empty' do
+      before { task.find_or_create_queue! }
+
+      it { expect { task.delete_queue_nodes }.not_to change { task.queue.size } }
+    end
+
+    context 'when queue is with nodes' do
+      let(:nodables) { create_list(:user, 5) }
+
+      before do
+        nodables.each do |nodable|
+          task.push_to_queue(nodable)
+        end
+      end
+
+      it { expect { task.delete_queue_nodes }.to change { task.queue.size }.from(5).to(0) }
+    end
+  end
+
+  describe '#remove_from_queue' do
+    context "when queue dosen't exist or is empty" do
+      let(:nodable) { create(:user) }
+
+      it { expect(task.remove_from_queue(nodable)).to be(nil) }
+    end
+
+    context "when queue does not have the nodable in it" do
+      let(:task) { create(:task, :with_three_nodes) }
+      let(:nodable) { create(:user) }
+
+      it { expect(task.remove_from_queue(nodable)).to be(nil) }
+    end
+
+    context 'when queue has one node' do
+      let(:nodable) { create(:user) }
+
+      before { task.push_to_queue(nodable) }
+
+      it "expects to find and delete the nodables node" do
+        expect { task.remove_from_queue(nodable) }.to change { task.queue.size }.from(1).to(0)
+      end
+    end
+
+    context 'when queue has two different nodables' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+      end
+
+      it "expects to delete first_nodable" do
+        expect do
+          task.remove_from_queue(first_nodable)
+        end.to change { task.queue.size }.from(2).to(1)
+        expect(task.queue.head_node.nodable).to eq(second_nodable)
+      end
+
+      it "expects to delete second_nodable" do
+        expect do
+          task.remove_from_queue(second_nodable)
+        end.to change { task.queue.size }.from(2).to(1)
+        expect(task.queue.head_node.nodable).to eq(first_nodable)
+      end
+
+      context 'when the second_nodable is added in the tail' do
+        let(:in_head) { false }
+
+        it "expects to delete first_nodable" do
+          expect do
+            task.remove_from_queue(first_nodable)
+          end.to change { task.queue.size }.from(2).to(1)
+          expect(task.queue.head_node.nodable).to eq(second_nodable)
+        end
+
+        it "expects to delete second_nodable" do
+          expect do
+            task.remove_from_queue(second_nodable)
+          end.to change { task.queue.size }.from(2).to(1)
+          expect(task.queue.head_node.nodable).to eq(first_nodable)
+        end
+      end
+    end
+
+    context 'when queue has two equal nodables' do
+      let(:nodable) { create(:user) }
+
+      before do
+        task.push_to_queue(nodable)
+        task.push_to_queue(nodable)
+      end
+
+      it "expects to delte both nodes from the queue" do
+        expect do
+          task.remove_from_queue(nodable)
+        end.to change { task.queue.size }.from(2).to(0)
+      end
+    end
+
+    context 'when queue is generic (has more than two nodes)' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:third_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+        task.push_to_queue(third_nodable, in_head)
+      end
+
+      it "expects to delete first_nodable's node and to have second_nodable as tail" do
+        expect do
+          task.remove_from_queue(first_nodable)
+        end.to change { task.queue.size }.from(3).to(2)
+        expect(task.queue.tail_node.nodable).to eq(second_nodable)
+      end
+
+      it "expects to delete second_nodable's node and to have first_nodable as tail" do
+        expect do
+          task.remove_from_queue(second_nodable)
+        end.to change { task.queue.size }.from(3).to(2)
+        expect(task.queue.tail_node.nodable).to eq(first_nodable)
+      end
+
+      it "expects to delete third_nodable's node and to have second_nodable as head" do
+        expect { task.remove_from_queue(third_nodable) }.to change { task.queue.size }.from(3).to(2)
+        expect(task.queue.head_node.nodable).to eq(second_nodable)
+      end
+
+      context 'when nodes are added in the tail' do
+        let(:in_head) { false }
+
+        it "expects to delete first_nodable's node and to have second_nodable as tail" do
+          expect do
+            task.remove_from_queue(first_nodable)
+          end.to change { task.queue.size }.from(3).to(2)
+          expect(task.queue.head_node.nodable).to eq(second_nodable)
+        end
+
+        it "expects to delete second_nodable's node and to have first_nodable as tail" do
+          expect do
+            task.remove_from_queue(second_nodable)
+          end.to change { task.queue.size }.from(3).to(2)
+          expect(task.queue.tail_node.nodable).to eq(third_nodable)
+        end
+
+        it "expects to delete third_nodable's node and to have second_nodable as head" do
+          expect do
+            task.remove_from_queue(third_nodable)
+          end.to change { task.queue.size }.from(3).to(2)
+          expect(task.queue.tail_node.nodable).to eq(second_nodable)
+        end
+      end
+    end
+
+    context 'when queue has three nodes but two nodables are the same' do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(first_nodable, in_head)
+        task.push_to_queue(second_nodable, in_head)
+      end
+
+      it "expects to delete first and second node when first_nodable is deleted" do
+        expect do
+          task.remove_from_queue(first_nodable)
+        end.to change { task.queue.size }.from(3).to(1)
+        expect(task.queue.head_node.nodable).to eq(second_nodable)
+      end
+
+      context 'when nodes are added in the tail' do
+        let(:in_head) { false }
+
+        it "expects to delete first and second node when first_nodable is deleted" do
+          expect do
+            task.remove_from_queue(first_nodable)
+          end.to change { task.queue.size }.from(3).to(1)
+          expect(task.queue.head_node.nodable).to eq(second_nodable)
+        end
+      end
+    end
+
+    context 'when queue has three nodes with the same nodable' do
+      let(:nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(nodable)
+        task.push_to_queue(nodable)
+        task.push_to_queue(nodable)
+      end
+
+      it "expects to delete first and second node when first_nodable is deleted" do
+        expect { task.remove_from_queue(nodable) }.to change { task.queue.size }.from(3).to(0)
+      end
+    end
+
+    context 'when queue has lenght 5', focus: true do
+      let(:first_nodable) { create(:user) }
+      let(:second_nodable) { create(:user) }
+      let(:third_nodable) { create(:user) }
+      let(:fourth_nodable) { create(:user) }
+      let(:fifth_nodable) { create(:user) }
+      let(:in_head) { true }
+
+      before do
+        task.push_to_queue(first_nodable)
+        task.push_to_queue(second_nodable, in_head)
+        task.push_to_queue(third_nodable, in_head)
+        task.push_to_queue(fourth_nodable, in_head)
+        task.push_to_queue(fifth_nodable, in_head)
+      end
+
+      RSpec.shared_examples "properly_removed" do
+        it "expects not to raise an error and to properly delete de nodable's node" do
+          expect { task.remove_from_queue(nodable_to_remove) }.to change {
+            task.queue.size
+          }.from(5).to(4)
+        end
+      end
+
+      context 'when removing the the head_node of the queue (fifth_nodable)' do
+        let(:nodable_to_remove) { fifth_nodable }
+
+        include_examples 'properly_removed'
+
+        it "expects head_node to have third_nodable as child_node" do
+          task.remove_from_queue(fifth_nodable)
+          expect(task.queue.head_node.nodable).to eq(fourth_nodable)
+          expect(task.queue.head_node.child_node.nodable).to eq(third_nodable)
+        end
+      end
+
+      context 'when removing the second nodable of the queue (fourth_nodable)' do
+        let(:nodable_to_remove) { fourth_nodable }
+
+        include_examples 'properly_removed'
+
+        it "expects head_node to have third_nodable as child_node" do
+          task.remove_from_queue(fourth_nodable)
+          expect(task.queue.head_node.child_node.nodable).to eq(third_nodable)
+        end
+      end
+
+      context 'when removing the third nodable of the queue (third_nodable)' do
+        let(:nodable_to_remove) { third_nodable }
+
+        include_examples 'properly_removed'
+
+        it "expects fourth_nodable to have second_nodable as child_node" do
+          task.remove_from_queue(third_nodable)
+          expect(task.queue.head_node.child_node.nodable).to eq(fourth_nodable)
+          expect(task.queue.head_node.child_node.child_node.nodable).to eq(second_nodable)
+        end
+      end
+
+      context 'when removing the penultimaten (second_nodable)' do
+        let(:nodable_to_remove) { second_nodable }
+
+        include_examples 'properly_removed'
+
+        it "expects tail_node to have third_nodable as parent_node" do
+          task.remove_from_queue(second_nodable)
+          expect(task.queue.tail_node.parent_node.nodable).to eq(third_nodable)
+        end
+      end
+
+      context 'when removing the tail_node (first_nodable)' do
+        let(:nodable_to_remove) { first_nodable }
+
+        include_examples 'properly_removed'
+
+        it "expects tail_node to have third_nodable as parent_node" do
+          task.remove_from_queue(first_nodable)
+          expect(task.queue.tail_node.nodable).to eq(second_nodable)
+          expect(task.queue.tail_node.parent_node.nodable).to eq(third_nodable)
+        end
+      end
+    end
+  end
+end