bajiudongfeng (bajiudongfeng)

Missing `secret_key_base` for 'production' environment

bajiudongfeng — Tue, 31 Oct 2017 15:48:08 +0800

错误如上，但是我已经设置了 SECRET_KEY_BASE

echo $SECRET_KEY_BASE

6f1cdd7d6de9cc27b3d03a296b7637f93bc7d362d4223527d4777ee1ce968614c142f2feb7bc30668ddca56879dcf5ed7e7bdfef7aee83ab5eb868cd33b4346d

为啥依然会报这个错误呢？

gem mina 的学习

bajiudongfeng — Wed, 12 Apr 2017 22:51:55 +0800

有些地方理解的还不是很到位，还请大家指点．

1. 概述

mina 是一个快速部署工具。原理：

将部署过程需要用到的所有命令放置到数组之中
转换成对应的字符串
登录远程服务器，执行命令

2. 深入分析

mina 主体代码结构：

各个文件作用简述：

Mina::Application 类主要是初始化 mina，执行队列中的命令. 主要方法 run

Mina::Backend::Local 和 Mina::Backend::Remote 类一个是在当前机器执行命令，一个是在远程服务器执行命令。关键方法：ssh

Mina::Helpers::Internal 模块主要是对命令进行一些字符串方面的处理，记录部署花费时间等.<br＞ Mina::Helpers::Output 模块主要是输出的操作，用不同的颜色表示不同信息的输出。

Mina::Runner::Exec Mina::Runner::Pretty Mina::Runner::Printer Mina::Runner::System 这几个类实现了 ruby 调用 shell 的几种形式。

Mina::Commands 类定义了对命令的一些基本操作. 例如: 方法：command 将命令加入队列方法：process 将命令的队列转换成字符串方法：run 执行命令

Mina::Configuration 类定义了 mina 中最基本的方法例如: set fetch

Mina::DSL 模块定义了一些关键的，会直接使用到的方法例如：方法：invoke 让任务可以被调用方法：in_path 在某个目录下运行命令方法：run 执行某个命令

Mina::Runner 类主要是命令的最后执行．

3. 举例说明运行流程

例子：

mina run["ls -l"]
mina 任务源码（tasks/mina/default.rb）接下来分析下 mina 运行这个命令的流程 mina 定义了运行命令的任务

desc 'Runs a command in the server.'
task :run, [:command] do |_, args|
  ensure!(:deploy_to)
  command = args[:command]

  unless command
    puts "You need to provide a command. Try: mina 'run[ls -la]'"
    exit 1
  end

  in_path fetch(:deploy_to) do
    command command
  end
end

起点和终点

所有的 mina 任务的运行都要先执行文件 bin/mina

#!/usr/bin/env ruby require 'mina' Mina::Application.new.run

初始化 mina，同时开始执行命令

我们来看这个过程都发生了那些操作，关键点：

def run
  Rake.application = self
  super
end

将 Mina::Application 初始化对象复制给 Rake.application
调用父类 Rake::Application 的 run 方法，这个会导致对方法top_level_tasks调用。其中很关键的是： :run_commands．这个会导致对 run_commands 这个任务的执行（稍后会提到）

之后会回到任务mina run["ls -l"] 之中

ensure!(:deploy_to)
command = args[:command]

确认部署目录有值，获取参数

核心来了

in_path fetch(:deploy_to) do
    command command
 end

我们来看 in_path 方法：

def in_path(path, indent: nil)
  real_commands = commands
  @commands = Commands.new
  yield
  real_commands.command(commands.process(path), quiet: true, indent: indent)
  @commands = real_commands
end

yield中的操作也就是command command 这是将命令ls -l放入队列之中．

def initialize(stage = :default)
  @stage = stage
  @queue = Hash.new { |hash, key| hash[key] = [] }
end

def command(code, strip: true, quiet: false, indent: nil)
  code = unindent(code) if strip
  code = indent(indent, code) if indent
  queue[stage] << (quiet ? code : echo_cmd(code))
end

对命令进行一些简单的处理，然后加入队列queue[:default]中．类似结果：

#<Mina::Commands:0x0000000291a5d0 @stage=:default, @queue={:default=>["ls -l"]}>

将命令进行一些处理再次放入队列之中

def process(path = nil)
  if path
    queue[stage].unshift(%{echo "$ cd #{path}"}) if fetch(:verbose)
    %{(cd #{path} && #{queue[stage].join(' && ')} && cd -)}
  else
    queue[stage].join("\n")
  end
end

类似结果：＞ #<Mina::Commands:0x0000000291a698 @stage=:default, @queue={:default=>["(cd /home/zhang/dongfeng && ls -l && cd -)"]}>

接下来会执行任务 run_commands，这个应该还是Mina::Application的run 方法中的super的因素。具体原因还不清楚．

task :environment do
end

task :run_commands do
  if commands.run_default?
    invoke :environment
    commands.run(:remote)
  end
end

当 stage == :default 且命令队列不为空的时候才执行. 会调用任务 mina environment，默认为空，但是项目中的配置文件一般会覆写这个任务用来加载ruby环境，例如rvm等．

快到最后时刻了

def report_time
       time_start = Time.now
       output = yield
       print_info "Elapsed time: %.2f seconds" % [Time.now - time_start]
       output
end

定义了计算时间的方法．


def run(backend)
      return if queue.empty?
      report_time do
        status = Mina::Runner.new(process, backend).run
        error! 'Run Error' unless status
      end
 end

命令的执行即将开始．关键参数类似结果：

process : (cd /home/zhang/dongfeng && ls -l && cd -) backend: remote

Mina::Runner的关键方法：

 def run
      Mina::Runner.const_get(class_name_for(execution_mode)).new(script).run
 end
private

def script
   　Mina::Backend.const_get(class_name_for(backend)).new(commands).prepare
end

Mina::Runner.const_get(class_name_for(execution_mode)) 主要就是选用那种执行方式：

Mina::Runner::Exec Mina::Runner::Pretty Mina::Runner::Printer Mina::Runner::System

而 script 则确定在远程还是在本地执行，此处是在远程执行．

def prepare
  if fetch(:simulate)
    [
      '#!/usr/bin/env bash', "# Executing the following via '#{ssh}':",
      '#', commands, ' '
    ].join("\n")
  else
    command = Shellwords.escape(commands)
    w = [ssh, '--', command].join(' ')
  end
end

def ssh
  ensure!(:domain)
  args = fetch(:domain)
  args = "#{fetch(:user)}@#{fetch(:domain)}" if set?(:user)
  args += " -i #{fetch(:identity_file)}" if set?(:identity_file)
  args += " -p #{fetch(:port)}" if set?(:port)
  args += ' -A' if set?(:forward_agent)
  args += " #{fetch(:ssh_options)}" if set?(:ssh_options)
  args += ' -tt'
  "ssh #{args}"
end

prepare 会对命令进行一些处理类似结果：

(cd\ /home/zhang/dongfeng\ &&\ ls\ -l\ &&\ cd\ -)

然后把 ssh 远程登录的命令加入到所有命令的最开始处．类似结果：

ssh user_name@***.xyz -p 22 -tt -- (cd\ /home/zhang/dongfeng\ &&\ ls\ -l\ &&\ cd\ -)

此时就开始登录远程服务器执行命令了，静待即可．

Devise async send email

bajiudongfeng — Sun, 09 Apr 2017 18:41:48 +0800

1. 解决方案

在 user 这个 model 下添加如下代码

# Override Devise to send mails with async
def send_devise_notification(notification, *args)
  devise_mailer.send(notification, self, *args).deliver_later
end

默认的话使用 devise 内部内置的发送邮件的方法，也可以进行覆盖，自定义邮件发送。但是要注意修改devise.rb文件：

# Configure the class responsible to send e-mails.
# config.mailer = 'Devise::Mailer'

后台进行邮件处理的可以选择 Resque,sidekiq 等，此处使用sidekiq 在 application.rb 文件中加入如下代码：

config.active_job.queue_adapter = :sidekiq

devise 默认的邮件发送使用的 redis 队列名称是 mailers,因此要在sidekiq.yml文件中加入此队列。

- [mailers, 3]

2. 运行结果

development.log 文件：

[ActiveJob] Enqueued ActionMailer::DeliveryJob (Job ID: 6a5e3f3f-bccf-4fc7-89e0-f16f63918aa0) to Sidekiq(mailers) with arguments: "Devise::Mailer", "reset_password_instructions", "deliver_now", #>, "CpfoqSDN3z6zvA9yiUsL", {}

sidekiq.log 文件：

2017-04-09T08:53:57.511Z 24351 TID-y44z8 ActionMailer::DeliveryJob JID-fede8f1837ccca19b5dbf262 INFO: start
2017-04-09T08:53:58.493Z 24351 TID-y44z8 ActionMailer::DeliveryJob JID-fede8f1837ccca19b5dbf262 INFO: done: 0.983 sec

3. 源码探究

打印 send_devise_notification(notification, *args) 参数信息：

I, [2017-04-09T17:00:56.308408 #21573] INFO -- : notification: reset_password_instructions
I, [2017-04-09T17:00:56.308512 #21573] INFO -- : args: ["hmNJj3Gszwvswd2VjxQL", {}]
I, [2017-04-09T17:00:56.498526 #21573] INFO -- : devise_mailer: Devise::Mailer Class

因此可知类： Devise::Mailer 方法：reset_password_instructions

源码文件路径：devise/app/mailers/devise/mailer.rb

if defined?(ActionMailer)
  class Devise::Mailer < Devise.parent_mailer.constantize
    include Devise::Mailers::Helpers

    def confirmation_instructions(record, token, opts={})
      @token = token
      devise_mail(record, :confirmation_instructions, opts)
    end

    def reset_password_instructions(record, token, opts={})
      @token = token
      devise_mail(record, :reset_password_instructions, opts)
    end

    def unlock_instructions(record, token, opts={})
      @token = token
      devise_mail(record, :unlock_instructions, opts)
    end

    def email_changed(record, opts={})
      devise_mail(record, :email_changed, opts)
    end

    def password_change(record, opts={})
      devise_mail(record, :password_change, opts)
    end
  end
end

因此：devise_mailer会根据不同的参数调用不同的方法。

Devise.parent_mailer.constantize 解析：

# devise/lib/devise.rb
module Devise
  # The parent mailer all Devise mailers inherit from.
  # Defaults to ActionMailer::Base. This should be set early
  # in the initialization process and should be set to a string.
  mattr_accessor :parent_mailer
  @@parent_mailer = "ActionMailer::Base"
end

发送邮件操作进一步解析

发送邮件的方法 devise_mail 定义在 module Devise::Mailers::Helpers中，这是发送邮件的具体实现。

# 发送邮件 record 就是User记录, action 是 :reset_password_instructions
def devise_mail(record, action, opts = {}, &block)
  initialize_from_record(record)
  mail headers_for(action, opts), &block
end

 # 一些初始化的工作
def initialize_from_record(record)
  @scope_name = Devise::Mapping.find_scope!(record)
  @resource   = instance_variable_set("@#{devise_mapping.name}", record)
end

# 设置一些头信息
def headers_for(action, opts)
  headers = {
    subject: subject_for(action),
    to: resource.email,
    from: mailer_sender(devise_mapping),
    reply_to: mailer_reply_to(devise_mapping),
    template_path: template_paths,
    template_name: action
  }.merge(opts)

  @email = headers[:to]
  headers
end

headers 的结果类似：

headers: {:subject=>"重置密码信息", :to=>"14172@qq.com", :from=>"infoabc@qq.com", :reply_to=>"infoabc@qq.com", :template_path=>["devise/mailer"], :template_name=>:reset_password_instructions}

What are blocks, procs, and lambdas?

bajiudongfeng — Sat, 08 Apr 2017 20:33:56 +0800

原文链接

1. 主要区别：

Proc 和 Lambda 都是对象，而 Block 不是
参数列表中最多只能有一个 Block，但是可以有多个 Proc 或 Lambda
Lambda 对参数的检查很严格，而 Proc 则比较宽松
Proc 和 Lambda 中 return 关键字的行为是不同的

2. 特殊符号

同时要注意&符号

The '&' tells ruby to turn the proc into a block

例如

Sale.limit(5).map(&:id)

:id是一个 symbol 对象，当在其前面加上&就表示后边需要的是一个 proc，因此:id会调用其 to_sym 方法。

3. 具体代码分析

基本的例子

# Block Examples
[1,2,3].each { |x| puts x*2 }   # block is in between the curly braces

[1,2,3].each do |x|
  puts x*2                    # block is everything between the do and end
end

# Proc Examples             
p = Proc.new { |x| puts x*2 }
[1,2,3].each(&p)              # The '&' tells ruby to turn the proc into a block 

proc = Proc.new { puts "Hello World" }
proc.call                     # The body of the Proc object gets executed when called

# Lambda Examples            
lam = lambda { |x| puts x*2 }
[1,2,3].each(&lam)

lam = lambda { puts "Hello World" }
lam.call

区别 1(Proc 和 Lambda 都是对象，而 Block 不是) 举例

p = Proc.new { puts "Hello World" }

p.call  # prints 'Hello World'
p.class # returns 'Proc'
a = p   # a now equals p, a Proc instance
p       # returns a proc object '#<Proc:0x007f96b1a60eb0@(irb):46>'

{ puts "Hello World"}       # syntax error  
a = { puts "Hello World"}   # syntax error
[1,2,3].each {|x| puts x*2} #

p 是类 Proc 的一个实例对象，其可以调用方法，复制给其他变量，也可以返回自己. block 是方法调用的一部分，不可以单独存在，

区别 2(参数列表中最多只能有一个 Block，但是可以有多个 Proc 或 Lambda) 举例

def multiple_procs(proc1, proc2,&block)
  proc1.call
  proc2.call
  block.call
end

a = Proc.new { puts "First proc" }
b = Proc.new { puts "Second proc" }

multiple_procs(a,b) {puts "block"}

区别 3(Lambda 对参数的检查很严格，而 Proc 则比较宽松) 举例

proc = Proc.new { puts "Hello world" }
lam = lambda { puts "Hello World" }

proc.class # returns 'Proc'
lam.class  # returns 'Proc'

proc   # returns '#<Proc:0x007f96b1032d30@(irb):75>'
lam    # returns '<Proc:0x007f96b1b41938@(irb):76 (lambda)>'

proc 和 lam 都是 Proc 的实例对象，仅有微小的不同参数检查的不同

proc = Proc.new { |x| puts x } # creates a proc that takes 1 argument
proc.call(2)                   # prints out 2
proc.call                      # returns nil
proc.call(1,2,3)               # prints out 1 and forgets about the extra arguments

lam = lambda { |x| puts x }    # creates a lambda that takes 1 argument
lam.call(2)                    # prints out 2
lam.call                       # ArgumentError: wrong number of arguments (0 for 1)
lam.call(1,2,3)                # ArgumentError: wrong number of arguments (3 for 1)

区别 4(Proc 和 Lambda 中 return 关键字的行为是不同的) 举例

def lambda_test
  lam = lambda { return }
  lam.call
  puts "Hello world"
end

lambda_test                 # calling lambda_test prints 'Hello World'


def proc_test
  proc = Proc.new { return }
  proc.call
  puts "Hello world"
end

proc_test                 # calling proc_test prints nothing

这个有点类似循环中的continue 和 break

devise_async 发送邮件出错

bajiudongfeng — Sat, 25 Mar 2017 15:11:46 +0800

使用 devise_async 发送邮件，按照这个教程做的。
可是却报如下错误，求解：

ArgumentError (wrong number of arguments (given 3, expected 1..2)):

app/controllers/users/registrations_controller.rb:13:in `create'
  Rendering /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/diagnostics.html.erb within rescues/layout
  Rendering /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/_source.html.erb
  Rendered /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/_source.html.erb (4.9ms)
  Rendering /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/_trace.html.erb
  Rendered /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/_trace.html.erb (3.2ms)
  Rendering /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/_request_and_response.html.erb
  Rendered /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/_request_and_response.html.erb (1.6ms)
  Rendered /home/zhang/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.2/lib/action_dispatch/middleware/templates/rescues/diagnostics.html.erb within rescues/layout (27.7ms)

谢谢！

GitHub 登录 OAuth 学习

bajiudongfeng — Thu, 23 Mar 2017 21:15:14 +0800

简介维基百科

OAuth（开放授权）是一个开放标准，允许用户让第三方应用访问该用户在某一网站上存储的私密的资源（如照片，视频，联系人列表），而无需将用户名和密码提供给第三方应用。

OAuth 允许用户提供一个令牌，而不是用户名和密码来访问他们存放在特定服务提供者的数据。每一个令牌授权一个特定的网站（例如，视频编辑网站) 在特定的时段（例如，接下来的 2 小时内）内访问特定的资源（例如仅仅是某一相册中的视频）。这样，OAuth 让用户可以授权第三方网站访问他们存储在另外服务提供者的某些特定信息，而非所有内容。
大致流程 (以 github 为例)

应用向 github 请求授权 github 为用户显示一个授权页面，用户在此页面确认是否同意应用的请求如果用户同意授权，应用会获取到一个访问令牌 (access_token)，通过此令牌，应用可以访问授权用户的数据
详细流程 github 文档

转发到授权页面的 api

GET https://github.com/login/oauth/authorize client_id 必须参数。

如果用户同意授权，github 就会转发到第三方网站，同时提供一个 code 参数。
第三方站点接着调用 api

POST https://github.com/login/oauth/access_token client_id 必须 client_secret 必须 code 必须获得 token，例如
access_token=e72e16c7e42f292c6912e7710c838347ae178b4a&scope=user%2Cgist&token_type=bearer

访问资源

GET https://api.github.com/user?access_token=...
devise 集成文档

Active Support 的 Concern 模块来由探究

bajiudongfeng — Mon, 20 Mar 2017 21:54:25 +0800

ActiveSupport::Concern 模块作用：让 rails 类包含模块之后同时获得实例方法和类方法。例如：

require 'active_support'
module MyConcernA
  extend ActiveSupport::Concern

  def an_instance_method 
    "an_instance_method "
  end

  module ClassMethods
    def a_class_method
      "a_class_method"
    end
  end

end

class MyClass
  include MyConcernA
end

MyClass.a_class_method
=> "a_class_method" 
MyClass.new.an_instance_method
=> "an_instance_method "

那么这个是如何实现的呢？让我们从头说起。两个基本的概念：include 和 extend
include 让类获得实例方法
extend 让类获得类方法
最早使类同时获得实例方法和类方法的解决方法：

module A
  def self.included(base)
    base.extend ClassMethods
  end

  module ClassMethods
    def a_class_method
      puts "a_class_method"
    end
  end
  def a_instance_method
    puts "a_instance_method"
  end
end

class W
  include A
end
W.a_class_method
a_class_method
 => nil

模块 A 覆写了钩子方法 included，当在类 W 中 include A 的时候会调用覆写后的方法。
此时会把 W 作为一个参数传递进去，就是 included 钩子方法中的 base，所以就相当于 W 扩展了模块 ClassMethods，因此模块 ClassMethods 中的方法也就成为了类 A 的类方法。

但是这个技巧本身存在一些问题。每个需要定义类方法的模块都需要定义一个相似的 included 钩子方法。除此之外还有一个更为关键的问题，例如：

module B
  def self.included(base)
    base.extend ClassMethods
    #base.send :include, A
  end

  module ClassMethods
    def b_class_method
      puts "b_class_method"
    end
  end
  def b_instance_method
    puts "b_instance_method"
  end
  include A
end

class C
  include B
end

C.b_class_method
b_class_method
 => nil 
C.a_class_method
NoMethodError: undefined method `a_class_method' for C:Class
B.a_class_method
a_class_method
 => nil

本来 a_class_method 应该是类 C 的类方法才对，可是这里出了问题。原因在哪里呢？
在类C中 include B 此时参数 base 的值是 C
而在模块 B 中 include A 时候参数 base 的值是 B，所以 a_class_method 成为模块 B 的一个类方法。

为了解决这个问题，需要在模块 B 的钩子方法 included 中加入注释掉的代码

base.send :include, A

让类 C 调用一下模块 A 的钩子方法方法 included. 这样问题解决了，但是会造成其他的问题，如各个模块都包含了相似的代码，当超过一层模块包含的时候还有可能失败。

为了解决上述问题，ActiveSupport::Concern 出现了。其封装了包含并且扩展的技巧，同时解决了链式包含的问题。
一个模块可以通过扩展 concern 模块来定义自己的 ClassMethods 模块来实现包含并且扩展的功能，也就是文章最开始的例子。
那么这个是如何实现的呢？看源码

  module Concern
    class MultipleIncludedBlocks < StandardError #:nodoc:
      def initialize
        super "Cannot define multiple 'included' blocks for a Concern"
      end
    end

    def self.extended(base) #:nodoc:
      base.instance_variable_set(:@_dependencies, [])
    end

    def append_features(base)
      if base.instance_variable_defined?(:@_dependencies)
        base.instance_variable_get(:@_dependencies) << self
        return false
      else
        return false if base < self
        @_dependencies.each { |dep| base.send(:include, dep) }
        super
        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
      end
    end
　
　＃ 。。。

主要是两个方法 extend 和 append_features
当模块扩展 Concern 时候，会调用钩子方法 extended。在这个方法中为扩展它的类定义了一个@_dependencies.默认值是 [].
方法append_features是一个内核方法。和module#included类似。
相同点：当包含一个模块的时候被调用。
不同的：included 默认是空的，只有覆写之后才会有内容。而 append_features 则包含有实际的动作。用于检查被包含模块是否已经在包含类的祖先链上，如果不在则将该模块加入其祖先链。

当一个模块扩展 ActiveSupport::Concern，我们称其为一个 concern
接着我们来分析 append_features 的源码：
主要分为两种情况：
第一种情况

module MyConcernB
  extend ActiveSupport::Concern

  def an_instance_methodb
    "an_instance_method "
  end

  module ClassMethods
    def a_class_methodb
      "a_class_method"
    end
  end
  def self.instance_check
    instance_variable_get(:@_dependencies)
  end
  include MyConcernA
end

代码会先判断 base 是否是一个 concern.
当前是一个 concern(MyConcernB) 在包含一个 concern(MyConcernA).此时包含的时候并没有真正的执行包含的动作，只是把链接放到一个依赖图中。也就是将 MyConcernA 放入数组@_dependencies.

MyConcernB.instance_check
 => [MyConcernA] 
MyConcernB.a_class_method
NoMethodError: undefined method `a_class_method' for MyConcernB:Module

第二种情况

class MyClass
  include MyConcernB
end

此时就是 else 后边的情况了。
首先会判断 MyClass 是否继承了 MyConcernB，也就是看 MyConcernB 是否在 MyClass 的继承链中。
如果没有就进行最关键的步骤：concern(MyConcernB) 中的依赖（也就是@_dependencies,上文已经打印出了值）会被递归包含到类 Myclass 中。这种最小化的依赖管理方式解决了之前链式包含的问题。
此处的

@_dependencies.each { |dep| base.send(:include, dep) }

就相当于在 MyClass 中

include MyConcernA

把所有的依赖的 concern(也就是@_dependencies中的值) 都加入类的祖先链之后，
需要把包含类自己（此处相当于 MyConcernB）也加入类的继承链中。这个通过调用 super 来实现。
最后是要通过 ClassMethods 模块来扩展类，就像最初做的事情一样。

以上内容全部来源于 ruby 元编程第十章。
第一次写，还请大家多多指导。

单件类的疑问

bajiudongfeng — Wed, 08 Mar 2017 16:55:30 +0800

最近在看 letter_avatar 这个 gem，看到如下代码有些疑问．

在 class << self end 中定义方法，这个明白是给类 LetterAvatar::Avatar 定义类方法．

可是在里边定义个类 Identity，是什么意思呢？

Identity 和 LetterAvatar::Avatar 又有什么关系呢？

是因为 Identity 的方法只需要在 LetterAvatar::Avatar 类中使用才这样做的吗？

谢谢！

数组分页,除了 Kaminari.paginate_array 有更好的方法吗?

bajiudongfeng — Fri, 24 Feb 2017 18:19:49 +0800

最近做了个统计的表格，表格中的很多元素都是通过计算出来的，因此不能直接分页

目前使用了

paginatable_array = Kaminari.paginate_array (my_array_object).page (params [:page]).per (10)

方法，但是每次都要把整个结果集计算出来

而不是查看第一页的时候只取第一页的数据

有别的好的方法吗？谢谢！

网站升级到 https 后 Devise 登录请求会从 https 变成 http,其他页面正常

bajiudongfeng — Fri, 30 Dec 2016 15:42:56 +0800

图 1：

图 2：

如图所示： sing_in 这个请求是 https

但是到登录成功之后的 root 请求却变成了 http

查看 log 发现有如下信息：

I, [2016-12-30T15:33:59.873096 #6843]  INFO -- : Redirected to http://bset.yesqin.com/user/root

因此应该是重定向的时候出问题了。

打印出重定向时候的请求信息：

I, [2016-12-30T15:38:04.448955 #11578]  INFO -- :     after_sign_in_path_for(resource):  /user/root

按理说登录后的请求也应该是 https 才对啊，可为啥变了呢？

谢谢！

貌似发现了个论坛搜索的 Bug

bajiudongfeng — Tue, 08 Nov 2016 09:34:50 +0800

依次点击了 rspec 测试求时间方法

自然语言时间解析

下班时间都怎么度过的

然后打开的页面如图所示分别是

自然语言时间解析

下班时间都怎么度过的

Newrelic 监控的 respons 时间和实际测试时间差别很大

@huacnlee

transaction 中例如 create! 又包含在一个小的 begin..commit 中何解?

bajiudongfeng — Wed, 31 Aug 2016 13:33:04 +0800

本来是希望能减少提交次数，可是为了保证能正确回滚，又要使用 create! 这种方法，然这个又包含在一个单独的 transaction 中，有没有比较好的方法来解决这个问题。谢谢！

目前使用 paranoia 软删除,看有人喜欢给所有的表都加入软删除,有这个必要吗?

bajiudongfeng — Mon, 29 Aug 2016 20:51:47 +0800

如题

［已解决］字符串转换成 hash

bajiudongfeng — Thu, 23 Jun 2016 20:57:08 +0800

w = "{'response':{'id':'19999','period':'5','fieldList':[{'date':'2016-06-23','time':'00:01:07'},{'date':'2016-06-23','time':'00:06:07'}]}}"

uri = URI(price_api) price_data = Net::HTTP.get(uri) 使用如上方法获取 api 的结果是一个字符串如上字符串如何才能转换成 hash?

rake assets:precompile RAILS_ENV=production 没有生成*.gz 文件

bajiudongfeng — Tue, 07 Jun 2016 16:48:40 +0800

最近在看 rake assets:precompile 配合 nginx gzip 使静态文件进行压缩传输运行这个命令之后却没有生成*.gz 文件，本以为自己改到了 asset 相关的配置，查看之后无果在网上看了下，虽然可以写个 rake 任务自己进行压缩，同时 nginx 也提供这个功能，但是还是想知道自己项目的问题出在哪里了？求指点。

看到几篇文章，从环境搭载到部署 (Nginx + Unicorn)，每一步都讲解的很清楚，着实不错。

bajiudongfeng — Thu, 26 May 2016 11:01:00 +0800

第一篇：http://vladigleba.com/blog/2014/03/05/deploying-rails-apps-part-1-securing-the-server/ 本篇讲了服务器选择，登陆，部署账户创建权限设置。第二篇：http://vladigleba.com/blog/2014/03/14/deploying-rails-apps-part-2-setting-up-the-server/ 本篇讲了服务器基本环境的搭建，nodejs,nginx,ruby 等。第三篇：http://vladigleba.com/blog/2014/03/21/deploying-rails-apps-part-3-configuring-unicorn/ 本篇比较了 passenger,unicorn,puma 之间的优缺点，和 unicorn 的安装配置。第四篇：http://vladigleba.com/blog/2014/03/27/deploying-rails-apps-part-4-configuring-nginx/ 本篇讲解了 nginx 的配置，阐述了相关 directive 的作用。

Can't verify CSRF token authenticity 看了社区之前同样问题依然没有解决.

bajiudongfeng — Sun, 10 Jan 2016 15:38:43 +0800

登陆使用的是 devise 做的然后在前台使用$.ajax 发送 post 请求，出现了这个警告. 尝试了如下方法：

1.在 application.js 中添加如下代码

$.ajaxSetup({
  beforeSend: function (xhr) {
    xhr.setRequestHeader('X-CSRF-Token',$('meta[name="csrf-token"]').attr('content'));
  }
});

2.试着将$('meta[name="csrf-token"]').attr('content') 的值作为一个 ajax 的一个参数直接传过去. 都没有解决。

用 firefox 查看 request headers 里边也有 X-CSRF-Token 然后看有的朋友说可能是传入的和服务器端的 token 不一样。那该咋看服务器端的 token 值呢. 这个到底是哪里的问题呢？谢谢了。

已解决 CentOS iptables 配置完成之后,端口依然无法连接.

bajiudongfeng — Wed, 30 Dec 2015 11:09:06 +0800

先说下系统是 centos7 ,firewall 已经关闭了。现在使用 iptables 来管理. iptables --line-numbers -n -L 命令结果截图如下: 然而在本地使用 telnet ip 8000 依然无法连接使用命令 netstat -nlpt 结果如下: 22,80,3306 端口都是正常的. 谢谢。

gem 'net-ssh'　调用 Net::SSH.start ('host', 'user', :password => "password") 方法时候用户名或者密码错误情况下程序卡死

bajiudongfeng — Sun, 13 Sep 2015 12:12:00 +0800

如下：这是我的代码：实际发现如果用户名或者密码错误的时候，程序会卡死．看了一下源码如下：按理用户名密码不对应该抛出异常才对啊．然后在 rails c 里边试了一下，发现如果用户名密码不对，会让你继续输入密码，如果三次全部错误才会报错．那么这该如何解决呢？谢谢！

API 编写显示问题

bajiudongfeng — Wed, 28 Jan 2015 15:40:33 +0800

本人现在用 grape,jbuilder 编写 api，现在遇到了一个问题. 如下: 现在有两个数据集合 a 和 b，前台显示是要 4 个 a 的元素，1 个 b 的元素这样的.a 和 b 元素的字段也都不相同. 也就是说返回的 json 数据应该是四个 a 中元素，一个 b 中元素这样的. 求解.....