dallal 0.0.1

data/lib/dallal.rb

@@ -0,0 +1,41 @@
+require "dallal/engine" if defined?(Rails)
+require 'dallal/notification'
+require 'dallal/notifiers/notifier'
+require 'dallal/events/events'
+require 'dallal/configuration'
+require 'dallal/events/event_publisher'
+
+module Dallal
+  extend Configuration
+  # Add here include Notifiable and move all methods below to
+  # Notifiable Module
+
+  def self.included(base)
+    base.include(InstanceMethods)
+    base.extend(ClassMethods)
+    
+    base.class_eval do
+      include Dallal::Events::Publisher
+
+      after_create :publish_notification_created
+      after_update :publish_notification_updated
+    end
+  end
+
+  module ClassMethods
+  end
+
+  module InstanceMethods
+    def publish_notification_created
+      Dallal::Events::EventPublisher.broadcast({
+        class: self.class.name, id: self.id, event: :create
+      })
+    end
+
+    def publish_notification_updated
+      Dallal::Events::EventPublisher.broadcast({
+        class: self.class.name, id: self.id, event: :update
+      })
+    end
+  end
+end

data/lib/generators/dallal/install/USAGE

@@ -0,0 +1,2 @@
+Description:
+  Generate a config initializer for user notification

data/lib/generators/dallal/install/install_generator.rb

@@ -0,0 +1,11 @@
+module Dallal
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base 
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      
+      def copy_initializer
+         template 'dallal.rb', 'config/initializers/dallal.rb'
+      end
+    end
+  end
+end

data/lib/generators/dallal/install/templates/dallal.rb

@@ -0,0 +1,16 @@
+Dallal.configure do |config|
+  # Set the user class name of your app
+  config.user_class_name  = 'User'
+
+  # Set up user notification class name
+  config.dallal_class_name = 'Dallal'
+
+  # Enable / Disable notifications globaly
+  config.enabled = true
+
+  # 
+  # config.available_notifications = [:email]
+
+  # 
+  # config.auto_deliver = true
+end

data/lib/generators/dallal/notification/USAGE

@@ -0,0 +1,2 @@
+Description:
+  Generates a notification migration and model

data/lib/generators/dallal/notification/notification_generator.rb

@@ -0,0 +1,44 @@
+require 'rails/generators/active_record'
+
+module Dallal
+  module Generators
+    class NotificationGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+
+      def notifications_table_name
+        "#{table_name.singularize}_notifications"
+      end
+
+      def copy_migration
+        migration_template "migration.rb", "db/migrate/create_#{notifications_table_name}.rb"
+      end
+
+      def copy_files
+        copy_file "model.rb", model_path
+
+        if self.behavior == :invoke
+          inject_into_class(model_path, model_class_name, model_content)
+        end
+      end
+
+      private
+      def model_class_name
+        "#{table_name.singularize}_notification".classify
+      end
+
+      def user_model_name
+        Dallal.configuration.user_class_name.downcase
+      end
+
+      def model_path
+        "app/models/#{table_name.singularize}_notification.rb"
+      end
+
+      def model_content
+        <<-TEXT
+  belongs_to #{user_model_name}
+        TEXT
+      end
+    end
+  end
+end

data/lib/generators/dallal/notification/templates/migration.rb

@@ -0,0 +1,10 @@
+class Create<%= notifications_table_name.camelize %> < ActiveRecord::Migration
+  def change
+    create_table :<%= notifications_table_name %> do |t|
+      t.references :<%= user_model_name %>, index: true, foreign_key: true, null: false
+      t.timestamp :sent_at
+      t.timestamp :deliver_at
+      t.timestamps
+    end
+  end
+end

data/lib/generators/dallal/notification/templates/model.rb

@@ -0,0 +1,2 @@
+class Dallal < ActiveRecord::Based
+end

data/lib/generators/dallal/notifiers/USAGE

@@ -0,0 +1,2 @@
+Description:
+  Create concrete notifiers

data/lib/generators/dallal/notifiers/notifiers_generator.rb

@@ -0,0 +1,56 @@
+require 'rails/generators/active_record'
+
+module Dallal
+  module Generators
+    class NotifiersGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      
+      def copy_migration
+        migration_template "#{notifier_name}_notifier_migration.rb", "db/migrate/create_#{notifier_name}_notifiers.rb"
+      end
+
+      # TODO Refactor and DRY this or better DRY 3 step generation process into 1 or 2.
+      def copy_files
+        copy_file "#{notifier_name}_notifier.rb", model_path
+
+        if self.behavior == :invoke
+          inject_into_class(model_path, model_class_name, model_content)
+        end
+      end
+    
+      def dallal_class_name
+        Dallal.configuration.dallal_class_name.underscore
+      end
+
+      private
+      def notifications_table_name
+        "#{notifier_name}_notifiers"
+      end
+
+      # A quick and dirty patch for sms -> sm singularization
+      def notifier_name
+        case table_name
+        when 'sms'
+          # TODO Revisit this one. sms name [singularizes as sm]
+          'sms'
+        else
+          table_name.singularize
+        end
+      end
+
+      def model_class_name
+        "#{notifier_name}_notifier".classify
+      end
+
+      def model_content
+        <<-RUBY
+  belongs_to #{dallal_class_name}
+        RUBY
+      end
+
+      def model_path
+        "app/models/#{notifier_name}_notifier.rb"
+      end
+    end
+  end
+end

data/lib/generators/dallal/notifiers/templates/email_notifier.rb

@@ -0,0 +1,2 @@
+class EmailNotifier < ActiveRecord::Base
+end

data/lib/generators/dallal/notifiers/templates/email_notifier_migration.rb

@@ -0,0 +1,7 @@
+class Create<%= notifications_table_name.camelize %> < ActiveRecord::Migration
+  def change
+    create_table :<%= notifications_table_name %> do |t|
+      t.timestamps
+    end
+  end
+end

data/lib/generators/dallal/notifiers/templates/sms_notifier.rb

@@ -0,0 +1,2 @@
+class SmsNotifier < ActiveRecord::Base
+end

data/lib/generators/dallal/notifiers/templates/sms_notifier_migration.rb

@@ -0,0 +1,7 @@
+class Create<%= notifications_table_name.camelize %> < ActiveRecord::Migration
+  def change
+    create_table :<%= notifications_table_name %> do |t|
+      t.timestamps
+    end
+  end
+end

data/lib/tasks/user_notification_tasks.rake

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

data/spec/dallal/configuration_spec.rb

@@ -0,0 +1,56 @@
+require 'rails_helper'
+
+describe Dallal::Configuration do
+  subject do
+    class DummClass
+      extend Dallal::Configuration
+    end
+
+    DummClass
+  end
+
+  describe '.configure' do
+    it 'returns the configuration when a block is given' do
+      subject.configure do |config|
+        expect(config).to be_a Dallal::Configuration::Configuration
+      end
+    end
+
+    it { expect(subject.configure).to be nil }
+
+    context "Configuration settings" do
+      before do
+        subject.configure do |config|
+          config.user_class_name = 'UserClassName'
+        end
+      end
+
+      it 'should have set confg attributes correctly' do
+        expect(subject.configuration.user_class_name).to eq 'UserClassName'
+      end
+    end
+  end
+
+  describe '.options' do
+    before do
+      subject.configure do |config|
+        config.user_class_name = 'UserClass'
+      end
+    end
+
+    it 'should return all options' do
+      expect(subject.options).to eq({
+        user_class_name: 'UserClass',
+        dallal_class_name: 'Dallal',
+        enabled: true,
+        email_layout: 'mailer',
+        from_email: 'foo@bar.xyz',
+        from_name: 'just a name'
+      })
+    end
+  end
+
+  describe 'Default Config Values' do
+    pending
+  end
+end

data/spec/dallal/dallal_spec.rb

@@ -0,0 +1,23 @@
+require 'rails_helper'
+
+describe Dallal do
+  context "callbacks" do
+    subject { FactoryGirl.build(:user) }
+    it 'should broadcast a created event' do
+      allow(subject).to receive(:id).and_return(1)
+
+      expect(Dallal::Events::EventPublisher).to receive(:broadcast).
+        with(class: subject.class.name, id: subject.id, event: :create).and_call_original
+
+      subject.save!
+    end
+    it 'should broadcase an updated event' do
+      subject.save
+
+      expect(Dallal::Events::EventPublisher).to receive(:broadcast).
+        with(class: subject.class.name, id: subject.id, event: :update).and_call_original
+
+      subject.save!
+    end
+  end
+end

data/spec/dallal/events/event_publisher_spec.rb

@@ -0,0 +1,7 @@
+require 'rails_helper'
+
+describe Dallal::Events::EventPublisher do
+  it { expect(subject).to be_a Dallal::Events::Publisher }
+
+  it { expect(subject.class.pub_sub_namespace).to eq 'dallals' }
+end

data/spec/dallal/events/event_subscriber_spec.rb

@@ -0,0 +1,92 @@
+require 'rails_helper'
+
+describe Dallal::Events::EventSubscriber do
+  let(:publisher) { Dallal::Events::EventPublisher }
+  let(:payload) { { a: 1, b: 2 } }
+  let(:user) { FactoryGirl.build(:user) }
+  
+  before { allow(user).to receive(:id).and_return(12) }
+
+  context 'when a create event is broadcasted' do
+    it 'creates a new instance and exeutes' do
+      base_event = double('Dallal::Events::EventSubscriber')
+      expect(Dallal::Events::EventSubscriber).to receive(:new).with(class: user.class.name, id: user.id, event: :create).and_return(base_event)
+      expect(base_event).to receive(:execute)
+      user.save!
+    end
+  end
+
+  context 'when a create event is broadcasted' do
+    it 'creates a new instance and executes' do
+      # save the user
+      user.save!
+
+      base_event = double('Dallal::Events::EventSubscriber')
+      expect(Dallal::Events::EventSubscriber).to receive(:new).with(class: user.class.name, id: user.id, event: :update).and_return(base_event)
+      expect(base_event).to receive(:execute)
+
+      # update user
+      user.save!
+    end
+  end
+
+  # Instance spec
+  let(:payload) do
+    {
+      class: 'User',
+      id: 1,
+      event: :create
+    }
+  end
+  
+  subject { Dallal::Events::EventSubscriber.new(payload) }
+
+  describe '#execute' do
+    context 'when notifications are supported' do
+      before { expect(subject).to receive(:should_create_notifications?).and_return(true) }
+
+      it 'triggers a bg job using ActiveJob' do
+        expect(Dallal::DallalJob).to receive(:perform_later).with(payload[:class], payload[:id], payload[:event].to_s).and_call_original
+        subject.execute
+      end
+    end
+    context 'when notifications are not supported' do
+      before { expect(subject).to receive(:should_create_notifications?).and_return(false) }
+      it 'does not  trigger any job' do
+        expect(Dallal::DallalJob).to_not receive(:perform_later).with(payload[:class], payload[:id], payload[:event].to_s).and_call_original
+        subject.execute
+      end
+    end
+  end
+
+  describe '#should_create_notifications?' do
+    context 'when notifications are enabled' do
+      before { Dallal.configuration.enabled = true }
+      context 'when class is included in notifiables' do
+        before { expect(Dallal::Events::Observer::NOTIFIABLES.include?(payload[:class])).to be_truthy }
+
+        it { expect(subject.send(:should_create_notifications?)).to be_truthy }
+      end
+      context 'when subject is not a notifiable' do
+        before { payload[:class] = 'SomeNonNotifableClass' }
+        before { expect(Dallal::Events::Observer::NOTIFIABLES.include?(payload[:class])).to be_falsey }
+
+        it { expect(subject.send(:should_create_notifications?)).to be_falsey }
+      end
+    end
+    context 'when notifications are disabled' do
+      before { Dallal.configuration.enabled = false }
+      context 'when class is included in notifiables' do
+        before { expect(Dallal::Events::Observer::NOTIFIABLES.include?(payload[:class])).to be_truthy }
+
+        it { expect(subject.send(:should_create_notifications?)).to be_falsey }
+      end
+      context 'when subject ia not a notifiable' do
+        before { payload[:class] = 'SomeNonNotifableClass' }
+        before { expect(Dallal::Events::Observer::NOTIFIABLES.include?(payload[:class])).to be_falsey }
+        it { expect(subject.send(:should_create_notifications?)).to be_falsey }
+      end
+    end
+  end
+
+end

data/spec/dallal/events/observer_spec.rb

@@ -0,0 +1,117 @@
+require 'rails_helper'
+
+describe Dallal::Events::Observer do
+  subject { Dallal::Events::Observer }
+  it { expect(Dallal::Events::Observer.callbacks).to eq [] }
+  describe '.inherited' do
+    context "when a class inherites from observer" do
+      let(:klass) do
+        class DummyNotifier < Dallal::Events::Observer
+        end
+      end
+
+      it 'should validate that model exists and include the model name in NOTIFABLES' do
+        expect(Dallal::Events::Observer).to receive(:validate_model_exists!).with('Dummy').and_call_original
+        klass
+        expect(Dallal::Events::Observer::NOTIFIABLES).to include('Dummy')
+      end
+    end
+  end
+
+  describe '.on' do
+    it 'should append args, options and block to callbacks' do
+      expect(subject.callbacks.size).to eq 0
+      executed = false
+
+      subject.on :create, a: 1, b: 2 do
+        executed = true
+      end
+
+      expect(executed).to be false
+      expect(subject.callbacks.size).to eq 1
+      callback = subject.callbacks[0]
+      expect(callback[:on]).to eq([:create])
+      expect(callback[:opts]).to eq({a: 1, b: 2})
+      expect(callback[:block]).to be_a(Proc)
+    end
+  end
+
+  describe '.create_notification' do
+    subject { UserNotifier }
+    before do
+      @user = FactoryGirl.create(:user)
+    end
+
+    context 'when no callbacks are available' do
+      before do
+        subject.instance_variable_set(:@__notification_callbacks, [])
+        expect(subject.callbacks.size).to eq 0
+      end
+
+      it 'does not sipatch any notification' do
+        expect_any_instance_of(Dallal::Notification).to_not receive(:dispatch!)
+        subject.create_notification(id: 1, event: :create)
+      end
+    end
+
+    # TODO Refactor these specs
+    context 'when a callbacks is defined' do
+      context "create event" do
+        before { subject.instance_variable_set(:@__notification_callbacks, []) }
+        it 'dipatches a notification' do
+          @create_block_executed = false
+
+          subject.on :create, a: 1, b: 2 do
+            @create_block_executed = true
+          end
+
+          notification = double('Dallal::Notification')
+          expect(Dallal::Notification).to receive(:new).with(event: :create, model_class: 'User', opts: { a: 1, b: 2 }, _object: @user).and_return(notification)
+          expect(notification).to receive(:dispatch!)
+          subject.create_notification(id: @user.id, event: :create)
+
+          expect(notification.user).to eq @user
+          # TODO Fix this
+          #expect(@create_block_executed).to be true
+          #expect(@update_block_executed).to be true
+        end
+      end
+      context "update event" do
+        before { subject.instance_variable_set(:@__notification_callbacks, []) }
+        it 'dispatches an update event' do
+          @update_block_executed = false
+          subject.on :update, a: 1, b: 2 do
+            @update_block_executed = true
+          end
+
+          notification = double('Dallal::Notification')
+          expect(Dallal::Notification).to receive(:new).with(event: :update, model_class: 'User', opts: { a: 1, b: 2 }, _object: @user).and_return(notification)
+          expect(notification).to receive(:dispatch!)
+          subject.create_notification(id: @user.id, event: :update)
+
+          expect(notification.user).to eq @user 
+        end
+      end
+    end
+
+    context 'when called with an event that is not defined' do
+      before { subject.instance_variable_set(:@__notification_callbacks, []) }
+      it 'does not emit a notification' do
+        subject.on :create do
+
+        end
+        expect_any_instance_of(Dallal::Notification).to_not receive(:dispatch!)
+        subject.create_notification(id: @user.id, event: :non_existing)
+      end
+    end
+  end
+
+  describe '.models_class' do
+    subject { UserNotifier }
+    it { expect(subject.send(:model_class)).to eq 'User' }
+  end
+
+  describe '.validate_model_exists!' do
+    pending
+  end
+end

data/spec/dallal/events/publisher_spec.rb

@@ -0,0 +1,14 @@
+require 'rails_helper'
+
+describe Dallal::Events::Publisher do
+  subject { Dallal::Events::EventPublisher }
+
+  describe '.broadcast' do
+    it 'brodcasts an event to with ActiveSupport::Notification.instrument' do
+      payload = { a: 1, b: 2 }
+      expect(ActiveSupport::Notifications).to receive(:instrument).with(
+        subject.pub_sub_namespace, payload).and_call_original
+      subject.broadcast(payload)
+    end
+  end
+end

data/spec/dallal/events/subscriber_spec.rb

@@ -0,0 +1,4 @@
+require 'rails_helper'
+
+describe Dallal::Events::Subscriber do
+end