git stash [save [--patch] [-k|--[no-]keep-index] [-q|--quiet] [<message>]]
git stash ( pop | apply ) [--index] [-q|--quiet] [<stash>]
git stash list [<options>]
git stash clear
git stash show [<stash>]
git stash drop [-q|--quiet] [<stash>]
git stash branch <branchname> [<stash>]

准备说一说我是如何把开发环境理顺的。

首先是Maven Pax Plugin，如他项目主页介绍的，这款插件是OSGi的瑞士军刀，提供了创建，构建，管理，部署多种类型的OSGi bundle。它提供了一些脚本可供调用，也可以在maven命令行直接使用，这个比较赞。默认使用的是Felix的OSGi实现。

然后学习OSGi最好是找篇教程，Felix提供的这个教程貌似不错，我就准备照这个走一遍看看。

第一个例子是ServiceEventListener，例子不错但是教程本身没说如何创建此工程，我参考了maven-pax-plugin的usage页，用到两个命令mvn org.ops4j:maven-pax-plugin:create-project和mvn pax:create-bundle，然后用mvn eclipse:eclipse创建eclipse工程文件。

命令如下：

>mvn org.ops4j:maven-pax-plugin:create-project "-DgroupId=my.example" "-DartifactId=project"
>cd project
>mvn pax:create-bundle "-DbundleName=simple-api" "-Dpackage=org.example.simple" "-Dinternals=false"
>mvn pax:create-bundle "-DbundleName=simple-impl" "-Dpackage=org.example.simple" "-Dinterface=false"
>cd simple-api
>mvn eclipse:eclipse
>cd ../simple-impl
>mvn eclipse:eclipse

然后我就把这两个工程simple-api和simple-impl导入到了eclipse，首先发现两个问题

1. 这两个工程都不是Maven工程，而且项目依赖不正确
2. 这两个项目的pom文件都是红的，提示compile和testCompile相关的错

那我是怎么手工修这两个问题的呢？

1. right click project -> config -> Convert to maven project
首先将这两个工程转换成Mavn工程
然后，打开.classpath文件，将两个osgiR4的jar包依赖替换成这个

<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"/>;

2. 打开pom文件，用提示的quickFix修改掉这两个编译的问题，这时候pom文件里会多出这么一段

<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
  			<plugin>
  				<groupId>org.eclipse.m2e</groupId>
  				<artifactId>lifecycle-mapping</artifactId>
  				<version>1.0.0</version>
  				<configuration>
  					<lifecycleMappingMetadata>
  						<pluginExecutions>
  							<pluginExecution>
  								<pluginExecutionFilter>
  									<groupId>org.ops4j</groupId>
  									<artifactId>
  										maven-pax-plugin
  									</artifactId>
  									<versionRange>
  										[1.5,)
  									</versionRange>
  									<goals>
  										<goal>testCompile</goal>
  										<goal>compile</goal>
  									</goals>
  								</pluginExecutionFilter>
  								<action>
  									<ignore></ignore>
  								</action>
  							</pluginExecution>
  						</pluginExecutions>
  					</lifecycleMappingMetadata>
  				</configuration>
  			</plugin>

3. 这时候还需要right click project -> Maven -> update project configuration

这时候，环境问题基本就OK了，照着例子敲好代码，然后mvn clean install pax:provision就OK了

g! lb
START LEVEL 6
ID|State |Level|Name
0|Active | 0|System Bundle (4.0.2)
1|Active | 5|my.example.project.simple-api [org.example.simple] (1.0.1.SNAPSHOT)
2|Active | 5|my.example.project.simple-impl [org.example.simple] (1.0.1.SNAPSHOT)
3|Active | 1|Apache Felix Gogo Command (0.12.0)
4|Active | 1|Apache Felix Gogo Runtime (0.10.0)
5|Active | 1|Apache Felix Gogo Shell (0.10.0)

Note: 另外编译的时候发现版本问题，在顶级pom里加上这么一段解决了，还不知道本质原因

<plugin><!-- Compile -->
		        <groupId>org.apache.maven.plugins</groupId>
		        <artifactId>maven-compiler-plugin</artifactId>
		        <configuration>
		          <source>1.6</source>
		          <target>1.6</target>
		        </configuration>
		        <executions>
		          <execution>
		            <id>compile-for-this-application</id>
		            <goals>
		              <goal>compile</goal>
		            </goals>
		          </execution>
		        </executions>
	      </plugin>

测试过程中发现新浪微博开放平台oauth2的两个问题
1. access_token response 不够标准，它返回的 “content-type”=>”text/plain;charset=UTF-8″, 其实返回值是json格式，如果http头返回”application/json” 就更好了，省得开发人员手工处理。

2. OAuth授权后获得access_token，后续验证用户信息调用account/get_uid，微博API要求请求参数里必须填写access_token，这里比较难说是谁的问题，但是比较来说github instagram和oauth2 gem的默认行为都兼容，唯独新浪微博需要手工设置query参数，对程序员的易用性兼顾不够。

My solution & it worked:

sudo mv /Applications/FaceTime.app ~/Downloads/
sudo mv ~/Downloads/FaceTime.app /Applications/

功能一个注册登陆系统，登陆完成之后，点击新浪图标，oauth连接/授权/关联新浪微薄账号，取得用户的相关微薄数据，上一张完成之后的页面截图就清楚些了。

步骤如下

1. 使用devise实现注册登陆功能
2. 使用omniauth实现新浪微薄的oauth认证
1. 配置omniauth
2. 完成新浪微薄oauth，保存access_token, access_token_secret到数据库
3. 使用之前存下来的access_token, access_token_secret调用新浪API取所需要的数据

OK，下面是从创建这个rails app开始的完整步骤

首先是1.使用devise实现注册登陆功能

>rails new authentication
>cd authentication

修改Gemfile
     gem 'devise'
     gem 'omniauth'
     gem 'json'

>bundle install
>rails g controller home index
>rails g devise:install
>rails generate devise User
>rake db:migrate

修改config/routes.rb
    root :to => "home#index"
修改app/views/home/index.html.erb，显示注册、登陆、退出等URL
    <% if user_signed_in? -%> <!-- Provided by devise -->
	<div style="float:right">
	  <%= current_user.email %> |
	  <%= link_to '用户信息', edit_user_registration_path %> |
	  <%= link_to '退出登录', destroy_user_session_path, :method => :delete %> |
	</div>
    <% end -%>
    <% unless user_signed_in? -%>
	<div style="float:right">
	  <%= link_to '注册', new_user_registration_path %> |
	  <%= link_to '登录', new_user_session_path %>
	</div>
    <% end -%>

>rails s

devise真的很好用，这步骤做完之后，基本的注册登陆功能已经完备，可以访问http://localhost:3000 验证一下

接下来2.使用omniauth实现新浪微薄的oauth认证
A. 配置omniauth

修改config/application.rb
    require 'oa-oauth'
    config.middleware.use OmniAuth::Strategies::Tsina, 'APP_KEY', 'APP_SECRET'
    #可以加多个Provider，如果还需要连接其他认证

B. 完成新浪微薄oauth，保存access_token, access_token_secret到数据库
使用omniauth是如此简单，你只需要加上这个link（/auth/:provider）就行了，这里的provider是tsina

修改app/views/home/index.html.erb，增加一行
<div style="float:right">
 <%= current_user.email %> |
 <%= link_to '用户信息', edit_user_registration_path %> |
 <%= link_to '退出登录', destroy_user_session_path, :method => :delete %> |
 <%= link_to image_tag("tsina_24_24.png"), '/auth/tsina', :title=> "连接新浪微薄" %>
</div>

OK，用户登陆完就能看到这个链接了，点一下试试看，首先是一个授权app的页面，这时候输入新浪微博的用户密码，确认授权，然后不出意外你看到的是这个效果

我们再来回顾一下oAuth的流程，这个是新浪提供的一个流程图，我们正处于重定向到Callback_url这个阶段，而我们应用还没有定义回调的url

OK，下一步就是定义我们的callback_url

>rails g controller authorization oauth_create oauth_destroy

修改config/routes.rb
  get "authorization/oauth_create" #上个命令自动生成
  get "authorization/oauth_destroy" #同上
  match "/auth/:provider/callback" => "authorization#oauth_create" #定义callback_url

先看看oAuth成功没有，code可以简单点

app/controllers/authorization_controller.rb
class AuthorizationController < ApplicationController
  def oauth_create
    auth = request.env["omniauth.auth"]
    render :text=>auth.to_yaml
  end
end

再次点击新浪图标，我们能看到一堆文本信息，包括token，secret等等，说明oAuth已经成功了。

C. 使用之前存下来的access_token, access_token_secret调用新浪API取所需要的数据
现在我们需要的数据都能取到了，然后思考一个问题，貌似我们应该把这个授权信息存下来，然后就不需要每次用户都授权一下才能取API数据。
建立下面这个authorization model存授权信息

>rails g model authorization provider:string uid:string user_id:integer access_token:string access_token_secret:string

app/models/user.rb
class User < ActiveRecord::Base
  has_many :authorizations do
     def find_or_create_by_params(params) #辅助方法，别着急，一会儿就看到怎么用的了
          provider,uid = params[:provider],params[:uid]
          access_token,access_token_secret = params[:access_token],params[:access_token_secret]

          authorization = find_or_create_by_provider_and_uid(provider,uid)
          authorization.update_attributes(params.except(:provider,:uid))
     end
  end

  #... devise stuff
end

app/models/authorization.rb
class Authorization < ActiveRecord::Base
     belongs_to :user

     validates :user_id, :uid, :provider, :presence => true
     validates :uid, :uniqueness => { :scope => :provider }
end

OK,回到回调方法里，我们要把有用的数据存到model里进而持久化

app/controllers/authorization_controller.rb
class AuthorizationController < ApplicationController
  def oauth_create
    auth = request.env["omniauth.auth"]
    user = current_user
    user.authorizations.find_or_create_by_params({ #这里调用辅助方法
	:provider => auth["provider"],
	:uid => auth["uid"],
	:access_token => auth['credentials']['token'],
	:access_token_secret => auth['credentials']['secret']
    })
    flash[:notice] = "#{auth['provider']} user #{auth['uid']} successfully authenticated"
    redirect_to root_url
end

然后我们希望每次用户刷新首页的时候，我们去取一下他授权微薄的最新信息（home#index是我们的root_url还记得不）

class HomeController < ApplicationController
  def index
	oauth_retrive
  end

private
	require 'json'
	def oauth_retrive
		user = current_user
		if not user.blank?
			authorization = user.authorizations.first
			if not authorization.blank?
				access_token = authorization.access_token
				access_token_secret = authorization.access_token_secret

				consumer = OAuth::Consumer.new('APP_KEY','APP_SECRET',{:site =>'http://api.t.sina.com.cn'})
				accesstoken = OAuth::AccessToken.new(consumer, access_token, access_token_secret)
				response = accesstoken.get("http://api.t.sina.com.cn/account/verify_credentials.json")
				@weibo_user = JSON.parse(response.body)
			end
		end
	end
end

修改app/views/home/index.html.erb，增加读取weibo_user的信息
<% if user_signed_in? -%> <!-- Provided by devise -->
	<div style="float:right">
	  <%= current_user.email %> |
	  <%= link_to '用户信息', edit_user_registration_path %> |
	  <%= link_to '退出登录', destroy_user_session_path, :method => :delete %> |
	  <%= link_to image_tag("tsina_24_24.png"), '/auth/tsina', :title=> "连接新浪微薄" %>
	</div>
	<% if @weibo_user %>
	<div style="clear:both"></div>
	<div style="float:right">
		<p>已连接新浪微薄:<p/>
		<%= link_to image_tag(@weibo_user['profile_image_url']), "http://weibo.com/#{@weibo_user['id']}" %>
		<%= link_to @weibo_user['screen_name'], "http://weibo.com/#{@weibo_user['id']}" %>
		关注:<%= @weibo_user['followers_count'] %>
		粉丝:<%= @weibo_user['friends_count'] %>
		微薄:<%= @weibo_user['statuses_count'] %>
		收藏:<%= @weibo_user['favourites_count'] %>
	</div>
	<% end -%>
<% end -%>

按照这个步骤，就能成功看到最终成果了。

Notes:上文所用的环境如下,完整代码可以在这找到https://github.com/jihao/rails_apps_for_fun/tree/master/authentication

Rails 3.0.9
ruby 1.8.7 (2011-02-18 patchlevel 334) [i386-mingw32]
builder (2.1.2)
devise (1.4.2)
omniauth (0.2.6)

这个过程中找到的较好的参考文档/资源

1. https://github.com/plataformatec/devise
2. http://oauth.rubyforge.org/
3. https://github.com/intridea/omniauth

这个问题的root cause应该是种子文件被修改，只能特定BT下载客户端才能识别了，八成是为了抵制吸血迅雷，这个时候大家一定都是想，要是能用吸血迅雷打开这个种子该多好啊！

好吧！Hold住！免费传授大家这招，在BitComet的你正在下载的这个任务上，右键->复制磁链，然后到迅雷里新建任务->粘贴，是不是成功了？速度也有了！

也许可以写个脚本生成Magnet URI？今天就不研究了。

也就我git clone repository到本地后，发现link3有我想要的代码，我要把link3上的改动merge到我的repository上，避免我花精力改相同的bug

git如何merge github forked repository里的更新?
具体做法是下面三步，以前没用git这么搞过，知道之后其实蛮简单
1. >git remote add geoffyoungs http://github.com/geoffyoungs/ruby-gmail.git
2. >git fetch geoffyoungs
3. >git merge geoffyoungs/master

本地的repository看上去是这样的：
>git remote -v
geoffyoungs http://github.com/geoffyoungs/ruby-gmail.git (fetch)
geoffyoungs http://github.com/geoffyoungs/ruby-gmail.git (push)
origin http://jihao@github.com/jihao/ruby-gmail.git (fetch)
origin http://jihao@github.com/jihao/ruby-gmail.git (push)
>git branch -a
* master
remotes/geoffyoungs/gh-pages
remotes/geoffyoungs/master
remotes/origin/HEAD -> origin/master
remotes/origin/adimircolen-master
remotes/origin/gh-pages
remotes/origin/master


晚上折腾了一会儿，连调成功了，现在收到新邮件的时候，桌面上的arduino板子会有声有色的提醒啦，有图有真相，O(∩_∩)O哈哈~，下面分享这个小玩具是怎么搞定的。

这个玩具由两部分组成
1.PC端检查gmail邮件更新和发送串口信号的ruby脚本
2.Arduino的信号控制及串口通信程序

1.PC端检查gmail邮件更新和发送串口信号的ruby脚本
用到两个ruby gem ‘ruby-gmail’和’serialport’
前者封装了操作gmail邮件的相关功能，后者是一个跨平台的ruby串口通信库
ruby代码比较简单，就不多解释了

require 'rubygems'
require 'gmail'
require 'serialport'

$username,$password = ARGV

def init_email_count
	gmail = Gmail.new($username, $password)
	$count = gmail.inbox.count(:unread)
	puts "unread email count: #{$count}"
	gmail.logout
end

def has_new_email?
	latest = get_latest_email_count
	if latest!=$count
		$count = latest
		puts "current email count: #{$count}"
		return true
	else
		return false
	end
end

def get_latest_email_count
	print '.'
	gmail = Gmail.new($username, $password)
	latest = gmail.inbox.count(:unread)
	gmail.logout
	return latest
end

def write_serialport chr
	puts "write to serial port [#{chr}]"
	$sp.write chr
	#rd = sp.read
	#puts "read from serial port [#{rd}]"
end

init_email_count
# 0 is mapped to "COM1" on Windows, and 2 is COM3, 9600 is baud rate
# Arduino on serial port2 (COM3)
$sp = SerialPort.new(2, 9600)
loop do
	if has_new_email?
		write_serialport 'H'
		sleep 30
		write_serialport 'L'
	end
	sleep 5
end

#not closed
#$sp.close

2.Arduino的信号控制及串口通信程序
为了有声有色，混合了fade和buzzer两个功能，所以代码略多

PIN 9，是绿色LED渐明渐暗的控制，显示系统正在正常工作
PIN 10，是红色LED，当收到串口H信号的时候亮起来，指示收到新邮件
PIN 6，蜂鸣器的控制针脚

其余的应该都能看懂意思，不解释了

int brightness = 0;    // how bright the LED is
int fadeAmount = 5;    // how many points to fade the LED by
int ledPin=9;          // pin for green LED which indicates system running
int serialLedPin=10;   // pin for RED LED which indicates incoming email
int buzzerPin=6;       // pin for buzzer
int incomingByte;      // a variable to read incoming serial data into
void setup()  {
  Serial.begin(9600);
  // declare pin 9 to be an output:
  pinMode(ledPin, OUTPUT);
  pinMode(serialLedPin, OUTPUT);
  pinMode(buzzerPin,OUTPUT);//设置模拟信号IO脚模式，OUTPUT为输出
}
void beep()
{
  unsigned char i,j;//定义变量
  for(i=0;i<80;i++)//输出一个频率的声音
  {
    analogWrite(buzzerPin,i);//发声音
    delay(1);//延时1ms
    analogWrite(buzzerPin,LOW);//不发声音
    delay(1);//延时ms
  }
}
void beep5times()
{
   for(int i=0;i<5;i++)
   {
     beep();
     delay(1000);
   }
}
void checkSerialInput() {
  // see if there's incoming serial data:
  if (Serial.available() > 0) {
    // read the oldest byte in the serial buffer:
    incomingByte = Serial.read();
    Serial.write(incomingByte);
    // if it's a capital H (ASCII 72), turn on the LED:
    if (incomingByte == 'H') {
      digitalWrite(serialLedPin, HIGH);
      beep5times();
    }
    // if it's an L (ASCII 76) turn off the LED:
    if (incomingByte == 'L') {
      digitalWrite(serialLedPin, LOW);
    }
  }
}
void loop()  {
  // set the brightness of pin 9:
  analogWrite(ledPin, brightness);
  // check any input from serial in
  checkSerialInput();

  // change the brightness for next time through the loop:
  brightness = brightness + fadeAmount;

  // reverse the direction of the fading at the ends of the fade:
  if (brightness == 0 || brightness == 255) {
    fadeAmount = -fadeAmount ;
  }
  // wait for 30 milliseconds to see the dimming effect
  delay(30);
}

最后总结一下：
虽然刚刚ruby入门，但是感觉用ruby写点小东西满顺畅的，还有就是github,ruby gem神马的都很强大
然后就是arduino的开发上手也很容易

• Ruby不允许多重继承
• Ruby可以继承多个模块

#foobar_module.rb
module FooBarModule     #用module关键字来定义模块
     def say
         puts 'hi'
     end
end

#foo.rb
require "foobar_module"     #如何在不同文件中，需要使用require或者load来加载模块
class Foo
     include FooBarModule    #可以理解为，把Module的内容拷贝一份到类里
     def bar
         puts 'foobar'
     end
end
foo = Foo.new
foo.say #hi
Foo.ancestors #=> [Foo, FooBarModule, Object, Kernel]     #模块的include是一种特殊的继承
FooBarModule.respond_to? :new     #=> false 模块不能实例化
FooBarModule.respond_to? :extend  #=> true  模块可以继承模块，模块不能直接继承Object

方法调用的查找顺序

1. 对象的单态方法
2. 对象的实例方法
3. include模块中的实例方法
4. 父类中的实例方法
5. 父类include模块中的实例方法
6. 一直这样找到最上层，如果还是没有找到，Ruby会调用默认Object#method_missing，产生NoMethodError异常

class Foo
     def method1
          puts "I am instance method1"
     end
end

class Foo
     def Foo.method1
          puts "I am class method1"
     end
end

bar = Foo.new
def bar.method2
     puts "I am singleton method2"
end
bar2 = Foo.new
bar.method2    #I am singleton method2
bar2.method2   #NoMethodError: undefined method `method2' for #

bar = Foo.new
class << bar
     def method2
          puts "I am singleton method2 defined in singleton class"
     end
end
bar.method2    #I am singleton method2 defined in singleton class

class Foo
     def Foo.method1 #与单态方法的定义表达式相似"def (对象).(方法名)"
          puts "I am class method1"
     end
end

class Foo
     class << self #定义self(=Foo)的单态类，等同于 class << Foo
          def method1
              puts "I am class method1 defined in metaclass(Foo)"
          end
     end
end
Foo.method1 #I am class method1 defined in metaclass(Foo)