wechat-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61ec7a5b42fe03ce985fca363b29374a69b051d4
+  data.tar.gz: 47a37f39ef34d8435f287b89ffd656ccdb3adae8
+SHA512:
+  metadata.gz: 674382d229096c6b2a711187413cce1394cec05048882c2fbceca14ec7192a3a9950306895431e42c97e5a7cd4eb545b55d670d39c3092e02c4e4e537aae0e06
+  data.tar.gz: 43a1e9a64c2cd1363f267de614bdcd99615778eecdf3282deabb5971ce370014636fc499ad7de1e7e9bc5cbb2bf933a2d3b1a2233da7547d4be4d36811a08190

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+
+
+group :test do
+  gem 'rspec', '~> 2.13.0'
+  gem 'webmock', '~> 1.9.0'
+end
+
+
+
+# Specify your gem's dependencies in wechat-rb.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Eshaam Rabaney
+
+MIT License
+
+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,104 @@
+# wechat-rb
+
+Simple Ruby wrapper for the Wechat Admin API.
+
+
+## Installation
+
+    $ gem install wechat-rb
+
+
+## Wechat API Hint
+
+This wrapper tries to implement all available methods of the Wechat Admin API in a
+Ruby-like fashion. However, the Wechat API lacks a decent amount of methods that
+you expect an API to provide.
+Thus, if methods are missing or a certain implementation
+style was choosen it is most likely due to the inconsistency of the API itself.
+Feel free to get in touch or submit a pull request if you encounter any problems.
+
+
+Must-known facts about the Wechat API:
+
+* Wechat requires multimedia files such as images and videos to be uploaded to their servers is some cases. To help make things easier, this wrapper will upload the multimedia files on the fly for you and you can even pass external url for upload.
+* Return values differ from method to method due to the way the Wechat API is implemented.
+Thus, a Hash as a return value or an Array of Hashes was choosen as the global return object. Basically it is a parsed JSON response.
+* Please refer to the Wechat API documentation for detailed information on parameters, return values or error codes.
+
+
+## Configuration and Setup
+### Authentication
+
+Authenticate with the api credentials provided in your Wechat Admin Account.
+
+    Wechat.configure do |c|
+      c.api_appid = 'my_appid'
+      c.api_appsecret = 'my_secret'
+      # OPTIONAL, defaults to https://api.weixin.qq.com/cgi-bin
+      c.api_endpoint = 'https://api.weixin.qq.com/cgi-bin'
+    end
+
+
+## Interacting with the API
+
+You can interact with the API on the provided data objects
+
+#### Message
+
+    # Send a custom Text message
+    Wechat::Message.send({to: 'oRVIRuNafMJvn-eEwd0r9nv5HhqE'},  {text: "Hello World"})
+
+    # Send a custom Image message
+    Wechat::Message.send({to: 'oRVIRuNafMJvn-eEwd0r9nv5HhqE'},  {image: "http://example.com/image.jpg"})
+
+    # Send a custom News message
+    Wechat::Message.send({to: 'oRVIRuNafMJvn-eEwd0r9nv5HhqE'},  {news: [{title: 'My title', description: 'My descript', url: 'www.example.com', pic_url: 'http://example.com/image.jpg'}]})
+
+
+#### Broadcast
+
+    # Send a News Message  Broadcast to all Followers
+    Wechat::Broadcast.send(news: [{title: 'My title', description: 'My descript', url: 'www.example.com', pic_url: 'http://example.com/image.jpg'}])
+
+    # Send a News Message  Broadcast to select Followers
+    Wechat::Broadcast.send(news: [{title: 'My title', description: 'My descript', url: 'www.example.com', pic_url: 'http://example.com/image.jpg'}], ['oRVIRuNafMJvn-eEwd0r9nv5HhqE'])
+
+
+#### Follower
+
+    # Get list of Followers
+    Wechat::Follower.list
+
+    # Get follower profile
+    Wechat::Follower.show('oRVIRuNafMJvn-eEwd0r9nv5HhqE')
+
+
+#### Menu
+
+    # Create a Custom menu
+    Wechat::Menu.create({button: [{type: 'click',name: 'News', key: 'news_today'}]})
+
+
+
+## Todo
+* More tests :)
+* Implement Callback Messages
+* Implement Better Error Handling and Access Token
+
+## Contributing
+
+1. Fork it 
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+## Ruby Versions
+
+This gem was developed and tested with versions 2.0.0
+
+
+## Copyright
+
+Copyright (c) 2014 Eshaam Rabaney. See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/wechat.rb

@@ -0,0 +1,56 @@
+require "base64"
+require 'json'
+require 'rest_client'
+require 'uri'
+require 'open-uri'
+require "multi_xml"
+
+
+
+require "wechat/local_resource"
+require "wechat/error"
+require 'wechat/access_token'
+require 'wechat/request'
+require 'wechat/response'
+require 'wechat/data_object'
+require 'wechat/data_objects/broadcast'
+require 'wechat/data_objects/follower'
+require 'wechat/data_objects/media'
+require 'wechat/data_objects/menu'
+require 'wechat/data_objects/message'
+require 'wechat/data_objects/qrcode'
+require "wechat/version"
+
+
+
+module Wechat
+  class << self
+
+    # @!attribute api_endpoint
+    #   @return [String] Base URL for WeChat API. default: https://api.weixin.qq.com/cgi-bin
+    # @!attribute file_endpoint
+    #   @return [String] Base URL for WeChat Media API. default: http://file.api.weixin.qq.com/cgi-bin
+    # @!attribute api_appid
+    #   @return [String] Obtained in WeChat Account 
+    # @!attribute api_appsecret
+    #   @return [String] Obtained in WeChat Account 
+
+    attr_accessor :api_endpoint, :file_endpoint, :api_appid, :api_appsecret,:access_token
+
+
+
+    def api_endpoint
+      @api_endpoint ||= 'https://api.weixin.qq.com/cgi-bin'
+    end
+
+    def file_endpoint 
+      @file_endpoint ||= 'http://file.api.weixin.qq.com/cgi-bin'
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+  end
+end

data/lib/wechat/access_token.rb

@@ -0,0 +1,32 @@
+module Wechat
+  class AccessToken
+    attr_accessor :appid, :secret
+
+    def initialize
+      raise 'Wechat.api_appid not set' if Wechat.api_appid.nil?
+      raise 'Wechat.api_appsecret not set' if Wechat.api_appsecret.nil?
+
+      @appid = Wechat.api_appid
+      @secret = Wechat.api_appsecret
+      
+    end
+
+    def token
+      Wechat.access_token ||= self.refresh
+    end
+
+    def refresh
+      url = "#{Wechat.api_endpoint}/token"
+      data = RestClient.get(url, params:{grant_type: "client_credential", appid: @appid, secret: @secret})
+      return valid_token(data)
+    end
+
+    private 
+    def valid_token token_data
+      rep = JSON.parse(token_data)
+       raise "Response didn't have access_token" if  rep['access_token'].empty?
+      return rep['access_token']
+    end
+
+  end
+end

data/lib/wechat/data_object.rb

@@ -0,0 +1,53 @@
+module Wechat
+ 
+  class DataObject
+    class << self
+
+      # Make a HTTP GET request
+      #
+      # @param method_name [String] The path, relative to Wechat.api_endpoint
+      # @param params [Hash] custom params hash
+      # @return [Hash]
+      def get(method_name, params)
+
+        if params.empty?
+          self.new.request 'get', method_name, params
+        else
+          self.new.request 'get', [method_name + '?', parameterize_params(params)].join("&"), {}
+        end
+      end
+
+      # Make a HTTP POST request
+      #
+      # @param method_name [String] The path, relative to Wechat.api_endpoint
+      # @param params [Hash] custom params hash
+      # @return [Hash]
+      def post(method_name, params)
+        self.new.request 'post', method_name, params
+      end
+
+
+
+      # Custom Parameterizer for Wechat
+      #
+      # @param params [Hash] custom params hash
+      # @return [String] key => value is returned as key=value
+      def parameterize_params(params)
+        params.inject(""){|string, (k, v)| string << "#{k}=#{v}"; string << "&"; string}[0..-2]
+      end
+    end
+
+    # Make a HTTP request
+    #
+    # @param http_verb [String] Http method
+    # @param method_name [String] The path, relative to Wechat.api_endpoint
+    # @param params [Hash] custom params hash
+    # @return [Hash]
+    def request(http_verb, method_name, params)
+      response = Wechat::Request.new(http_verb, method_name, params).send_request
+      #hashiefy(response)
+    end
+
+
+  end
+end

data/lib/wechat/data_objects/broadcast.rb

@@ -0,0 +1,102 @@
+module Wechat
+
+  # Methods for the Advanced Broadcast Interface
+  # http://admin.wechat.com/wiki/index.php?title=Advanced_Broadcast_Interface
+  #
+  class Broadcast < DataObject
+    class << self
+
+      # Send a broadcast.
+      #
+      # @param message [Hash] internal id of key field
+      # @param key_value [Integer, String] value of interal id field
+      # @param params [Hash] Contact information to create
+      # @return [Hash] internal id of the contact
+      # @example
+      #   Wechat::Broadcast.send(news: articles)
+     
+
+      def send(message = {}, followers = [])
+	     	
+        to_followers = generate_send_list(followers)
+        send_message = generate_content(message)
+        b = {}
+        b.merge!(to_followers)
+        b.merge!(send_message)
+        broadcast_message = JSON.generate(b)
+        
+
+        post "message/mass/send", broadcast_message
+
+      end
+
+      #private
+      def generate_send_list(followers)
+        
+        if followers.empty?
+
+          all_followers = Wechat::Follower.list
+          send_followers = {touser: all_followers["data"]["openid"]}
+
+        else
+          send_followers = {touser: followers}
+        end
+
+
+      end
+
+      def generate_content(message)
+        type = message.keys[0]
+        body = message.values[0]
+
+        case type
+
+        when :text
+        	content = {text: {content: body},msgtype: "text"}
+       	when :audio
+       		content = {voice: {media_id: upload_media_for_broadcast('voice',body)},msgtype: "voice"}
+       	when :image
+       		content = {image: {media_id: upload_media_for_broadcast('image',body)},msgtype: "image"}
+
+        when :news
+          items = []
+
+          body.each do |article|
+
+            new_article = {
+              thumb_media_id: upload_media_for_broadcast('image',article[:picurl]),
+              title: article[:title],
+              content_source_url: article[:url],
+              content: article[:url],
+              digest: article[:description],
+            }
+
+            items << new_article
+
+          end
+
+          
+          news_upload_result = upload_news_articles_for_broadcast(items)
+
+          content = {mpnews: {media_id: news_upload_result["media_id"]},msgtype: "mpnews"}
+
+
+
+        end
+        
+      end
+
+      def upload_media_for_broadcast(type,item)
+        result = Wechat::Media.upload(type,item)
+        return result['media_id']
+      end
+
+      def upload_news_articles_for_broadcast(articles)
+        post "media/uploadnews", JSON.generate({articles: articles})
+      end
+
+
+
+    end
+  end
+end

data/lib/wechat/data_objects/follower.rb

@@ -0,0 +1,40 @@
+module Wechat
+
+  # Methods for the Followers
+
+  class Follower < DataObject
+    class << self
+
+      # Obtain list of followers 
+      # => http://admin.wechat.com/wiki/index.php?title=Follower_List
+
+
+      # @return [Hash] List of OpenIDs
+      # @example
+      #   Wechat::Follower.list
+
+
+      def list
+        get("user/get", {})
+
+      end
+
+
+      # Get a follower profile for a given OpenID 
+      # => http://admin.wechat.com/wiki/index.php?title=User_Profile
+
+      # @param openid [String] the openid of follower
+      # @return [Hash] result data
+      # @example
+      #   Wechat::Follower.show('oRVIRuBVh0Dh91HAzauOW-WiZ3g0')
+
+
+      def show(openid)
+        get("user/info", {openid: openid})
+      end
+
+
+
+    end
+  end
+end

data/lib/wechat/data_objects/media.rb

@@ -0,0 +1,49 @@
+module Wechat
+
+  # Methods for transfering media files 
+  # => http://admin.wechat.com/wiki/index.php?title=Transferring_Multimedia_Files
+  #
+  class Media < DataObject
+    class << self
+
+      # Upload files to wechat media api 
+      
+      # @param type [String] the type of media being uploaded. Either 'image','audio','video','voice'
+      # @param path [String] the relative path to a file or pass URL
+      # @return [Hash] result data
+      # @example
+      #   Wechat::Media.upload('image','/path/to/my/image.jpg')
+      #   Wechat::Media.upload('image','http://example.com/image.jpg')
+
+
+      def upload(type, path)
+
+        if path.include?'http'
+              # We create a local representation of the remote resource
+          # local_resource = LocalResource.new URI.parse(path)
+           local_resource = LocalResource.new(URI.parse(path))
+          # We have a copy of the remote file for processing
+          local_copy_of_remote_file = local_resource.file
+
+
+          path = local_copy_of_remote_file.path
+        end
+
+        file = File.new(path,'rb')
+        post "media/upload", {media: file, type: type}
+      end
+
+      # Download files from wechat media api 
+      
+      # @param media_id [String] the media_id of the file to be downloaded
+      # @return [String] path to downloaded file
+      
+      def download(media_id) 
+        get "media/get", {media_id: media_id}
+
+      end
+
+
+    end
+  end
+end

data/lib/wechat/data_objects/menu.rb

@@ -0,0 +1,49 @@
+module Wechat
+
+  # Methods for the Custom Menu API
+
+  class Menu < DataObject
+    class << self
+
+      # Get the menu currently live if one exists
+      # http://admin.wechat.com/wiki/index.php?title=Query
+
+      # @return [Hash] result data
+      # @example
+      #   Wechat::Menu.query
+
+
+      def query
+        get("menu/get", {})
+      end
+     
+
+      # Create a custom menu
+      
+      # @param menu [Hash] 
+      # @return [Hash] result data
+      # @example
+      #   Wechat::Menu.create({button: [{type: 'click',name: 'News', key: 'news_today'}]})
+
+
+      def create(menu)
+        post("menu/create", JSON.generate(menu))
+      end
+
+
+
+      # Delete the menu currently live if one exists
+      # http://admin.wechat.com/wiki/index.php?title=Delete
+
+      # @return [Hash] result data
+      # @example
+      #   Wechat::Menu.delete
+
+      def delete 
+        get("menu/delete", {})
+      end
+
+
+    end
+  end
+end

data/lib/wechat/data_objects/message.rb

@@ -0,0 +1,65 @@
+module Wechat
+
+  # Methods for the Contact API
+  #
+  #
+  class Message < DataObject
+    class << self
+      
+      attr_reader :message_hash
+
+
+      def from_hash(post_xml)
+          @message_hash = MultiXml.parse(post_xml)
+      end
+
+
+
+      def send(to='', message = {})
+        processed_message = process_message(to,message)
+        post( "message/custom/send", processed_message)
+
+      end
+
+
+      def verify_signature(token)
+        array = [token, params[:timestamp], params[:nonce]].compact.sort
+        render :text => "Forbidden", :status => 403 if params[:signature] != Digest::SHA1.hexdigest(array.join)
+      end
+
+
+
+      #private
+
+
+      def process_message(to, message)
+        @new_message = {
+          :touser=>to
+        }
+
+        type = message.keys[0]
+        body = message.values[0]
+
+        case type
+        
+        when :text
+          @new_message.merge!(:msgtype=>"text", :text=>{:content=>body})
+        when :image
+          @new_message.merge!(:msgtype=>"image", :image=>{:media_id=>body})
+        when :audio
+          @new_message.merge!(:msgtype=>"voice", :voice=>{:media_id=>body})
+        when :video
+          @new_message.merge!(:msgtype=>"video", :video=>{:media_id=>body})
+        when :news
+          @new_message.merge!(:msgtype=>"news", :news=>{:articles=>body})
+        end
+
+        
+      end
+
+
+
+
+    end
+  end
+end

data/lib/wechat/data_objects/qrcode.rb

@@ -0,0 +1,39 @@
+module Wechat
+
+  # Methods for Generating Parametric QR Code 
+  # http://admin.wechat.com/wiki/index.php?title=Generating_Parametric_QR_Code
+  
+
+  class Qrcode < DataObject
+    class << self
+
+      # Create a qrcode
+      
+      # @return [Hash] result data
+      # @example
+      #   Wechat::Qrcode.create
+
+
+      def create
+        options = {expire_seconds: 1800,action_name: 'QR_SCENE',
+          action_info: {scene: {scene_id: 2.times.map{ 10 + Random.rand(20) }.join }}}
+        post("qrcode/create", JSON.generate(options))
+      end
+
+
+
+      # Get the QR code image url from a ticket number
+
+      # @param ticket [String] the ticket number of qr code obtained from create
+      # @return [String] QR code image url
+      # @example
+      #   Wechat::Qrcode.show('gQEc8DoAAAAAAAAAASxodHRwOi8vd2VpeGluLnFxLmNvbS9xL0xFUG15QWJtMHBhci1FMV9uMjJCAAIEL3gHVAMECAcAAA==')
+
+      def show(ticket) 
+        return "https://mp.weixin.qq.com/cgi-bin/showqrcode/cgi-bin/showqrcode?ticket=#{CGI.escape(ticket)}"
+      end
+
+
+    end
+  end
+end

data/lib/wechat/error.rb

@@ -0,0 +1,24 @@
+module Wechat
+  
+  # Custom error class for rescuing from Wechat errors
+  class Error < StandardError
+    def initialize(code)
+      @code = code
+
+      super(build_error_message)
+    end
+
+    def build_error_message
+      "HTTP-Code: #{@code}"
+    end
+  end
+
+  # Raised when Wechat returns a 400 HTTP status code
+  class BadRequest < Error; end
+
+  # Raised when Wechat returns a 401 HTTP status code
+  class Unauthorized < Error; end
+
+  # Raised when Wechat returns a 500 HTTP status code
+  class InternalServerError < Error; end
+end

data/lib/wechat/local_resource.rb

@@ -0,0 +1,36 @@
+module Wechat
+  
+  class LocalResource
+    attr_reader :uri
+    
+    def initialize(uri)
+      @uri = uri
+    end
+    
+    def file
+      @file ||= Tempfile.new(tmp_filename, tmp_folder, encoding: encoding).tap do |f|
+        io.rewind
+        f.write(io.read)
+        f.close
+      end
+    end
+    
+    def io
+      @io ||= uri.open
+    end
+    
+    def encoding
+      io.rewind
+      io.read.encoding
+    end
+    
+    def tmp_filename
+      File.basename(uri.path)
+    end
+    
+    def tmp_folder
+      '/tmp'
+    end
+    
+  end
+end

data/lib/wechat/request.rb

@@ -0,0 +1,48 @@
+module Wechat
+
+  class Request
+    attr_accessor :http_verb, :path, :params
+
+    def initialize(http_verb, path, params = {})
+      self.path = path
+      self.http_verb = http_verb
+      self.params = params
+    end
+
+    def send_request
+      case http_verb.to_sym
+      when :post
+        RestClient.post(wechat_uri, params) do |response, request, result, &block|
+          Wechat::Response.new(response).result
+        end
+      else 
+        RestClient.get(wechat_uri, :content_type => :json) do |response, request, result, &block|
+          Wechat::Response.new(response).result      
+        end
+      end
+    end
+
+    def access_token
+      Wechat::AccessToken.new.token
+    end
+
+    def wechat_uri
+      if (@path.include?'media/upload') || (@path.include?'media/get')
+        base = Wechat.file_endpoint
+      else
+        base = Wechat.api_endpoint
+      end
+      [base, @path].join('/') + append_access_token 
+    end
+
+    def append_access_token
+      if @path.include?'?'
+        return "&access_token=#{access_token}"
+      else
+        return "?&access_token=#{access_token}"
+      end
+    end
+
+  end
+
+end

data/lib/wechat/response.rb

@@ -0,0 +1,40 @@
+module Wechat
+
+  class Response
+    attr_accessor :code, :data, :parse_as
+
+    def initialize(response)
+      type = response.headers[:content_type] 
+
+      case type
+      when /image|audio|video/
+        self.parse_as = :file
+      else
+        self.parse_as = :json
+      end
+      self.data = response
+      self.code = response.code 
+    end
+
+    def result
+      if code == 200        
+        case parse_as
+        when :file
+          file = Tempfile.new(["tmp", ".#{data.headers[:content_type].split('/')[1] }"])
+          file.binmode
+          file.write(data.body)
+          file.close
+          file.path
+        when :json
+          JSON.parse(data)           
+        end
+
+      elsif !code.nil? && code == 401
+        raise Wechat::Unauthorized.new(code)
+      else
+        raise Wechat::BadRequest.new(code)
+      end
+    end
+
+  end
+end

data/lib/wechat/version.rb

@@ -0,0 +1,3 @@
+module Wechat
+  VERSION = "0.1.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'wechat'
+require 'rspec'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.before(:all) { stub_wechat_authentication! }
+end
+
+def stub_wechat_authentication!
+  Wechat.configure do |config|
+    config.api_appid = "my_username"
+    config.api_appsecret = "my_password"
+  end
+end
+

data/spec/wechat/data_object_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Wechat::DataObject do
+  context "as a class" do
+
+    describe '.get' do
+      it "delegates to the instance request method" do
+        Wechat::DataObject.any_instance.should_receive(:request).with('get', 'test_method', {}).and_return(nil)
+        Wechat::DataObject.get('test_method', {})
+      end
+
+  
+    end
+
+    describe '.post' do
+      it "delegates to the instance request method" do
+        Wechat::DataObject.any_instance.should_receive(:request).with('post', 'test_method', {}).and_return(nil)
+        Wechat::DataObject.post('test_method', {})
+      end
+    end
+
+
+
+    describe '.parameterize_params' do
+      it "converts hash to params string" do
+        params = {"a" => 1, "b" => 2, "c" => 3}
+        expect(Wechat::DataObject.parameterize_params(params)).to eq("a=1&b=2&c=3")
+      end
+    end
+  end
+
+  context "as an instance" do
+    let(:data_object) { Wechat::DataObject.new }
+
+    it "provides a simpel #request that delegates to Wechat::Request" do
+      Wechat::Request.any_instance.should_receive(:send_request).and_return(nil)
+      data_object.request('get', 'test_method', {})
+    end
+  end
+end

data/spec/wechat/request_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Wechat::Request do
+  let(:client) { Wechat::Client.new }
+  let(:request) { Wechat::Request.new('get', 'some-path', {:a => 1}) }
+
+  describe '#initialize' do
+    it 'sets client, path, http_verb and params attributes on initialize' do
+      expect(request.http_verb).to eq('get')
+      expect(request.path).to eq("some-path")
+      expect(request.params).to eq({:a => 1})
+    end
+  end
+
+  describe '#client' do
+    it "provides a simple client accessor method" do
+      expect(request.client).to be_a(Wechat::Client)
+    end
+  end
+
+
+
+end

data/spec/wechat/response_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Wechat::Response do
+  
+
+end

data/spec/wechat_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Wechat do
+
+  describe ".configure" do
+    [:api_endpoint, :api_appid, :api_appsecret,:file_endpoint].each do |key|
+      it "sets the #{key.to_s.gsub('_', ' ')}" do
+        Wechat.configure do |config|
+          config.send("#{key}=", key)
+        end
+        expect(Wechat.instance_variable_get(:"@#{key}")).to eq key
+      end
+    end
+  end
+
+
+  describe ".api_endpoint getter" do
+    it "returns specific url as default value" do
+      Wechat.api_endpoint = nil
+      Wechat.api_endpoint.should eq('https://api.weixin.qq.com/cgi-bin')
+      Wechat.file_endpoint = nil
+      Wechat.file_endpoint.should eq('http://file.api.weixin.qq.com/cgi-bin')
+    end
+  end
+end

data/wechat.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wechat/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wechat-rb"
+  spec.version       = Wechat::VERSION
+  spec.authors       = ["Eshaam Rabaney"]
+  spec.email         = ["eshaam.rabaney@gmail.com"]
+  spec.summary       = %q{A Ruby library for interacting with the echat Official Accounts API.}
+  spec.description   = %q{Easy to use ruby library for Wechat Official Accounts.}
+  spec.homepage      = "https://github.com/eshaam/wechat-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency "rest-client"
+  spec.add_dependency "multi_xml"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: wechat-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eshaam Rabaney
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-03 00:00:00.000000000 Z
+dependencies:
+- !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: multi_xml
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easy to use ruby library for Wechat Official Accounts.
+email:
+- eshaam.rabaney@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/wechat.rb
+- lib/wechat/access_token.rb
+- lib/wechat/data_object.rb
+- lib/wechat/data_objects/broadcast.rb
+- lib/wechat/data_objects/follower.rb
+- lib/wechat/data_objects/media.rb
+- lib/wechat/data_objects/menu.rb
+- lib/wechat/data_objects/message.rb
+- lib/wechat/data_objects/qrcode.rb
+- lib/wechat/error.rb
+- lib/wechat/local_resource.rb
+- lib/wechat/request.rb
+- lib/wechat/response.rb
+- lib/wechat/version.rb
+- spec/spec_helper.rb
+- spec/wechat/data_object_spec.rb
+- spec/wechat/request_spec.rb
+- spec/wechat/response_spec.rb
+- spec/wechat_spec.rb
+- wechat.gemspec
+homepage: https://github.com/eshaam/wechat-rb
+licenses:
+- MIT
+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.2
+signing_key: 
+specification_version: 4
+summary: A Ruby library for interacting with the echat Official Accounts API.
+test_files:
+- spec/spec_helper.rb
+- spec/wechat/data_object_spec.rb
+- spec/wechat/request_spec.rb
+- spec/wechat/response_spec.rb
+- spec/wechat_spec.rb