说说你的查询语句是怎么写的，Product.published.map{|x| x.picutres.map{|x| x.imageable}} 这样？

所以说参考 slc 做一个嘛，反正注入关联要干的活 slc 里都写了

scope 是关联上的 scope？看不出你写的 scope 和关联有什么关系，一开始我以为是 default_scope，后来发现关联是会忽视 default_scope 的。。

你那样改写关联，会导致 includes 无效等杂七杂八的问题，用||=缓存的话，也要有相应失效的机制

有干这个的 gem https://github.com/hooopo/second_level_cache

不过带 where 条件的关联，用 slc 可能会导致关联没法正确过期，要留意一下或者你参照 slc 的思路自己弄一个

7102 年了，还不支持 linux 输入中文。

😐没看到 left join

那就A.joins(ActiveRecord::Base.send(:sanitize_sql, ["LEFT JOIN bs ON as.id = bs.id AND bs.state in (?)", state_arr]))

干嘛在 on 上加 where 条件... 直接 join 完了 where 就是

在 rubychina，甚至可以招 python

原来如此

`` open3

{}属于最右的调用，do end 属于最左的调用

最简单的就是用Array#replace方法，对于immutable的变量，如果你非要这么做 https://github.com/CicholGricenchos/tricks/tree/master/caller_context_operate

最近也想写一份入门指南，我觉得先介绍define_method比def更好，基于 ruby 是个精简的 oo 内核加糖糖糖糖糖的语言……

这个专利的意思是，当你以任何理由起诉 facebook 的时候，必须立即停止使用 react，也就是 fb 在你还在用 react 的时候就可以肆意侵权了。

alias 就是这么特殊，而且 alias 的冒号还可以省略，用 alias_method 吧

order has_many order_items
order_item has_one product
order has_many packages
package has_many package_items
package_item has_one product

以上是常见的表结构，不知道你的是怎样的，order 和 products 一般是一对多，到 packages 也是一对多，然后 package 到 products 也是一对多。

关联加上 autosave，直接 teacher.students.new(xxx); teacher.save

?在 1.8 的时候是用来查字符的 ascii 码的，?x 相当于'x'.ord 这样，在 1.9 之后就变成返回单个字符本身了，一般很少会这么用。。

正则太 low 了，用宏吧 https://ruby-china.org/topics/29703

想玩魔法的话其实 call 也不用的，也不用 method_missing，在执行 block 之前做个宏替换：

require 'ruby_parser'
require 'ruby2ruby'
require 'method_source'

class Object
  class Proxy < BasicObject
    def call value
      @_ = value
    end

    def _
      @_
    end

    def initialize target
      @_ = target
    end
  end

  def pipe &block
    source = block.source
    block_body = RubyParser.new.process(source).to_a[3]
    head, *sequences = block_body
    sequences.map!{|x| [:call, nil, :call, x]}
    ast = Sexp.from_array([:block, *sequences])
    Proxy.new(self).instance_eval Ruby2Ruby.new.process(ast)
  end
end

#==========业务代码分割线=========

class ServiceA
  def initialize(n); @n = n; end

  def do_something
    p @n
    @n + 1
  end
end

class ServiceB
  def initialize(n); @n = n; end

  def do_something_else
    p @n
  end
end

some_data = 1
some_data.pipe do
  ServiceA.new(_).do_something  # => print 1
  ServiceB.new(_).do_something_else  # => print 2
end

可以的，_就是上一行的结果，call的作用就是赋值给_，https://ruby-china.org/topics/31848

其实 ruby 完全可以定义一些运算符，甚至超算符...

some_data
>> ServiceOne.do_something
>> ServiceOne.do_something_else

用这套配组合子可以玩的很开心……

但是要 ruby way 的话，我想应该是这样子：

some_data.pipe do
  call ServiceOne.new(_).do_something
  call ServiceTwo.new(_).do_something_else
end

因为管道本质上是要把占位符拿出来，这样也许不算太优雅，但是也许有些地方能用到，另外个人觉得 binding.pry 其实比 puts 要方便.....

抄送 @luikore ;-)

cool，那个 class 和 def 是用宏做的吗？

物理机 ubuntu 无桌面环境 i3wm

就

MainCombinePackageItem.joins('INNER JOIN packages main_package ON main_package.id = main_combine_package_items.main_package_id')
                      .joins('INNER JOIN packages combined_package ON combined_package.id = main_combine_package_items.combined_package_id')
                      .where('main_package.state NOT IN ? or combined_package.state NOT IN ?', [9, 10], [9, 10])
                      .where(warehouse_id: 1)

像楼上说的 not in 如果用不到索引的话，可以改成 in，一共有哪些状态是知道的

rails 在 joins 和 eager_load 同一个表的时候会加上别名的：

MainCombinedPackageItem.joins(:main_package, :combined_package)

SELECT "main_combined_package_items".* FROM "main_combined_package_items" INNER JOIN "packages" ON "packages"."id" = "main_combined_package_items"."main_package_id" INNER JOIN "packages" "combined_packages_main_combined_package_items" ON "combined_packages_main_combined_package_items"."id" = "main_combined_package_items"."combined_package_id"

第二个 packages 表加了 combined_packages_main_combined_package_items 的别名，可以直接在 where 用，但是我觉得这样不好，干脆直接写 sql 或者用把 sql 拆成手写的 joins() where()

惊了可还行，怕不是真实猛男（滑稽

不过 ruby 用的不是引用计数，是 mark and sweep： http://blog.jobbole.com/60900/

只要记住 ruby 里传递的永远是引用就好了，包括数字传的也是引用，不提供代码块，只提供一个对象引用的话，这个对象不一定是可复制的（虽然数组可以），所以 Array.new 肯定不会帮你复制

嗯，我看看