Pollyanna fucked around with this message at 18:48 on Feb 19, 2015

RSpec.describe Activity, :type => :model do
  context "on creation" do
    let(:lead) { create(:lead)}
    let(:activity) { create(:activity, lead: lead) }
    it "updates last_activity_at of the parent lead" do
      expect(activity.lead.last_activity_at).to eq(activity.created_at)
    end
  end

  context "on deletion" do 
    let(:lead) { create(:lead)}
    let(:activity) { create(:activity)}

    it "resets the last_activity_at to the last activity" do
      destroyed_activity = create(:activity, lead: lead) 
      destroyed_activity.destroy
      expect(lead.last_activity_at).to eq(activity.created_at)
    end
  end
end

RSpec.describe Lead, :type => :model do
  
  context 'relationships' do

    let(:leads) { FactoryGirl.create_list(:lead, 3) }

     it "returns nil before the first lead" do
      expect(leads[0].prev_lead).to be nil
    end

    it 'returns nil after the last lead' do
      expect(leads[-1].next_lead).to be nil
    end

    it 'returns the previous lead' do
      expect(leads[1].next_lead).to be leads[0]
    end

    it 'returns the next lead' do
      expect(leads[1].prev_lead).to eq leads[2]
    end
  end 

EVGA Longoria fucked around with this message at 21:01 on Feb 23, 2015

class ClassA
  has_many => :class_a_class_b
  has_many :class_b, :through => :class_a_class_b
end

class ClassB
  has_many => :class_a_class_b
  has_many :class_a, :through => :class_a_class_b
end

class ClassAClassB
  belongs_to :class_a
  belongs_to :class_b

  # database table class_a_class_b contains the following fields
  # class_a_id
  # class_b_id
  # some_other_attribute 
end

def some_method
  a = classA.new
  b = classB.new

  # If I do this, then there's no classA_classB object to populate with some_other_attribute, at 
  # least without saving first (which really isn't an option)
  a.class_bs << b
  puts a.class_bs.size                                                       # output = 1
  a.class_a_class_bs.size                                                    # output = 0; same 
                                                                             #  for b.class_a_class_b.size
  a.class_a_class_bs.first.some_other_attribute = "abc"                      # throws exception; 
end

def try_different_approach
  a = classA.new
  b = classB.new
  link = ClassAClassB.new
  link.class_a = a
  link.class_b = b
  link.some_other_attribute = "abc"
  a.class_a_class_bs << link
  b.class_a_class_bs << link

  # This works, but now I don't have the direct link between A and B, and doesn't inform
  # the main objects of the links at all.
  puts a.class_bs.size                                                      # output = 0
  puts a.class_a_class_bs.size                                              # output = 0
  # etc.
  # In this case, I'm also concerned about whether the link will even be saved when I save a or b.
end

def third_try
  a = classA.new
  b = classB.new
  link = ClassAClassB.new

  link.class_a = a
  link.class_b = b
  link.other_attribute = "abc"
  a.class_a_class_bs << link
  b.class_a.class_bs << link
  
  # Still doesn't hook up a -> b link, but at least is functional up to that point.
  puts a.class_a_class_bs.size                                              # output = 1
  puts b.class_a_class_bs.size                                              # output = 1
  puts a.class_bs.size                                                      # output = 0
  puts b.class_as.size                                                      # output = 0

  # However, even when I save a, it doesn't get the link to b without reloading.
  a.save
  puts a.class_bs.size                                                      # output = 0
  # Oddly, the other direction works fine.
  puts b.class_as.sizse                                                     # output = 1
  a.reload
  puts a.class_bs.size                                                      # output = 1
end

def desperate_attempt
  # Just hook everything up manually
  a = classA.new
  b = classB.new
  link = ClassAClassB.new
  link.class_a = a
  link.class_b = b
  link.other_attribute = "abc"
  a.class_a_class_bs << link
  b.class_a_class.bs << link
  a.class_bs << b
  b.class_as << a
  
  # That seems to work at first, but the link between a and b is actually separate from the explicit 
  # link object here.  So, when I save, I get this:
  a.save
  puts a.persisted?                                                         # output = true
  puts b.persisted?                                                         # output = true
  puts link.persisted?                                                      # output = true
  puts a.class_a_class_bs.size                                              # output = 2
end

a.class_b = b, :using => link

Peristalsis fucked around with this message at 19:46 on Feb 26, 2015

      class Butt < ActiveRecord::Base
        has_many: :poops
      end 
      
      class Poop < ActiveRecord::Base
        belongs_to: :butt
      end 

      class ButtManager
        attr_reader :butt

        def initialize(butt:)
          @butt = butt
        end

        def go_to_bathroom
          poop = create_poop
          wipe_butt
          flush_toilet
          examine_poop(poop)
        end 
        
        def create_poop
          butt.poops.create
        end

        def flush_toilet
          begin 
            Toilet.flush
          rescue Toilet::ToiletTankNotReady
            # handle error
          end 
        end

        def wipe_butt
          fail "No TP in cache" if TP.get_from_cache.nil?
          # butt whiping code
        end 

        def examine_poop(poop)
          raise if poop.contains_blood? 
          # validates health of poop 
        end
      end

DONT THREAD ON ME fucked around with this message at 22:18 on Feb 27, 2015