guise 0.2.3 → 0.3.0

data/lib/guise/syntax.rb

@@ -0,0 +1,104 @@
+require 'active_support/concern'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+
+module Guise
+  module Syntax
+    def has_guises(*guises)
+      include Introspection
+
+      options = guises.last.is_a?(Hash) ? guises.pop : {}
+
+      guises      = guises.map(&:to_s)
+      association = options.fetch(:association)
+      attribute   = options.fetch(:attribute)
+
+      Guise.registry[self.name] = {
+        names: guises,
+        association: association,
+        attribute: attribute
+      }
+
+      guises.each do |guise|
+        method_name = guise.underscore
+        scope method_name.pluralize, -> { joins(association).where(association => { attribute => guise }) }
+
+        define_method "#{method_name}?" do
+          has_guise?(guise)
+        end
+      end
+
+      has_many association, options.except(:association, :attribute)
+
+      if association != :guises
+        association_singular = association.to_s.singularize
+
+        alias_method :guises, association
+        alias_method "has_#{association_singular}?", :has_guise?
+        alias_method "has_#{association}?", :has_guises?
+        alias_method "has_any_#{association}?", :has_any_guises?
+      end
+    end
+
+    def guise_of(class_name)
+      options = Guise.registry[class_name]
+
+      if options.nil?
+        raise ArgumentError, "no guises defined on #{class_name}"
+      end
+
+      default_scope -> { send(model_name.plural) }
+
+      callback = SourceCallback.new(self.name, options[:attribute])
+
+      after_initialize callback
+      after_create callback
+    end
+
+    def guise_for(class_name, options = {})
+      guise_options = Guise.registry[class_name]
+
+      if guise_options.nil?
+        raise ArgumentError, "no guises defined on #{class_name}"
+      end
+
+      association = class_name.to_s.underscore.to_sym
+      guises      = guise_options[:names]
+      attribute   = guise_options[:attribute]
+      foreign_key = options[:foreign_key] || "#{class_name.underscore}_id"
+
+      belongs_to association, options.except(:validate)
+
+      guises.each do |guise|
+        scope guise.underscore.pluralize, -> { where(attribute => guise) }
+      end
+
+      if options[:validate] != false
+        validates attribute, uniqueness: { scope: foreign_key }, presence: true, inclusion: { in: guises }
+      end
+    end
+
+    def scoped_guise_for(class_name)
+      guise_options = Guise.registry[class_name]
+
+      if guise_options.nil?
+        raise ArgumentError, "no guises defined on #{class_name}"
+      end
+
+      attribute = guise_options[:attribute]
+      parent_name = table_name.classify
+
+      value = guise_options[:names].detect do |guise|
+        guise == model_name.to_s.chomp(parent_name)
+      end
+
+      default_scope -> { where(attribute => value) }
+
+      callback = AssociationCallback.new(value, attribute)
+
+      after_initialize callback
+      before_create callback
+    end
+  end
+end

data/lib/guise/version.rb

@@ -1,3 +1,3 @@
 module Guise
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/lib/guise.rb

@@ -1,79 +1,15 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
 require 'guise/version'
-require 'guise/options'
+require 'guise/callbacks'
+require 'guise/syntax'
 require 'guise/introspection'
 
 module Guise
-
-  def has_guises(*names)
-    extend Options
-
-    options = names.last.is_a?(Hash) ? names.pop : {}
-    class_names = names.map(&:to_s).map(&:classify)
-
-    guise_options, association_options = extract_guise_options(class_names, options)
-
-    build_guises(class_names, guise_options)
-    introspect_guises(class_names)
-
-    has_many guise_association, association_options
-
-    if guise_association != :guises
-      alias_method :guises, guise_association
-    end
-  end
-
-  def guise_for(name, options = {})
-    association = Object.const_get(name.to_s.classify)
-    foreign_key = options[:foreign_key] || "#{association.name.underscore}_id"
-
-    belongs_to name, options
-
-    if options[:validate] != false
-      validates association.guise_attribute,
-                :uniqueness => { :scope => foreign_key },
-                :presence => true,
-                :inclusion => { :in => association.guises }
-    end
-  end
-
-  private
-
-  def build_guises(names, options)
-    names.each do |name|
-      scope_name = name.tableize.to_sym
-
-      # Add a scope for this type of resource
-      scope scope_name, joins(guise_association).where(guise_association => { guise_attribute => name })
-
-      # build the class setting it's default scope to limit to those of itself
-      guise_class = Class.new(self) do
-        default_scope { send(scope_name) }
-
-        after_initialize do
-          self.guises.new(self.guise_attribute => name) unless self.has_role?(name)
-        end
-
-        after_create do
-          self.guises.create(self.guise_attribute => name)
-        end
-      end
-
-      Object.const_set(name, guise_class)
-    end
-  end
-
-  def introspect_guises(names)
-    include Introspection
-
-    names.each do |name|
-      method_name = "#{name.underscore}?"
-      define_method method_name do
-        has_role?(name)
-      end
-    end
-  end
+  mattr_reader :registry
+  @@registry = HashWithIndifferentAccess.new
 end
 
 if defined?(ActiveRecord)
-  ActiveRecord::Base.extend Guise
+  ActiveRecord::Base.extend(Guise::Syntax)
 end

data/spec/factories.rb

@@ -5,20 +5,27 @@ FactoryGirl.define do
     email 'mrhalp@mit.edu'
 
     factory :technician do
-      after_create do |user|
-        FactoryGirl.create(:user_role, :name => 'Technician', :user => user)
+      after(:create) do |user, proxy|
+        create(:user_role, name: 'Technician', user: user)
       end
     end
 
     factory :supervisor do
-      after_create do |user|
-        FactoryGirl.create(:user_role, :name => 'Supervisor', :user => user)
+      after(:create) do |user, proxy|
+        create(:user_role, name: 'Supervisor', user: user)
       end
     end
   end
 
   factory :user_role do
-    association :user
+    user
     name 'Technician'
+
+    factory :technician_role do
+    end
+
+    factory :supervisor_role do
+      name 'Supervisor'
+    end
   end
 end

data/spec/guise_spec.rb

@@ -1,78 +1,126 @@
 require 'spec_helper'
 
 describe Guise do
+  let!(:user) { create(:user) }
+  let!(:supervisor) { create(:supervisor) }
+  let!(:technician) { create(:technician) }
 
-  let(:user) { create(:user) }
-  let(:supervisor) { create(:supervisor) }
-  let(:technician) { create(:technician) }
+  after do
+    User.delete_all
+    UserRole.delete_all
+  end
 
   describe ".has_guises" do
-    subject { user }
-
     it "sets up has_many association" do
-      should have_many :user_roles
+      expect(user).to have_many :user_roles
     end
 
-    it "builds subclasses of names called in :guise" do
-      Technician.new.should be_a User
-      Technician.new.guises.should_not be_empty
+    it "adds scopes for each type" do
+      technicians = User.technicians
+
+      expect(technicians).to include technician
+      expect(technicians).not_to include user
+      expect(technicians).not_to include supervisor
     end
+  end
 
-    it "adds scopes for each type" do
-      User.technicians.should include(technician)
-      User.technicians.should_not include(user)
+  describe "#has_guise?" do
+    it "checks if record is of the specified type" do
+      expect(user).not_to have_guise :technician
 
-      User.supervisors.should include(supervisor)
-      User.supervisors.should_not include(user)
+      expect(technician).to have_guise :technician
+      expect(technician).to have_guise :Technician
+      expect(technician).to have_guise 'Technician'
+      expect(technician).to have_guise 'technician'
+      expect(technician).to have_guise Technician
     end
 
-    describe "#has_role?" do
-      it "checks if resource is of the type provided" do
-        user.has_role?(:technician).should be_false
-        technician.has_role?(:Technician).should be_true
-      end
+    it "raises an error if type was not specified" do
+      expect { user.has_guise?(:Accountant) }.to raise_error ArgumentError
+    end
 
-      it "raises an error if type was not added in :guises call" do
-        expect { user.has_role?(:Accountant) }.to raise_error(NameError)
-      end
+    it 'is aliased based on the name of the association' do
+      expect(user).not_to have_user_role :technician
+      expect(technician).to have_user_role :technician
     end
 
-    describe "#has_roles?" do
-      before :each do
-        create(:user_role, :name => 'Technician', :user => supervisor)
-      end
+    it 'is wrapped for each guise specified' do
+      expect(user).not_to be_technician
+      expect(technician).to be_technician
+    end
+  end
 
-      it "checks if resource is all of the provided types" do
-        technician.has_roles?(:Supervisor, :Technician).should be_false
-        supervisor.has_roles?('Supervisor', Technician).should be_true
-      end
+  describe "#has_guises?" do
+    before do
+      @role = create(:user_role, name: 'Technician', user: supervisor)
     end
 
-    describe "#has_any_roles?" do
-      it "checks if resource is any of the supplied roles" do
-        user.has_any_roles?(:Supervisor, :Technician).should be_false
-        technician.has_any_roles?('supervisor', 'technician').should be_true
-      end
+    after do
+      @role.destroy
+    end
+
+    it "checks if resource is all of the provided types" do
+      expect(technician).not_to have_guises :Supervisor, :Technician
+      expect(supervisor).to have_guises :Supervisor, :Technician
     end
 
-    it "adds methods that proxy to #has_role? for ease" do
-      user.should respond_to :technician?
-      user.should respond_to :supervisor?
+    it 'is aliased based on the association name' do
+      expect(technician).not_to have_user_roles :Supervisor, :Technician
+      expect(supervisor).to have_user_roles :Supervisor, :Technician
+    end
+  end
 
-      user.technician?.should be_false
-      technician.technician?.should be_true
+  describe "#has_any_roles?" do
+    it "checks if resource is any of the supplied roles" do
+      expect(user).not_to have_any_guises :Supervisor, :Technician
+      expect(technician).to have_any_guises 'supervisor', 'technician'
+    end
+
+    it 'is aliased based on the association name' do
+      expect(user).not_to have_any_user_roles :Supervisor, :Technician
+      expect(technician).to have_any_user_roles 'supervisor', 'Technician'
+    end
+  end
+
+  describe '.guise_of' do
+    it "sets default scope to limit to records of the class's type" do
+      technician_ids = Technician.pluck(:id)
+
+      expect(technician_ids).to eq [technician.id]
+    end
+
+    it 'sets up lifecycle callbacks to ensure records are initialized and created with the correct associated records' do
+      new_record = Technician.new
+      expect(new_record).to have_guise :technician
+
+      created_record = Technician.create!
+      expect(created_record).to have_guise :technician
     end
   end
 
   describe ".guise_for" do
-    subject { create(:user_role) }
+    subject { UserRole.new }
 
     it "sets up belongs_to" do
       should belong_to(:user)
     end
 
-    describe "adds validations to ensure guise attribute is" do
+    it 'defines scopes for each guise' do
+      technician_role = create(:technician_role)
+      supervisor_role = create(:supervisor_role)
+
+      technician_roles = UserRole.technicians
+
+      expect(technician_roles).to include technician_role
+      expect(technician_roles).not_to include supervisor_role
+
+      supervisor_roles = UserRole.supervisors
 
+      expect(supervisor_roles).to include supervisor_role
+      expect(supervisor_roles).not_to include technician_role
+    end
+
+    describe "adds validations to ensure guise attribute is" do
       it "present" do
         should validate_presence_of(:name)
       end
@@ -82,8 +130,24 @@ describe Guise do
       end
 
       it "is one of the guise names provided" do
-        expect { create(:user_role, :name => 'Farmer') }.to raise_error ActiveRecord::RecordInvalid
+        expect { create(:user_role, name: 'Farmer') }.to raise_error ActiveRecord::RecordInvalid
       end
     end
   end
+
+  describe '.scoped_guise_of' do
+    it 'sets default scope' do
+      names = TechnicianUserRole.pluck(:name).uniq
+
+      expect(names).to eq ['Technician']
+    end
+
+    it 'sets up lifecycle callbacks to ensure the object is in the correct state' do
+      new_technician_role = TechnicianUserRole.new
+      created_technician_role = TechnicianUserRole.create!
+
+      expect(new_technician_role.name).to eq 'Technician'
+      expect(created_technician_role.name).to eq 'Technician'
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,17 +1,54 @@
+require 'pry'
 require 'active_record'
 require 'factory_girl'
 require 'shoulda-matchers'
 require 'guise'
 
-require File.expand_path('../support/database.rb', __FILE__)
+I18n.enforce_available_locales = false
 
-RSpec.configure do |config|
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+ActiveRecord::Migration.verbose = false
 
-  config.before :suite do
-    Database.create
-    FactoryGirl.find_definitions
+ActiveRecord::Schema.define do
+  create_table :users, force: true do |t|
+    t.string :name
+    t.string :email
   end
 
-  config.include FactoryGirl::Syntax::Methods
+  create_table :user_roles, force: true do |t|
+    t.string :name
+    t.integer :person_id
+  end
+end
+
+class User < ActiveRecord::Base
+  has_guises :Technician, :Supervisor, association: :user_roles, attribute: :name, foreign_key: :person_id
+end
+
+class Technician < User
+  guise_of :User
+end
+
+class Supervisor < User
+  guise_of :User
+end
+
+class UserRole < ActiveRecord::Base
+  guise_for :User,
+            foreign_key: :person_id
+end
+
+class TechnicianUserRole < UserRole
+  scoped_guise_for :User
 end
 
+
+FactoryGirl.find_definitions
+RSpec.configure do |config|
+  config.order = 'random'
+  config.include FactoryGirl::Syntax::Methods
+end