ruby记录

ruby for rails:
css style: https://getbootstrap.com
view source:gem sources
创建 vc: rails g controller welcome index
创建 db: bin/rails db:create (rake db:create)
创建模型user model:rails g model user
移植migrate： rake db:migrate

打开rails终端创建sql: rails c
选择当前数据库：User
插入一条数据：User.create username: '343', password: '123456'
查看所有的数据：User.all / User.all.to_a
查看第一条记录：user=User.first
user
user.id/user.password/user.username
修改一条记录：user.username = 'william'
user.save
删除一条记录：user.destroy

1 irb
2.$LOAD_PATH 加载的所有路径
  ruby 代码的查找路径为当前的$LOAD_PATH环境变量
  文件名命令规则：ruby文件的名字代表了当前class/module的名字
3.include and  extend
  include Managemnt:include 把模块的方法转换成实例方法
  extend Managemnt:extend 把模块的方法转换成类方法

5.include vs prepend
include 把模块注入当前类的继承链后面
prepend 把模块注入当前类的继承链前面

6.Staff.ancestors  方法查找链

7.class_eval
class_eval 会重新打开当前类作用域, 对当前的类重新定义和重新操作
「
class_eval 是只有类才能调用的，Class#class_eval
class_eval 是类的一个方法，类本身也是class的一个实例 ，即：所有的类class拥有 class_eval一个实例方法
在ruby中如果描述一个对像拥有实例方法，用#来代码，如果是类方法用.来代表
」

8.instance_eval:是所有类实例的方法，打开的是当前实例作用域

9. gem command
gem list:本机安装gem
gem install
gem uninstall
gem sources

10.bundle gem
gem 本身会有版本依赖问题
bundle是一个gem,被用来管理其他gems
bundle类似于Linux的yum,apt 是一个gems关系管理工具

bundle的基本使用
gem install bundler
Gemfile
bundle install/update/show/list

11.require vs load
相同点：都会在$LOAD_PATH下面查找当彰要引入的文件
不同点：
require调用文件时不需要".rb"的文件后缀，而load需要
require真对同样的文件只会调用一次，load而会反复调用

12. =~正则匹配
    !~没有匹配到

show gem 
gem env

列出已知的 ruby 版本:rvm list known
安装一个 ruby 版本:rvm install 2.2.0
切换 ruby 版本:rvm use 2.2.0
设置为默认版:rvm use 2.2.0 --default
查询已经安装的ruby:rvm list
卸载一个已安装版本:rvm remove 1.8.7

建立 gemset
rvm use 1.8.7
rvm gemset create rails23
以设定已建立的 gemset 做为当前环境: rvm use 1.8.7@rails23
列出当前 ruby 的 gemset:rvm gemset list
清空 gemset 中的 gem,清空一个 gemset 的所有 gem, 想重新安装所有 gem，可以这样
rvm gemset empty 1.8.7@rails23
删除一个 gemset:rvm gemset delete rails2-3

项目自动加载 gemset:
rvm install 1.9.3
rvm use 1.9.3
rvm gemset create rails313
rvm use 1.9.3@rails313

gem install rails --version 4.0.0 -V

=begin
1.setup:
brew install curl
curl -L https://get.rvm.io | bash -s stable
rvm install 2.2.3
2.set default version
rvm use --default 2.2.3
3.check out version
rvm use 2.2.1
4.uninstall
rvm unistall 2.2.1
5.debug
 irb for test
6.
a={"a":1,"b":2}   => {:a=>1, :b=>2}
a={"a"=>1,"b"=>2} => {"a"=>1, "b"=>2}
a.object_id

7.! or ?
!的方法会改变变自身
?的方法会返回true|false
这只是一个约束
在Rails中!的方法也被用来表示该方法会抛出异常
str = "capitalize"
str.capitalize!
str.is_a?(String)
8.nil
str = nil
str.nil?
在ruby中nil，false都是不成立，否的意思，其他一切为true
9.反引号
`ls` 运行shell cmd
10.array
3.0.0 :035 > a = []
3.0.0 :036 > a.push(1), => [1]
3.0.0 :037 > a.unshift(2),=> [2, 1]
3.0.0 :038 > a.pop ,  => 1
3.0.0 :039 > a.shift ,=> 2
3.0.0 :040 > a  , => []

11. 方法
a=1  # =>1
a+2  # =>3
在这里+只是一个方法，2是传递给方法的参数
方法的定义和参数传递煮可以不使用小括号()
所有方法都有返回值，方法体最后一行代码的返回值默认会做为方法的返回值，也可以显式的使用
return 关键字

12 range
3.0.0 :042 > a=1..10,=> 1..10
3.0.0 :043 > a.to_a.size, => 10
3.0.0 :044 > b=1...10, => 1...10
3.0.0 :045 > b.to_a.size, => 9
3.0.0 :046 > b,=> 1...10
3.0.0 :047 > c=:a..:z,=> :a..:z
3.0.0 :048 > d=a.to_a+c.to_a
 => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, :a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :o, :p, :q, :r, :s, :t, :u, :...

12。自定义Block，yield 为调用外部block的关键字
def hi name
  yiedl(name)
end
hi('code') {|x| "hello #{x}"}

13. proc
相当于定义了一个方法变量，可以把方法当作参数传递
hi = proc{ |x| p "hello #{x}"}
hi.call('world')

# equal to Proc
hi = Proc.new { |x| p "hello #{x}"}
hi.call('world')

14. if/unless
unless false
  p 'ok'
end

a = 1 if a!=1           # if a!=1 => a=1 ,少了一个end
b = 2 unless define?(b) # if undefine b => b =2

15. ruby没有++，--操作

16.变量类型
local variables : a = 1 ,b = "hello"
constants : Name = [ "join" ]
global variables :$platform = "mac"
instance variables : @name = "232"
class variables :@@counter = 20

def hello
  puts $$ #=> process id
  puts $: #-> ruby loading path
end

p Track.ancestors
=end

def process
  puts $$ #=> process id
  puts $: #-> ruby loading path
end
process

def hi name
  yield(name)
end
hi('code') { |x| p "hello #{x}"}

# def hi hello
#   p hello
# end
# hi "hi"

grp = "string".methods.grep(/case/)
puts grp

is_A = 'hello world' .is_a?(String)
gb = 'hello world'.gsub(/world/, 'lei').upcase
puts is_A, gb

=begin
10.times do |t|
  puts "hello  #{t}  times"
end
=end

# 识别变量a，也可以使用%Q.%q使用的是单引号引用规则，而%Q是双引号引用规则
a = '1234'
puts "#{a}"
puts %Q(#{a})   # 1234
puts %q(#{a})   # #{a}

# 在一个双引号括起的字符串内，转义字符会被解析。在一个单引号括起的字符串内，转义字符不会被解析，原样输出。
puts %q(I can \n。)    # I can \n。
puts %(I can \n。)     # 第一行 I can  第二行 。

:cat
puts :cat.class  # Symbol

# %r() 是写正则表达式的另一种方式。
# %q() 是写单引号字符串的另一种方式（可以是多行，这很有用）
# %Q() 给出双引号字符串
# %x() 是一个shell命令
# %i() 给出一个符号数组（Ruby> = 2.0.0）
# %s()变成foo符号（:foo）
# %w写一个用空格而不是逗号分隔且不带引号的字符串数组
puts %w[1 2 3]

array = [1, 2, 3, 4, 5] # 也可以使用 Array.new创建新数组
puts array[0] #=> 1
puts array.first #=> 1
puts array[12] #=> nil    # 数组越界不会报错
puts array[-1] #=> 5    # 从后往前取最后一个
puts array.last #=> 5

# 也可以把if放在后面进行条件判断，unless取反
warnings = ['Patronimic is missing', 'Address too short']
puts("Some warnings occurred:\n" + warnings.join("\n"))  if !warnings.empty?
puts("Some warnings occurred:\n" + warnings.join("\n"))  unless warnings.empty?

(1..5).each do |counter|
  puts "iteration #{counter}"
end

# (1..5).each { |counter|
#   puts "iteration #{counter}"
# }


# 传递一个block，# yield类似c语言函数指针
def logic
  puts '{'
  yield
  puts '}'
end
logic { puts 'Cat1 1237' }

class EnuTest
  def initialize &block
    @eb = EnuBlock.new
    yield @eb
  end
  def next
    @eb.next
  end
end

class EnuBlock
  def initialize
    @blocks = []
  end

  def << obj
    if obj.is_a? Proc
      @blocks << obj
    else
      @blocks << proc { obj }
    end
  end

  def next
    if @blocks.empty?
      raise "EOF"
    else
      @blocks.shift.call
    end
  end
end

# enu = EnuTest.new do |x|
#   x << 1
#   x << 3
#   x << proc { p 'hello'}
# end
# enu.next
# enu.next
#enu.next

class Eval
end
Eval.class_eval do
  def class_function
    p 'class_function'
  end
  def self.hi
    p 'hi'
  end
end
Eval.instance_eval do
  def instance_function
    p 'instance_function'
  end
  def self.hello
    p 'hello'
  end
end

def testEval
  Eval.new.class_function
  Eval.hi
  Eval.instance_function
  Eval.hello
end

module BM
  def self.include base
    p 'include ...' + base
    base.class_eval do
      set_logger :hi
    end
  end
  def hi
    p 'hi'
  end
end

class BMTest
  def self.set_logger method_name
    p "logger"
  end
  include BM
end

obj = BMTest.new
obj.hi
BMTest.set_logger "test"

#require 'active_support/concern'

module ActsAsField
  # extend ActiveSupport::Concern
  # included do
  #   @@acts_as_fields = []
  # end
  #
  def self.included base
    base.include InstanceMethods
    base.extend ClassMethods
    base.class_eval do
      @@acts_as_fields = []
    end
  end

  # class_methods do
  module ClassMethods
    def field name, path
      result = class_variable_get(:@@acts_as_fields)
      result << name.to_sym
      class_variable_set(:@@acts_as_fields, result)

      define_method(name) do
        case path
        when String
          path.split(".").inject(self.latest_data) {
            |data, key| data[key]
          }
        when Proc
          path.call(self)
        end
      end
    end
  end

  module InstanceMethods #
    def acts_as_fields
      self.class.class_variable_get :@@acts_as_fields
    end
  end
end

class Device
  include ActsAsField

  field :device_type, "device_type"
  field :battery, "data.battery"
  field :node_info, "data.node_info"

  field :battery_to_text, proc { |device|
    "#{device.battery}%"
  }

  def latest_data
    {
      "data" => {
        "node_info" => "this is a sensor",
        "battery" => 90
      },
      "device_type" => "Sensor"
    }
  end

end

d = Device.new
p d.node_info
# p d.battery_to_text
# p d.acts_as_fields

module RHCConcern
  def append_features base
    super
    base.instance_eval(&@_class_methods)
    base.class_eval(&@_class_eval)
  end

  def included base = nil, &block
    super
    @_class_eval = block
  end

  def class_methods &block
    @_class_methods = block
  end
end

module ActsAsField
  extend EggConcern
  included do
    @@acts_as_fields = []
  end

  class_methods do
    def field name, path
      result = class_variable_get(:@@acts_as_fields)
      result << name.to_sym
      class_variable_set(:@@acts_as_fields, result)

      define_method(name) do
        case path
        when String
          path.split(".").inject(self.latest_data) { |data, key| data[key] }
        when Proc
          path.call(self)
        end
      end
    end
  end

  def acts_as_fields
    self.class.class_variable_get :@@acts_as_fields
  end

end

class Device
  include ActsAsField

  field :device_type, "device_type"
  field :battery, "data.battery"
  field :node_info, "data.node_info"

  field :battery_to_text, proc { |device|
    "#{device.battery}%"
  }

  def latest_data
    {
      "data" => {
        "node_info" => "this is a sensor",
        "battery" => 90
      },
      "device_type" => "Sensor"
    }
  end

end

d = Device.new
p d.node_info
p d.battery_to_text
p d.acts_as_fields