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 = 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)

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"

I like ActiveRecord OR-ing

class Creature < ActiveRecord::Base
    scope :is_good_pet, -> {



class Person < ActiveRecord::Base
  has_many :pets

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

person.pets << 'Snoopy')
person.pets.count # => 2
person.pets.many? # => true

Multiline Ruby String without interpolation

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
# => "2017-01-17 06:43:48 -0500" 

s = %(
# => "\n2017-01-17 06:43:48 -0500\n"

s = %Q(
# => "\n2017-01-17 06:43:48 -0500\n"

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

s = %q(
# => "\n\#{}\n"

And without the new lines.

s = %q(
# => "\#{}"

Instagram Subscriptions

Instagram Subscriptions

Loading development environment (Rails 5.0.1)
2.3.0 :001 > puts JSON.parse(Infectious::Instagram.subscribe('','dave').body).to_yaml
ETHON: Libcurl initialized
ETHON: performed EASY effective_url= response_code=200 return_code=ok total_time=1.394347
  code: 200
  object: user
  aspect: media
  subscription_id: 0
  type: subscription
  id: 0


Not sure what to make of this at all.

class Cat
  def call(*args)
    (args).join(' ^O^ ')
end, :smeagol, :gimmick)

Rails 4, ActiveRecord::Base, MySQL and DISTINCT

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.* FROM `grapes` INNER JOIN `tickets` ON `z' at line 1: SELECT `pledges`.`id` AS t0_r0, ...., DISTINCT, 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.*')
+        scope = scope.joins(:tickets).distinct('')

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.* FROM grapes;

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

Do your columns contain Unicode Characters?

Want to work out if any of your columns contain Unicode Characters?

Something.where('LENGTH(data) != CHAR_LENGTH(data)').first

cannot remove 'v3.0': Directory not empty”

But it is empty???

rails@snarf:~$ ls -la /var/www/
total 40
drwxrwxr-x 2 rails rails 36864 Dec 16 15:11 .
drwxrwxr-x 3 rails rails  4096 Mar 23  2016 ..
rails@snarf:~$ rmdir /var/www/
rmdir: failed to remove ‘/var/www/’: Directory not empty

ActiveSupport Date and Time formats

Just went hunting for Date and Time formats, found this.


      # Use the strftime parameters for formats.
      # When no format has been given, it uses default.
      # You can provide other formats here if you like!
      default: "%Y-%m-%d"
      short: "%b %d"
      long: "%B %d, %Y"

    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]

    # Don't forget the nil at the beginning; there's no such thing as a 0th month
    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
    # Used in date_select and datetime_select.
      - year
      - month
      - day

      default: "%a, %d %b %Y %H:%M:%S %z"
      short: "%d %b %H:%M"
      long: "%B %d, %Y %H:%M"
    am: "am"
    pm: "pm"

# Used in array.to_sentence.
      words_connector: ", "
      two_words_connector: " and "
      last_word_connector: ", and "
    # Used in NumberHelper.number_to_delimited()
    # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
      # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
      separator: "."
      # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
      delimiter: ","
      # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
      precision: 3
      # If set to true, precision will mean the number of significant digits instead
      # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
      significant: false
      # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
      strip_insignificant_zeros: false

    # Used in NumberHelper.number_to_currency()
        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
        format: "%u%n"
        unit: "$"
        # These five are to override number.format and are optional
        separator: "."
        delimiter: ","
        precision: 2
        significant: false
        strip_insignificant_zeros: false

    # Used in NumberHelper.number_to_percentage()
        # These five are to override number.format and are optional
        # separator:
        delimiter: ""
        # precision:
        # significant: false
        # strip_insignificant_zeros: false
        format: "%n%"

    # Used in NumberHelper.number_to_rounded()
        # These five are to override number.format and are optional
        # separator:
        delimiter: ""
        # precision:
        # significant: false
        # strip_insignificant_zeros: false

    # Used in NumberHelper.number_to_human_size() and NumberHelper.number_to_human()
        # These five are to override number.format and are optional
        # separator:
        delimiter: ""
        precision: 3
        significant: true
        strip_insignificant_zeros: true
      # Used in number_to_human_size()
        # Storage units output formatting.
        # %u is the storage unit, %n is the number (default: 2 MB)
        format: "%n %u"
            one:   "Byte"
            other: "Bytes"
          kb: "KB"
          mb: "MB"
          gb: "GB"
          tb: "TB"
          pb: "PB"
          eb: "EB"
      # Used in NumberHelper.number_to_human()
        format: "%n %u"
        # Decimal units output formatting
        # By default we will only quantify some of the exponents
        # but the commented ones might be defined or overridden
        # by the user.
          # femto: Quadrillionth
          # pico: Trillionth
          # nano: Billionth
          # micro: Millionth
          # mili: Thousandth
          # centi: Hundredth
          # deci: Tenth
          unit: ""
          # ten:
          #   one: Ten
          #   other: Tens
          # hundred: Hundred
          thousand: Thousand
          million: Million
          billion: Billion
          trillion: Trillion
          quadrillion: Quadrillion