-- C level backtrace information -------------------------------------------
0   libruby.2.2.0.dylib                 0x0000000103e6e885 rb_vm_bugreport + 149
1   libruby.2.2.0.dylib                 0x0000000103d0dbb4 rb_bug + 468
2   libruby.2.2.0.dylib                 0x0000000103d0deac rb_bug_errno + 92
3   libruby.2.2.0.dylib                 0x0000000103e7cb2c thread_timer + 588
4   libsystem_pthread.dylib             0x00007fffbb4ac9af _pthread_body + 180
5   libsystem_pthread.dylib             0x00007fffbb4ac8fb _pthread_body + 0

-- Other runtime information -----------------------------------------------

* Loaded script: bin/rails

* Loaded features:

    0 enumerator.so
    1 rational.so
    2 complex.so

I always thought Enumerable#any? was equivalent to Enumerable#count > 1

But no…

[nil, nil, nil].any?
#=> false

I love PacMan but I am not good at it, not even if my own neighbourhood.

Interesting problem requiring us to remove the where values on an ActiveRecord::Relation. The original heavy handed method seems to play havoc with chained where calls and the id of the original proxy_association.owner would get used in a later where. Here we can see that our for_me method seems to cause the else_id to be the same as our recipient_id

[5] pry(#<RSpec::Core::ExampleGroup::Nested_1::Nested_7::Nested_1>)> user.somethings.where(else_id: something.else_id).to_sql
=> "SELECT `somethings`.* FROM `somethings` WHERE `somethings`.`user_id` = 20323 AND `somethings`.`else_id` = 6465  ORDER BY id DESC"
[6] pry(#<RSpec::Core::ExampleGroup::Nested_1::Nested_7::Nested_1>)> user.somethings.for_me.where(else_id: something.else_id).to_sql
=> "SELECT `somethings`.* FROM `somethings` WHERE `somethings`.`recipient_id` = 20323 AND `somethings`.`else_id` = 20323  ORDER BY id DESC

when in doubt read the Rails source

# remove user_id = proxy_association.owner.id from scope
    # so it can be reapplied by to_me or for_me
    def global_scope
-      s = respond_to?(:scoped) ? scoped : all
-      s.where_values = []
-      s
+      unscope(where: :user_id)
    end

which is the way that rewhere reassigns values in where rather than chaining again

2.2.2 :006 > Something.where(user_id: 1).where(user_id: 2).to_sql
=> "SELECT `somethings`.* FROM `somethings` WHERE `somethings`.`user_id` = 1 AND `somethings`.`user_id` = 2"
2.2.2 :007 > Something.where(user_id: 1).rewhere(user_id: 2).to_sql
=> "SELECT `somethings`.* FROM `somethings` WHERE `somethings`.`user_id` = 2"

class Creature < ActiveRecord::Base
    scope :is_good_pet, -> {
        where(
            arel_table[:is_cat].eq(true)
            .or(arel_table[:is_dog].eq(true))
            .or(arel_table[:eats_children].eq(false))
        )
    }
end

Nice…

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.count # => 1
person.pets.many? # => false

person.pets << Pet.new(name: 'Snoopy')
person.pets.count # => 2
person.pets.many? # => true

Whilst trying to clean up old blog posts. I thought I’d just re-assign the whole post on the console. However, the content of the post had code examples and these examples were being interpolated. This makes sense but isn’t what I wanted. These are all (nearly) equivalent other than the new lines.

s =<<-STR
#{Time.now}
STR
# => "2017-01-17 06:43:48 -0500" 

s = %(
#{Time.now}
)
# => "\n2017-01-17 06:43:48 -0500\n"

s = %Q(
#{Time.now}
)
# => "\n2017-01-17 06:43:48 -0500\n"

But what I really want it multi-line string assignment without interpolation.

s = %q(
#{Time.now}
)
# => "\n\#{Time.now}\n"

And without the new lines.

s = %q(
#{Time.now}
).lstrip.chop
# => "\#{Time.now}"

Instagram Subscriptions

Loading development environment (Rails 5.0.1)
2.3.0 :001 > puts JSON.parse(Infectious::Instagram.subscribe('http://robl.me/instagram/subscriptions/callback','dave').body).to_yaml
ETHON: Libcurl initialized
ETHON: performed EASY effective_url=https://api.instagram.com/v1/subscriptions response_code=200 return_code=ok total_time=1.394347
---
meta:
  code: 200
data:
  object: user
  object_id: 
  aspect: media
  subscription_id: 0
  callback_url: http://robl.me/instagram/subscriptions/callback
  type: subscription
  id: 0

Not sure what to make of this at all.

class Cat
  def call(*args)
    (args).join(' ^O^ ')
  end
end

Cat.new.(:samson, :smeagol, :gimmick)

Interesting, ActiveRecord joins issues today. Recently upgraded to Rails 4.0 and working on clearing odd occasional bugs.

Mysql2::Error: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DISTINCT grapes.id, grapes.* FROM `grapes` INNER JOIN `tickets` ON `z' at line 1: SELECT `pledges`.`id` AS t0_r0, ...., DISTINCT grapes.id, grapes.* FROM `grapes` INNER JOIN `tickets` ....

We specifically need a DISTINCT in here so that we don’t end up with duplicate rows. However, overwriting the select for *eager_load*ed statements isn’t going to work, in fact it appears to just append our select causing the above error. So…

-        scope = scope.joins(:tickets).select('DISTINCT grapes.id, grapes.*')
+        scope = scope.joins(:tickets).distinct('grapes.id')

Don’t use .select(‘DISTINCT … when eager_loading is likely to kick in. You’ll end up with something like.

SELECT `grapes`.`id` AS t0_r0, ..... DISTINCT(grapes.id), grapes.* FROM grapes;

Which will break, since you can’t have two DISTINCT in a SELECT.