dalliance 0.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+
+.DS_Store
+*.log
+*.sqlite
+
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dalliance.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2012 Annkissam
+
+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.rdoc

@@ -0,0 +1,39 @@
+= dalliance
+
+Opinionated background processing for ActiveRecord w/ delayed_job & state_machine
+
+A simple wrapper for asynchronous processing w/ error handling & a progress_meter
+
+== Getting Started
+
+In your Gemfile:
+
+    gem "dalliance"
+
+In your model:
+
+    class Model < ActiveRecord::Base
+      dalliance :process_method
+    end
+    
+process_method is the name of the method to invoke for background processing
+to kick it off just call dalliance_background_process
+
+Handle your migrations:
+
+   rails g dalliance:progress_meter
+   
+   rails g dalliance:update model_name
+
+== ProgressMeter
+
+Create a method called dalliance_progress_meter_total_count
+(or provide the dalliance_progress_meter_total_count_method option)
+
+Inside process_method call progress_meter.increment! after each iteration
+
+In your views you can then call dalliance_progress to get feedback on your asynchronous process
+     
+== Copyright
+
+Copyright (c) 2012 Annkissam. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+#RSPEC
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/dalliance.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dalliance/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dalliance"
+  s.version     = Dalliance::VERSION::STRING
+  s.authors     = ["Eric Sullivan"]
+  s.email       = ["eric.sullivan@annkissam.com"]
+  s.homepage    = "https://github.com/annkissam/dalliance"
+  s.summary     = Dalliance::VERSION::SUMMARY
+  s.description = %q{ Opinionated background processing for ActiveRecord w/ delayed_job & state_machine }
+
+  s.rubyforge_project = "dalliance"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency('activerecord', '>= 3.0.0')
+  s.add_dependency('activesupport', '>= 3.0.0')
+  
+  s.add_dependency('delayed_job', '>= 2.0.0')
+  s.add_dependency('state_machine')
+  
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'delayed_job_active_record'
+  s.add_development_dependency 'sqlite3'
+end

data/lib/dalliance/progress_meter.rb

@@ -0,0 +1,43 @@
+require 'active_record'
+
+module Dalliance
+  class ProgressMeter < ::ActiveRecord::Base
+    self.table_name = 'dalliance_progress_meters'
+    
+    belongs_to :dalliance_progress_model, :polymorphic => true
+
+    validates_presence_of :dalliance_progress_model
+
+    #current_count should max out at total_count, but we'll allow you to miscount...
+    validates_numericality_of :current_count, :only_integer => true, :greater_than_or_equal_to => 0#, :less_than_or_equal_to => Proc.new(&:total_count)
+    validates_numericality_of :total_count,   :only_integer => true, :greater_than => 0
+    validates_numericality_of :progress,      :only_integer => true, :greater_than_or_equal_to => 0, :less_than_or_equal_to => 100
+
+    def current_count
+      self[:current_count] ||= 0
+    end
+    
+    def total_count
+      self[:total_count] ||= 1
+    end
+    
+    before_validation :calculate_progress
+
+    def calculate_progress
+      begin
+        self.progress = (current_count.to_f / total_count.to_f * 100).to_i
+        
+        #Handle an incorrect total_count...
+        self.progress = 100 if progress > 100
+      rescue
+        #what, are you diving by zero?
+        self.progress = 0
+      end
+    end
+
+    def increment!
+      self.current_count += 1
+      self.save!
+    end
+  end
+end

data/lib/dalliance/version.rb

@@ -0,0 +1,13 @@
+module Dalliance
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+
+    SUMMARY = "dalliance #{STRING}"
+  end
+end
+

data/lib/dalliance.rb

@@ -0,0 +1,139 @@
+require 'dalliance/version'
+
+require 'dalliance/progress_meter'
+
+module Dalliance
+  extend ActiveSupport::Concern
+  
+  class << self
+    def options
+      @options ||= {
+        :background_processing => true,
+        :dalliance_progress_meter_total_count_method => :dalliance_progress_meter_total_count
+      }
+    end
+    
+    def background_processing?
+      options[:background_processing]
+    end
+    
+    def configure
+      yield(self) if block_given?
+    end
+  end
+  
+  included do
+    has_one :dalliance_progress_meter, :as => :dalliance_progress_model, :class_name => '::Dalliance::ProgressMeter'
+    
+    serialize :dalliance_error_hash, Hash
+    
+    #BEGIN state_machine(s)
+    scope :dalliance_pending, where(:dalliance_status => 'pending')
+    scope :dalliance_processing, where(:dalliance_status => 'processing')
+    scope :dalliance_processing_error, where(:dalliance_status => 'processing_error')
+    scope :dalliance_completed, where(:dalliance_status => 'completed')
+
+    state_machine :dalliance_status, :initial => :pending do
+      state :pending
+      state :processing
+      state :processing_error
+      state :completed
+
+      event :queue_dalliance do
+        transition :processing_error => :pending
+      end
+
+      event :start_dalliance do
+        transition :pending => :processing
+      end
+
+      event :error_dalliance do
+        transition :processing => :processing_error
+      end
+
+      event :finish_dalliance do
+        transition :processing => :completed
+      end
+    end
+    #END state_machine(s)
+  end
+  
+  module ClassMethods
+    def dalliance_status_in_load_select_array
+      state_machine(:dalliance_status).states.map {|state| [state.human_name, state.name] }
+    end
+  end
+  
+  #Force backgound_processing w/ true
+  def dalliance_background_process(backgound_processing = nil)
+    if backgound_processing || (backgound_processing.nil? && Dalliance.background_processing?)
+      delay.dalliance_process(true)
+    else
+      dalliance_process(false)
+    end
+  end
+  
+  #backgound_processing == false will re-raise any exceptions
+  def dalliance_process(backgound_processing = false)
+    begin
+      start_dalliance!
+
+      build_dalliance_progress_meter(:total_count => calculate_dalliance_progress_meter_total_count).save!
+      
+      self.send(self.class.dalliance_options[:dalliance_method])
+
+      finish_dalliance!
+    rescue StandardError => e
+      #Save the error for future analysis...
+      self.dalliance_error_hash = {:error => e, :message => e.message, :backtrace => e.backtrace}
+
+      error_dalliance!
+      
+      #Don't raise the error if we're backgound_processing...
+      raise e unless backgound_processing
+    ensure
+      if dalliance_progress_meter
+        dalliance_progress_meter.destroy 
+      end
+    end
+  end
+  
+  def dalliance_progress
+    if completed?
+      100
+    else
+      if dalliance_progress_meter
+        dalliance_progress_meter.progress
+      else
+        0
+      end
+    end
+  end
+
+  #If the progress_meter_total_count_method is not implemented just use 1...
+  def calculate_dalliance_progress_meter_total_count
+    if respond_to?(self.class.dalliance_options[:dalliance_progress_meter_total_count_method])
+      self.send(self.class.dalliance_options[:dalliance_progress_meter_total_count_method])
+    else
+      1
+    end
+  end
+end
+
+#http://yehudakatz.com/2009/11/12/better-ruby-idioms/
+class ActiveRecord::Base
+  def self.dalliance(*args)
+    options = args.last.is_a?(Hash) ? Dalliance.options.merge(args.pop) : Dalliance.options
+    
+    case args.length
+    when 1
+      options[:dalliance_method] = args[0]
+    else 
+      raise ArgumentError, "Incorrect number of Arguements provided" 
+    end
+    
+    cattr_accessor :dalliance_options
+    self.dalliance_options = options
+    include Dalliance
+  end
+end

data/lib/generators/dalliance/progress_meter/progress_meter_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+module Dalliance
+  class ProgressMeterGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Create a migration to add dalliance_progress_meters"
+
+    def self.source_root
+      @source_root ||= File.expand_path('../templates', __FILE__)
+    end
+
+    def self.next_migration_number(path)
+      ActiveRecord::Generators::Base.next_migration_number(path)
+    end
+
+    def generate_migration
+      migration_template 'migration.rb', 'db/migrate/create_dalliance_progress_meters'
+    end
+  end
+end

data/lib/generators/dalliance/progress_meter/templates/migration.rb

@@ -0,0 +1,21 @@
+class CreateDallianceProgressMeters < ActiveRecord::Migration
+  def self.up
+    create_table :dalliance_progress_meters do |t|
+      t.belongs_to :dalliance_progress_model, :polymorphic => true
+
+      t.integer :current_count
+      t.integer :total_count
+      t.integer :progress
+
+      t.timestamps
+    end
+
+    add_index     :dalliance_progress_meters, [:dalliance_progress_model_id, :dalliance_progress_model_type], :name => 'by_dalliance_progress_model'
+  end
+
+  def self.down
+    remove_index  :dalliance_progress_meters, :name => 'by_dalliance_progress_model'
+
+    drop_table    :dalliance_progress_meters
+  end
+end

data/lib/generators/dalliance/update/templates/migration.rb.erb

@@ -0,0 +1,11 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+    add_column :<%= name.underscore.camelize.tableize %>, :dalliance_error_hash, :text
+    add_column :<%= name.underscore.camelize.tableize %>, :dalliance_status, :string, :null => false, :default => 'pending'
+  end
+
+  def self.down
+    remove_column :<%= name.underscore.camelize.tableize %>, :dalliance_error_hash
+    remove_column :<%= name.underscore.camelize.tableize %>, :dalliance_status
+  end
+end

data/lib/generators/dalliance/update/update_generator.rb

@@ -0,0 +1,33 @@
+#Adapted from paperclip...
+#https://github.com/thoughtbot/paperclip
+
+require 'rails/generators/active_record'
+
+module Dalliance
+  class UpdateGenerator < ActiveRecord::Generators::Base
+    desc "Create a migration to add dalliance-specific fields to your model. " +
+         "The NAME argument is the name of your model"
+
+    def self.source_root
+      @source_root ||= File.expand_path('../templates', __FILE__)
+    end
+
+    def generate_migration
+      migration_template "migration.rb.erb", "db/migrate/#{migration_file_name}"
+    end
+
+    protected
+
+    def migration_name
+      "add_dalliance_to_#{name.underscore}"
+    end
+
+    def migration_file_name
+      "#{migration_name}.rb"
+    end
+
+    def migration_class_name
+      migration_name.camelize
+    end
+  end
+end

data/spec/dalliance/asynchronous_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe DallianceModel do
+  subject { DallianceModel.create }
+  
+  before(:all) do
+    Dalliance.options[:background_processing] = true
+  end
+  
+  context "success" do
+    before(:all) do
+      DallianceModel.dalliance_options[:dalliance_method] = :dalliance_success_method
+    end
+
+    it "should not call the dalliance_method w/o a Delayed::Worker" do
+      subject.dalliance_background_process
+      subject.reload
+      
+      subject.should_not be_successful
+      Delayed::Job.count.should == 1
+    end
+  
+    it "should call the dalliance_method w/ a Delayed::Worker" do
+      subject.dalliance_background_process
+      Delayed::Worker.new.work_off
+      subject.reload
+      
+      subject.should be_successful
+      Delayed::Job.count.should == 0
+    end
+    
+    it "should set the dalliance_status to completed" do
+      subject.dalliance_background_process
+      Delayed::Worker.new.work_off
+      subject.reload
+      
+      subject.should be_completed
+    end
+    
+    it "should set the dalliance_progress to 100" do
+      subject.dalliance_background_process
+      Delayed::Worker.new.work_off
+      subject.reload
+      
+      subject.dalliance_progress.should == 100
+    end
+  end
+  
+  context "raise error" do
+    before(:all) do
+      DallianceModel.dalliance_options[:dalliance_method] = :dalliance_error_method
+    end
+      
+    it "should NOT raise an error" do
+      subject.dalliance_background_process
+    
+      Delayed::Worker.new.work_off
+      
+      Delayed::Job.count.should == 0
+    end
+    
+    it "should store the error" do
+      subject.dalliance_background_process
+      Delayed::Worker.new.work_off
+      subject.reload
+      
+      subject.dalliance_error_hash.should_not be_empty
+      subject.dalliance_error_hash[:error].should == RuntimeError.new
+      subject.dalliance_error_hash[:message].should == 'RuntimeError'
+      subject.dalliance_error_hash[:backtrace].should_not be_blank
+    end
+    
+    it "should set the dalliance_status to processing_error" do
+      subject.dalliance_background_process
+      Delayed::Worker.new.work_off
+      subject.reload
+      
+      subject.should be_processing_error
+    end
+    
+    it "should set the dalliance_progress to 0" do
+      subject.dalliance_background_process
+      Delayed::Worker.new.work_off
+      subject.reload
+      
+      subject.dalliance_progress.should == 0
+    end
+  end
+end

data/spec/dalliance/dalliance_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe 'Dalliance' do
+end

data/spec/dalliance/synchronous_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe DallianceModel do
+  subject { DallianceModel.create }
+  
+  before(:all) do
+    Dalliance.options[:background_processing] = false
+  end
+  
+  context "success" do
+    before(:all) do
+      DallianceModel.dalliance_options[:dalliance_method] = :dalliance_success_method
+    end
+    
+    it "should call the dalliance_method" do
+      lambda { subject.dalliance_background_process }.should change(subject, :successful).from(false).to(true)
+    end
+    
+    it "should set the dalliance_status to completed" do
+      lambda { subject.dalliance_background_process }.should change(subject, :dalliance_status).from('pending').to('completed')
+    end
+    
+    it "should set the dalliance_progress to 100" do
+      lambda { subject.dalliance_background_process }.should change(subject, :dalliance_progress).from(0).to(100)
+    end
+  end
+  
+  context "raise error" do
+    before(:all) do
+      DallianceModel.dalliance_options[:dalliance_method] = :dalliance_error_method
+    end
+    
+    it "should raise an error" do
+      expect { subject.dalliance_background_process }.to raise_error(RuntimeError)
+    end
+    
+    it "should store the error" do
+      expect { subject.dalliance_background_process }.to raise_error(RuntimeError)
+      
+      subject.dalliance_error_hash.should_not be_empty
+      subject.dalliance_error_hash[:error].should == RuntimeError.new
+      subject.dalliance_error_hash[:message].should == 'RuntimeError'
+      subject.dalliance_error_hash[:backtrace].should_not be_blank
+    end
+    
+    it "should set the dalliance_status to processing_error" do
+      expect { subject.dalliance_background_process }.to raise_error(RuntimeError)
+      
+      subject.should be_processing_error
+    end
+    
+    it "should set the dalliance_progress to 0" do
+      expect { subject.dalliance_background_process }.to raise_error(RuntimeError)
+      
+      subject.dalliance_progress.should == 0
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'bundler/setup'
+
+#Automatically included in a rails app...
+require 'active_support'
+require 'state_machine'
+require 'delayed_job'
+
+#Required for testing...
+require 'delayed_job_active_record'
+
+require 'dalliance'
+
+RSpec.configure do |config|
+  #http://blog.rubyhead.com/2010/04/27/database-during-tests/
+  config.before do
+    ActiveRecord::Base.connection.begin_db_transaction
+    ActiveRecord::Base.connection.increment_open_transactions
+  end
+  
+  config.after do
+    if ActiveRecord::Base.connection.open_transactions != 0
+      ActiveRecord::Base.connection.rollback_db_transaction
+      ActiveRecord::Base.connection.decrement_open_transactions
+    end 
+  end
+end
+
+#We don't need a full rails app to test...
+require 'support/active_record'

data/spec/support/active_record.rb

@@ -0,0 +1,54 @@
+#Adapted from delayed_job_active_record
+#https://github.com/collectiveidea/delayed_job_active_record
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :dalliance_progress_meters, :force => true do |t|
+    t.belongs_to :dalliance_progress_model, :polymorphic => true
+
+    t.integer :current_count
+    t.integer :total_count
+    t.integer :progress
+
+    t.timestamps
+  end
+
+  add_index     :dalliance_progress_meters, [:dalliance_progress_model_id, :dalliance_progress_model_type], :name => 'by_dalliance_progress_model'
+  
+  create_table :delayed_jobs, :force => true do |table|
+    table.integer  :priority, :default => 0
+    table.integer  :attempts, :default => 0
+    table.text     :handler
+    table.text     :last_error
+    table.datetime :run_at
+    table.datetime :locked_at
+    table.datetime :failed_at
+    table.string   :locked_by
+    table.string   :queue
+    table.timestamps
+  end
+  
+  add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+
+  create_table :dalliance_models, :force => true do |t|
+    t.text :dalliance_error_hash
+    t.string :dalliance_status, :string, :null => false, :default => 'pending'
+    
+    t.boolean :successful, :default => false
+  end
+end
+
+# Purely useful for test cases...
+class DallianceModel < ActiveRecord::Base
+  dalliance :dalliance_success_method
+
+  def dalliance_success_method
+    update_attribute(:successful, true)
+  end
+  
+  def dalliance_error_method
+    raise RuntimeError
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: dalliance
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Eric Sullivan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70098455466720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70098455466720
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70098455466100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70098455466100
+- !ruby/object:Gem::Dependency
+  name: delayed_job
+  requirement: &70098455465500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70098455465500
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: &70098455465020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70098455465020
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70098455464440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70098455464440
+- !ruby/object:Gem::Dependency
+  name: delayed_job_active_record
+  requirement: &70098455463520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70098455463520
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70098455462940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70098455462940
+description: ! ' Opinionated background processing for ActiveRecord w/ delayed_job
+  & state_machine '
+email:
+- eric.sullivan@annkissam.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- dalliance.gemspec
+- lib/dalliance.rb
+- lib/dalliance/progress_meter.rb
+- lib/dalliance/version.rb
+- lib/generators/dalliance/progress_meter/progress_meter_generator.rb
+- lib/generators/dalliance/progress_meter/templates/migration.rb
+- lib/generators/dalliance/update/templates/migration.rb.erb
+- lib/generators/dalliance/update/update_generator.rb
+- spec/dalliance/asynchronous_spec.rb
+- spec/dalliance/dalliance_spec.rb
+- spec/dalliance/synchronous_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+homepage: https://github.com/annkissam/dalliance
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: dalliance
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: dalliance 0.0.1
+test_files:
+- spec/dalliance/asynchronous_spec.rb
+- spec/dalliance/dalliance_spec.rb
+- spec/dalliance/synchronous_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb