active_record-events 1.1.0 → 4.0.0

data/lib/active_record/events/naming.rb

@@ -5,34 +5,64 @@ module ActiveRecord
     class Naming
       def initialize(infinitive, options = {})
         @infinitive = infinitive
-        @subject = options[:subject].presence
+        @object = options[:object].presence
+        @field_name = options[:field_name].to_s
+        @field_type = options[:field_type].try(:to_sym)
       end
 
       def field
-        [@subject, past_participle, 'at'].compact.join('_')
+        return field_name if field_name.present?
+
+        suffix = field_type == :date ? 'on' : 'at'
+
+        concatenate(object, past_participle, suffix)
       end
 
       def predicate
-        [@subject, past_participle].compact.join('_')
+        concatenate(object, past_participle) + '?'
+      end
+
+      def inverse_predicate
+        concatenate(object, 'not', past_participle) + '?'
       end
 
       def action
-        [@infinitive, @subject].compact.join('_')
+        concatenate(infinitive, object) + '!'
+      end
+
+      def safe_action
+        concatenate(infinitive, object)
+      end
+
+      def collective_action
+        concatenate(infinitive, 'all', plural_object)
       end
 
       def scope
-        [@subject, past_participle].compact.join('_')
+        concatenate(object, past_participle)
       end
 
       def inverse_scope
-        [@subject, 'not', past_participle].compact.join('_')
+        concatenate(object, 'not', past_participle)
       end
 
       private
 
+      attr_reader :infinitive
+      attr_reader :object
+      attr_reader :field_name
+      attr_reader :field_type
+
+      def concatenate(*parts)
+        parts.compact.join('_')
+      end
+
       def past_participle
-        options = { tense: :past, aspect: :perfective }
-        @infinitive.verb.conjugate(options)
+        infinitive.verb.conjugate(tense: :past, aspect: :perfective)
+      end
+
+      def plural_object
+        object.to_s.pluralize if object.present?
       end
     end
   end

data/lib/active_record/events/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Events
-    VERSION = '1.1.0'
+    VERSION = '4.0.0'.freeze
   end
 end

data/lib/generators/active_record/event/USAGE

@@ -0,0 +1,15 @@
+Description:
+    Generates a database migration and updates the model file (if it exists).
+    Pass the model name, either CamelCased or under_scored, and the event name
+    as an infinitive.
+
+Examples:
+    `bin/rails generate active_record:event task complete`
+
+        Generates a migration adding a `completed_at` column to the `tasks`
+        table and updates the Task model.
+
+    `bin/rails generate active_record:event user confirm --object=email`
+
+        Generates a migration adding an `email_confirmed_at` column to the
+        `users` table and updates the User model.

data/lib/generators/active_record/event/event_generator.rb

@@ -0,0 +1,60 @@
+require 'rails/generators'
+
+require 'active_record/events/naming'
+require 'active_record/events/macro'
+
+module ActiveRecord
+  module Generators
+    class EventGenerator < Rails::Generators::Base
+      MACRO_OPTIONS = %w[object field_type skip_scopes].freeze
+
+      argument :model_name, type: :string
+      argument :event_name, type: :string
+
+      class_option :skip_scopes, type: :boolean,
+        desc: 'Skip the inclusion of scope methods'
+      class_option :field_type, type: :string,
+        desc: 'The field type (datetime or date)'
+      class_option :object, type: :string,
+        desc: 'The name of the object'
+
+      source_root File.expand_path('templates', __dir__)
+
+      def generate_migration_file
+        naming = ActiveRecord::Events::Naming.new(event_name, options)
+
+        table_name = model_name.tableize
+        field_name = naming.field
+        field_type = options[:field_type] || 'datetime'
+
+        migration_name = "add_#{field_name}_to_#{table_name}"
+        attributes = "#{field_name}:#{field_type}"
+
+        invoke 'active_record:migration', [migration_name, attributes]
+      end
+
+      def update_model_file
+        return unless model_file_exists?
+
+        macro_options = options.slice(*MACRO_OPTIONS)
+        macro = ActiveRecord::Events::Macro.new(event_name, macro_options)
+
+        inject_into_file model_file_path, "\s\s#{macro}\n", after: /class.+\n/
+      end
+
+      private
+
+      def model_file_exists?
+        File.exist?(model_file_path)
+      end
+
+      def model_file_path
+        File.expand_path("app/models/#{model_file_name}", destination_root)
+      end
+
+      def model_file_name
+        "#{model_name.underscore.singularize}.rb"
+      end
+    end
+  end
+end

data/spec/active_record/events/macro_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'active_record/events/macro'
+
+RSpec.describe ActiveRecord::Events::Macro do
+  let(:event_name) { :confirm }
+
+  subject { described_class.new(event_name, options) }
+
+  context 'without options' do
+    let(:options) { {} }
+
+    it "doesn't include any options" do
+      expect(subject.to_s).to eq('has_event :confirm')
+    end
+  end
+
+  context 'with a string option' do
+    let(:options) { { object: 'email' } }
+
+    it 'prepends the option value with a colon' do
+      expect(subject.to_s).to eq('has_event :confirm, object: :email')
+    end
+  end
+
+  context 'with a symbol option' do
+    let(:options) { { object: :email } }
+
+    it 'prepends the option value with a colon' do
+      expect(subject.to_s).to eq('has_event :confirm, object: :email')
+    end
+  end
+
+  context 'with a boolean option' do
+    let(:options) { { skip_scopes: true } }
+
+    it "doesn't prepend the option value with a colon" do
+      expect(subject.to_s).to eq('has_event :confirm, skip_scopes: true')
+    end
+  end
+
+  context 'with multiple options' do
+    let(:options) { { object: :email, field_type: :date } }
+
+    it 'includes all of the options' do
+      macro = 'has_event :confirm, object: :email, field_type: :date'
+      expect(subject.to_s).to eq(macro)
+    end
+  end
+end

data/spec/active_record/events/method_factory_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe ActiveRecord::Events::MethodFactory do
+  let(:event_name) { :complete }
+  let(:options) { {} }
+
+  subject { described_class.new(event_name, options) }
+
+  it 'generates instance methods' do
+    result = subject.instance_methods
+
+    expect(result).to have_method(:completed?)
+    expect(result).to have_method(:not_completed?)
+    expect(result).to have_method(:complete!)
+    expect(result).to have_method(:complete)
+  end
+
+  it 'generates class methods' do
+    result = subject.class_methods
+
+    expect(result).to have_method(:complete_all)
+    expect(result).to have_method(:completed)
+    expect(result).to have_method(:not_completed)
+  end
+
+  context 'with the object option' do
+    let(:options) { { object: :task } }
+
+    it 'generates instance methods' do
+      result = subject.instance_methods
+
+      expect(result).to have_method(:task_completed?)
+      expect(result).to have_method(:task_not_completed?)
+      expect(result).to have_method(:complete_task!)
+      expect(result).to have_method(:complete_task)
+    end
+
+    it 'generates class methods' do
+      result = subject.class_methods
+
+      expect(result).to have_method(:complete_all_tasks)
+      expect(result).to have_method(:task_completed)
+      expect(result).to have_method(:task_not_completed)
+    end
+  end
+
+  context 'with the skip scopes option' do
+    let(:options) { { skip_scopes: true } }
+
+    it 'generates class methods without scopes' do
+      result = subject.class_methods
+
+      expect(result).to have_method(:complete_all)
+
+      expect(result).not_to have_method(:completed)
+      expect(result).not_to have_method(:not_completed)
+    end
+  end
+end

data/spec/active_record/events/naming_spec.rb

@@ -1,51 +1,92 @@
 require 'spec_helper'
 
 RSpec.describe ActiveRecord::Events::Naming do
-  context 'without a subject' do
-    subject { described_class.new(:complete) }
+  let(:event_name) { :complete }
+  let(:options) { {} }
+
+  subject { described_class.new(event_name, options) }
+
+  it 'generates a field name' do
+    expect(subject.field).to eq('completed_at')
+  end
+
+  it 'generates a predicate name' do
+    expect(subject.predicate).to eq('completed?')
+  end
+
+  it 'generates an inverse predicate name' do
+    expect(subject.inverse_predicate).to eq('not_completed?')
+  end
+
+  it 'generates an action name' do
+    expect(subject.action).to eq('complete!')
+  end
+
+  it 'generates a safe action name' do
+    expect(subject.safe_action).to eq('complete')
+  end
+
+  it 'generates a collective action name' do
+    expect(subject.collective_action).to eq('complete_all')
+  end
+
+  it 'generates a scope name' do
+    expect(subject.scope).to eq('completed')
+  end
+
+  it 'generates an inverse scope name' do
+    expect(subject.inverse_scope).to eq('not_completed')
+  end
+
+  context 'with an object' do
+    let(:options) { { object: :task } }
 
     it 'generates a field name' do
-      expect(subject.field).to eq('completed_at')
+      expect(subject.field).to eq('task_completed_at')
     end
 
     it 'generates a predicate name' do
-      expect(subject.predicate).to eq('completed')
+      expect(subject.predicate).to eq('task_completed?')
+    end
+
+    it 'generates an inverse predicate name' do
+      expect(subject.inverse_predicate).to eq('task_not_completed?')
     end
 
     it 'generates an action name' do
-      expect(subject.action).to eq('complete')
+      expect(subject.action).to eq('complete_task!')
+    end
+
+    it 'generates a safe action name' do
+      expect(subject.safe_action).to eq('complete_task')
+    end
+
+    it 'generates a collective action name' do
+      expect(subject.collective_action).to eq('complete_all_tasks')
     end
 
     it 'generates a scope name' do
-      expect(subject.scope).to eq('completed')
+      expect(subject.scope).to eq('task_completed')
     end
 
     it 'generates an inverse scope name' do
-      expect(subject.inverse_scope).to eq('not_completed')
+      expect(subject.inverse_scope).to eq('task_not_completed')
     end
   end
 
-  context 'with a subject' do
-    subject { described_class.new(:confirm, subject: :email) }
+  context 'with a date field' do
+    let(:options) { { field_type: :date } }
 
     it 'generates a field name' do
-      expect(subject.field).to eq('email_confirmed_at')
-    end
-
-    it 'generates a predicate name' do
-      expect(subject.predicate).to eq('email_confirmed')
-    end
-
-    it 'generates an action name' do
-      expect(subject.action).to eq('confirm_email')
+      expect(subject.field).to eq('completed_on')
     end
+  end
 
-    it 'generates a scope name' do
-      expect(subject.scope).to eq('email_confirmed')
-    end
+  context 'with a custom field name' do
+    let(:options) { { field_name: :completion_time } }
 
-    it 'generates an inverse scope name' do
-      expect(subject.inverse_scope).to eq('email_not_confirmed')
+    it 'returns the field name' do
+      expect(subject.field).to eq('completion_time')
     end
   end
 end

data/spec/active_record/events_spec.rb

@@ -1,17 +1,24 @@
 require 'spec_helper'
 
 RSpec.describe ActiveRecord::Events do
-  let(:task) { create(:task) }
+  around(:each) do |example|
+    Timecop.freeze { example.run }
+  end
+
+  let!(:task) { create(:task) }
 
   it 'records a timestamp' do
     task.complete
 
-    expect(task).to be_completed
-    expect(task.completed_at).to eq(Time.now)
+    expect(task.completed?).to eq(true)
+    expect(task.not_completed?).to eq(false)
+
+    expect(task.completed_at).to eq(Time.current)
   end
 
   it 'preserves a timestamp' do
     task = create(:task, completed_at: 3.days.ago)
+
     task.complete
 
     expect(task.completed_at).to eq(3.days.ago)
@@ -19,20 +26,39 @@ RSpec.describe ActiveRecord::Events do
 
   it 'updates a timestamp' do
     task = create(:task, completed_at: 3.days.ago)
+
     task.complete!
 
-    expect(task.completed_at).to eq(Time.now)
+    expect(task.completed_at).to eq(Time.current)
   end
 
-  it 'defines scope methods' do
-    expect(Task.not_completed).to include(task)
+  it 'records multiple timestamps at once' do
+    Task.complete_all
+
+    expect(task.reload).to be_completed
+  end
+
+  it 'defines a scope' do
     expect(Task.completed).not_to include(task)
   end
 
-  let(:user) { create(:user) }
+  it 'defines an inverse scope' do
+    expect(Task.not_completed).to include(task)
+  end
+
+  it 'allows overriding instance methods' do
+    expect(ActiveRecord::Base.logger).to receive(:info)
+
+    task.complete!
+
+    expect(task).to be_completed
+  end
+
+  it 'allows overriding class methods' do
+    expect(ActiveRecord::Base.logger).to receive(:info)
+
+    Task.complete_all
 
-  it 'handles a subject' do
-    user.confirm_email
-    expect(user.email_confirmed?).to be(true)
+    expect(task.reload).to be_completed
   end
 end