wechat-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49c382d50e750b4bb75413972a7f8ddc74a372a1
+  data.tar.gz: ce7ac829af66603e79aee9ae127eec3e077f8e0f
+SHA512:
+  metadata.gz: 4a67f307848a3bb0fa57737fd50c136a987dbc9234f84b8a389163c1662e6fdb49b179b7e2bab4ef57f92e94e068404e7b166cb9a58a433cacc7b36990f4989a
+  data.tar.gz: b32b63a48c6cd730c0ebc590945dc38ef886b502459eb3aabf723ca844343740de9b8df80e5907d21533964a4db49436cd35b42e7a88bc556839b812c16512ba

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 skinnyworm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,5 @@
+Wechat Rails
+======================
+
+[![Build Status](https://travis-ci.org/skinnyworm/omniauth-wechat-oauth2.svg)](https://travis-ci.org/skinnyworm/wechat-rails) [![Code Climate](https://codeclimate.com/github/skinnyworm/wechat-rails.png)](https://codeclimate.com/github/skinnyworm/wechat-rails) [![Code Coverage](https://codeclimate.com/github/skinnyworm/wechat-rails/coverage.png)](https://codeclimate.com/github/skinnyworm/wechat-rails)
+

data/Rakefile

@@ -0,0 +1,31 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WechatRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+require File.join('bundler', 'gem_tasks')
+require File.join('rspec', 'core', 'rake_task')
+RSpec::Core::RakeTask.new(:spec)
+
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec

data/bin/wechat

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'thor'
+require "wechat-rails"
+require 'json'  
+require "active_support/core_ext"
+require 'fileutils'
+
+
+
+class App < Thor                                                 
+  class Helper
+    def self.with(options)
+      appid =  ENV["WECHAT_APPID"]
+      secret = ENV["WECHAT_SECRET"]
+      token_file = options[:toke_file] ||  ENV["WECHAT_ACCESS_TOKEN"]
+
+      if (appid.nil? || secret.nil? || token_file.nil?)
+      puts <<-HELP
+You need set wechat appid and secret in environment variables.
+
+  export WECHAT_APPID=<appid>
+  export WECHAT_SECRET=<secret>
+  export WECHAT_ACCESS_TOKEN=<file location for storing access token>
+
+HELP
+      exit 1
+      end
+      Wechat::Api.new(appid, secret, token_file)
+    end
+  end
+
+  package_name "Wechat"
+  option :toke_file, :aliases=>"-t", :desc => "File to store access token"
+
+  desc "users", "关注者列表"
+  def users
+    puts Helper.with(options).users
+  end
+
+  desc "user [OPEN_ID]", "查找关注者"
+  def user(open_id)
+    puts Helper.with(options).user(open_id)
+  end
+
+  desc "menu", "当前菜单"
+  def menu
+    puts Helper.with(options).menu
+  end
+
+  desc "menu_delete", "删除菜单"
+  def menu_delete
+    puts "Menu deleted" if Helper.with(options).menu_delete
+  end
+
+  desc "menu_create [MENU_YAML]", "删除菜单"
+  def menu_create(menu_yaml)
+    menu = YAML.load(File.new(menu_yaml).read)
+    puts "Menu created" if Helper.with(options).menu_create(menu)
+  end
+
+  desc "media [MEDIA_ID, PATH]", "媒体下载"
+  def media(media_id, path)
+    tmp_file = Helper.with(options).media(media_id)
+    FileUtils.mv(tmp_file.path, path)
+    puts "File downloaded"
+  end
+
+  desc "media_create [MEDIA_ID, PATH]", "媒体上传"
+  def media_create(type, path)
+    file = File.new(path)
+    puts Helper.with(options).media_create(type, file)
+  end
+  
+  desc "custom_text [OPENID, TEXT_MESSAGE]", "发送文字客服消息"
+  def custom_text openid, text_message
+    puts Helper.with(options).custom_message_send Wechat::Message.to(openid).text(text_message)
+  end
+
+  desc "custom_image [OPENID, IMAGE_PATH]", "发送图片客服消息"
+  def custom_image openid, image_path
+    file = File.new(image_path)
+    api = Helper.with(options)
+
+    media_id = api.media_create("image", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).image(media_id)
+  end
+
+  desc "custom_voice [OPENID, VOICE_PATH]", "发送语音客服消息"
+  def custom_voice openid, voice_path
+    file = File.new(voice_path)
+    api = Helper.with(options)
+
+    media_id = api.media_create("voice", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).voice(media_id)
+  end
+
+  desc "custom_video [OPENID, VIDEO_PATH]", "发送视频客服消息"
+  method_option :title, :aliases => "-h", :desc => "视频标题"
+  method_option :description, :aliases => "-d", :desc => "视频描述"
+  def custom_video openid, video_path
+    file = File.new(video_path)
+    api = Helper.with(options)
+
+    api_opts = options.slice(:title, :description)
+    media_id = api.media_create("video", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).video(media_id, api_opts)
+  end
+
+  desc "custom_music [OPENID, THUMBNAIL_PATH, MUSIC_URL]", "发送音乐客服消息"
+  method_option :title, :aliases => "-h", :desc => "音乐标题"
+  method_option :description, :aliases => "-d", :desc => "音乐描述"
+  method_option :HQ_music_url, :aliases => "-u", :desc => "高质量音乐URL链接"
+  def custom_music openid, thumbnail_path, music_url
+    file = File.new(thumbnail_path)
+    api = Helper.with(options)
+
+    api_opts = options.slice(:title, :description, :HQ_music_url)
+    thumb_media_id = api.media_create("thumb", file)["thumb_media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).music(thumb_media_id, music_url, api_opts)
+  end
+
+  desc "custom_news [OPENID, NEWS_YAML_FILE]", "发送图文客服消息"
+  def custom_news openid, news_yaml
+    articles = YAML.load(File.new(news_yaml).read)
+    puts Helper.with(options).custom_message_send Wechat::Message.to(openid).news(articles["articles"])
+  end
+
+end
+
+App.start

data/lib/wechat-rails.rb

@@ -0,0 +1,39 @@
+require "wechat/api"
+
+module Wechat
+  autoload :Message, "wechat/message"
+  autoload :Responder, "wechat/responder"
+  autoload :Response, "wechat/response"
+
+  class AccessTokenExpiredError < StandardError; end
+  class ResponseError < StandardError
+    attr_reader :error_code
+    def initialize(errcode, errmsg)
+      error_code = errcode
+      super "#{errmsg}(#{error_code})"
+    end
+  end
+
+  attr_reader :config
+
+  def self.config
+    @config ||= OpenStruct.new(
+      app_id: ENV["WECHAT_APPID"],
+      secret: ENV["WECHAT_SECRET"],
+      token: ENV["WECHAT_TOKEN"],
+      access_token: ENV["WECHAT_ACCESS_TOKEN"]
+    )
+  end
+
+  def self.api
+    @api ||= Wechat::Api.new(self.config.app_id, self.config.secret, self.config.access_token)
+  end
+end
+
+if defined? ActionController::Base
+  class ActionController::Base
+    def self.wechat_rails
+      self.send(:include, Wechat::Responder)
+    end
+  end
+end

data/lib/wechat/access_token.rb

@@ -0,0 +1,35 @@
+module Wechat
+  class AccessToken
+    attr_reader :client, :appid, :secret, :token_file, :token_data
+
+    def initialize(client, appid, secret, token_file)
+      @appid = appid
+      @secret = secret
+      @client = client
+      @token_file = token_file
+    end
+
+    def token
+      begin
+        @token_data ||= JSON.parse(File.read(token_file))
+      rescue
+        self.refresh
+      end
+      return valid_token(@token_data)
+    end
+
+    def refresh
+      data = client.get("token", params:{grant_type: "client_credential", appid: appid, secret: secret})
+      File.open(token_file, 'w'){|f| f.write(data.to_s)} if valid_token(data)
+      return @token_data = data
+    end
+
+    private 
+    def valid_token token_data
+      access_token = token_data["access_token"]
+      raise "Response didn't have access_token" if  access_token.blank?
+      return access_token
+    end
+
+  end
+end

data/lib/wechat/api.rb

@@ -0,0 +1,68 @@
+require 'wechat/client'
+require 'wechat/access_token'
+
+class Wechat::Api
+  attr_reader :app_id, :secret, :access_token, :client
+
+  API_BASE = "https://api.weixin.qq.com/cgi-bin/"
+  FILE_BASE = "http://file.api.weixin.qq.com/cgi-bin/"
+
+  def initialize app_id, secret, token_file
+    @client = Wechat::Client.new(API_BASE)
+    @access_token = Wechat::AccessToken.new(@client, app_id, secret, token_file)
+  end
+
+  def users
+    get("user/get")
+  end
+
+  def user openid
+    get("user/info", params:{openid: openid})
+  end
+
+  def menu
+    get("menu/get")
+  end
+
+  def menu_delete
+    get("menu/delete")
+  end
+
+  def menu_create menu
+    # 微信不接受7bit escaped json(eg \uxxxx), 中文必须UTF-8编码, 这可能是个安全漏洞
+    post("menu/create", JSON.generate(menu))
+  end
+
+  def media media_id
+    response = get "media/get", params:{media_id: media_id}, base: FILE_BASE, as: :file
+  end
+
+  def media_create type, file
+    post "media/upload", {upload:{media: file}}, params:{type: type}, base: FILE_BASE
+  end
+
+  def custom_message_send message
+    post "message/custom/send", message.to_json, content_type: :json
+  end
+  
+
+  protected
+  def get path, headers={}
+    with_access_token(headers[:params]){|params| client.get path, headers.merge(params: params)}
+  end
+
+  def post path, payload, headers = {}
+    with_access_token(headers[:params]){|params| client.post path, payload, headers.merge(params: params)}
+  end
+
+  def with_access_token params={}, tries=2
+    begin
+      params ||= {}
+      yield(params.merge(access_token: access_token.token))
+    rescue Wechat::AccessTokenExpiredError => ex
+      access_token.refresh
+      retry unless (tries -= 1).zero?
+    end 
+  end
+
+end

data/lib/wechat/client.rb

@@ -0,0 +1,74 @@
+require 'rest_client'
+
+module Wechat
+  class Client
+
+    attr_reader :base
+
+    def initialize(base)
+      @base = base
+    end
+
+    def get path, header={}
+      request(path, header) do |url, header|
+        RestClient.get(url, header)
+      end
+    end
+
+    def post path, payload, header = {}
+      request(path, header) do |url, header|
+        RestClient.post(url, payload, header)
+      end
+    end
+
+    def request path, header={}, &block
+      url = "#{header.delete(:base) || self.base}#{path}"
+      as = header.delete(:as)
+      header.merge!(:accept => :json)
+      response = yield(url, header)
+
+      raise "Request not OK, response code #{response.code}" if response.code != 200
+      parse_response(response, as || :json) do |parse_as, data|
+        break data unless (parse_as == :json && data["errcode"].present?)
+
+        case data["errcode"]
+        when 0 # for request didn't expect results
+          true
+
+        when 42001, 40014 #42001: access_token超时, 40014:不合法的access_token
+          raise AccessTokenExpiredError
+          
+        else
+          raise ResponseError.new(data['errcode'], data['errmsg'])
+        end
+      end
+    end
+
+    private
+    def parse_response response, as
+      content_type = response.headers[:content_type] 
+      parse_as = {
+        /^application\/json/ => :json,
+        /^image\/.*/ => :file
+      }.inject([]){|memo, match| memo<<match[1] if content_type =~ match[0]; memo}.first || as || :text
+
+      case parse_as
+      when :file
+        file = Tempfile.new("tmp")
+        file.binmode
+        file.write(response.body)
+        file.close
+        data = file
+
+      when :json
+        data = JSON.parse(response.body)
+
+      else
+        data = response.body
+      end
+
+      return yield(parse_as, data)
+    end
+
+  end
+end

data/lib/wechat/message.rb

@@ -0,0 +1,163 @@
+module Wechat
+  class Message
+
+    JSON_KEY_MAP = {
+      "ToUserName" => "touser",
+      "MediaId" => "media_id",
+      "ThumbMediaId" => "thumb_media_id"
+    }
+
+    class << self
+      def from_hash message_hash
+        self.new(message_hash)
+      end
+
+      def to to_user
+        self.new(:ToUserName=>to_user, :CreateTime=>Time.now.to_i)
+      end
+    end
+
+    class ArticleBuilder
+      attr_reader :items
+      delegate :count, to: :items
+      def initialize 
+        @items=Array.new
+      end
+
+      def item title: "title", description: nil, pic_url: nil, url: nil
+        items << {:Title=> title, :Description=> description, :PicUrl=> pic_url, :Url=> url}
+      end
+    end
+
+    attr_reader :message_hash
+
+    def initialize(message_hash)
+      @message_hash = message_hash || {}
+    end
+
+    def [](key)
+      message_hash[key]
+    end
+
+    def reply
+      Message.new(
+        :ToUserName=>message_hash[:FromUserName], 
+        :FromUserName=>message_hash[:ToUserName], 
+        :CreateTime=>Time.now.to_i
+      )
+    end
+
+    def as type
+      case type
+      when :text
+        message_hash[:Content]
+
+      when :image, :voice, :video
+        Wechat.api.media(message_hash[:MediaId])
+
+      when :location
+        message_hash.slice(:Location_X, :Location_Y, :Scale, :Label).inject({}){|results, value| 
+          results[value[0].to_s.underscore.to_sym] = value[1]; results}
+      else
+        raise "Don't know how to parse message as #{type}"
+      end
+    end
+
+    def to openid
+      update(:ToUserName=>openid)
+    end
+
+    def text content
+      update(:MsgType=>"text", :Content=>content)
+    end
+
+    def image media_id
+      update(:MsgType=>"image", :Image=>{:MediaId=>media_id})
+    end
+
+    def voice media_id
+      update(:MsgType=>"voice", :Voice=>{:MediaId=>media_id})
+    end
+
+    def video media_id, opts={}
+      video_fields = camelize_hash_keys(opts.slice(:title, :description).merge(media_id: media_id))
+      update(:MsgType=>"video", :Video=>video_fields)
+    end
+
+    def music thumb_media_id, music_url, opts={}
+      music_fields = camelize_hash_keys(opts.slice(:title, :description, :HQ_music_url).merge(music_url: music_url, thumb_media_id: thumb_media_id))
+      update(:MsgType=>"music", :Music=>music_fields)
+    end
+
+    def news collection, &block
+      if block_given?
+        article = ArticleBuilder.new
+        collection.each{|item| yield(article, item)}
+        items = article.items
+      else
+        items = collection.collect do |item| 
+         camelize_hash_keys(item.symbolize_keys.slice(:title, :description, :pic_url, :url))
+        end
+      end
+
+      update(:MsgType=>"news", :ArticleCount=> items.count, 
+        :Articles=> items.collect{|item| camelize_hash_keys(item)})
+    end
+
+    def to_xml
+      message_hash.to_xml(root: "xml", children: "item", skip_instruct: true, skip_types: true)
+    end
+
+    def to_json
+      json_hash = deep_recursive(message_hash) do |key, value|
+        key = key.to_s
+        [(JSON_KEY_MAP[key] || key.downcase), value]
+      end
+
+      json_hash.slice!("touser", "msgtype", "content", "image", "voice", "video", "music", "news", "articles").to_hash
+      case json_hash["msgtype"]
+      when "text"
+        json_hash["text"] = {"content" => json_hash.delete("content")}
+      when "news"
+        json_hash["news"] = {"articles" => json_hash.delete("articles")}
+      end
+      JSON.generate(json_hash)
+    end
+
+    def save_to! model_class
+      model = model_class.new(underscore_hash_keys(message_hash))
+      model.save!
+      return self
+    end
+
+    private
+    def camelize_hash_keys hash
+      deep_recursive(hash){|key, value| [key.to_s.camelize.to_sym, value]} 
+    end
+
+    def underscore_hash_keys hash
+      deep_recursive(hash){|key, value| [key.to_s.underscore.to_sym, value]} 
+    end
+
+    def update fields={}
+      message_hash.merge!(fields)
+      return self
+    end
+
+    def deep_recursive hash, &block
+      hash.inject({}) do |memo, val|
+        key,value = *val
+        case value.class.name
+        when "Hash"
+          value = deep_recursive(value, &block)
+        when "Array"
+          value = value.collect{|item| item.is_a?(Hash) ? deep_recursive(item, &block) : item}
+        end
+
+        key,value = yield(key, value)
+        memo.merge!(key => value)
+      end
+    end
+
+  end
+end

data/lib/wechat/responder.rb

@@ -0,0 +1,98 @@
+module Wechat
+  module Responder
+    extend ActiveSupport::Concern
+
+    included do 
+      self.skip_before_filter :verify_authenticity_token
+      self.before_filter :verify_signature, only: [:show, :create]
+    end
+
+    module ClassMethods
+
+      def on message_type, with: nil, respond: nil, &block
+        raise "Unknow message type" unless message_type.in? [:text, :image, :voice, :video, :location, :link, :event, :fallback]
+        config=respond.nil? ? {} : {:respond=>respond}
+        config.merge!(:proc=>block) if block_given?
+
+        if (with.present? && !message_type.in?([:text, :event]))
+          raise "Only text and event message can take :with parameters"
+        else
+          config.merge!(:with=>with) if with.present?
+        end
+
+        responders(message_type) << config
+        return config
+      end
+
+      def responders type
+        @responders ||= Hash.new
+        @responders[type] ||= Array.new
+      end
+
+      def responder_for message, &block
+        message_type = message[:MsgType].to_sym
+        responders = responders(message_type)
+
+        case message_type
+        when :text
+          yield(* match_responders(responders, message[:Content]))
+
+        when :event
+          yield(* match_responders(responders, message[:Event]))
+
+        else
+          yield(responders.first)
+        end
+      end
+
+      private 
+
+      def match_responders responders, value
+        matched = responders.inject({scoped:nil, general:nil}) do |matched, responder|
+          condition = responder[:with]
+
+          if condition.nil?
+            matched[:general] ||= [responder, value]
+            next matched
+          end
+          
+          if condition.is_a? Regexp
+            matched[:scoped] ||= [responder] + $~.captures if(value =~ condition)
+          else
+            matched[:scoped] ||= [responder, value] if(value == condition)
+          end
+          matched
+        end
+        return matched[:scoped] || matched[:general] 
+      end
+    end
+
+    
+    def show
+      render :text => params[:echostr]
+    end
+
+    def create
+      request = Wechat::Message.from_hash(params[:xml])
+      response = self.class.responder_for(request) do |responder, *args|
+        responder ||= self.class.responders(:fallback).first
+
+        next if responder.nil?
+        next request.reply.text responder[:respond] if (responder[:respond])
+        next responder[:proc].call(*args.unshift(request)) if (responder[:proc])
+      end
+
+      if response.respond_to? :to_xml
+        render xml: response.to_xml
+      else
+        render :nothing => true, :status => 200, :content_type => 'text/html'
+      end
+    end
+
+    private
+    def verify_signature
+      array = [Wechat.config.token, params[:timestamp], params[:nonce]].compact.sort
+      render :text => "Forbidden", :status => 403 if params[:signature] != Digest::SHA1.hexdigest(array.join)
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: wechat-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Skinnyworm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+description: API and message handling for wechat in rails environment
+email: askinnyworm@gmail.com
+executables:
+- wechat
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/wechat
+- lib/wechat-rails.rb
+- lib/wechat/access_token.rb
+- lib/wechat/api.rb
+- lib/wechat/client.rb
+- lib/wechat/message.rb
+- lib/wechat/responder.rb
+homepage: https://github.com/skinnyworm/wechat-rails
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: DSL for wechat message handling and api
+test_files: []