shirtsio-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d328158b57485ebd7629ac0520fb6331b5023de
+  data.tar.gz: 50d4414935fa2579e02368026ebb79796e8ef982
+SHA512:
+  metadata.gz: 1538b7d50d959b701b122c4658e7d088a22a7f3554cffa696bea9672d4992262469d7348efb148099c03be4075b34b14437a52cc2178af06faf83f5b95c33034
+  data.tar.gz: be241d7db0373ebded0a34b62fffc664052f9c6f16aa85de3880662c79e678c3868687fe93af2b3587119aa349c8e4f6e81328cc0ed504b3d7741566ecd875cf

data/.gitignore

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

data/.idea/dictionaries/dean.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="dean">
+    <words>
+      <w>webhook</w>
+    </words>
+  </dictionary>
+</component>

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shirtsio.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Dean Hailin Song
+
+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,29 @@
+# Shirtsio
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shirtsio'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shirtsio
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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 new Pull Request

data/Rakefile

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

data/lib/shirtsio.rb

@@ -0,0 +1,232 @@
+require 'cgi'
+require 'set'
+require 'openssl'
+require 'rest_client'
+require 'multi_json'
+
+# Version
+require "shirtsio/version"
+
+# Resources
+require "shirtsio/util"
+require "shirtsio/json"
+require "shirtsio/shirtsio_object"
+require "shirtsio/api_resource"
+require "shirtsio/category"
+require "shirtsio/product"
+require "shirtsio/quote"
+require "shirtsio/authentication"
+require "shirtsio/webhooks"
+require "shirtsio/status"
+require "shirtsio/order"
+
+# Error
+require "shirtsio/errors/shirtsio_error"
+require "shirtsio/errors/api_error"
+require "shirtsio/errors/api_connection_error"
+require "shirtsio/errors/invalid_request_error"
+require "shirtsio/errors/authentication_error"
+
+module Shirtsio
+  @api_base = 'https://www.shirts.io/api/v1/'
+  #put @api_base
+
+  class << self
+    attr_accessor :api_key, :api_base, :api_version
+  end
+
+  def self.api_url(url='')
+    @api_base + url
+  end
+
+  def self.request(method, url, api_key, params={}, headers={})
+    unless api_key ||= @api_key
+      raise AuthenticationError.new('No API key provided. ' +
+                                        'Set your API key using "Shirtsio.api_key = <API-KEY>". ' +
+                                        'You can generate API keys from the Shirts.io web interface. ' +
+                                        'See https://www.shirts.io for details.')
+    end
+
+    if api_key =~ /\s/
+      raise AuthenticationError.new('Your API key is invalid, as it contains ' +
+                                        'whitespace. (HINT: You can double-check your API key from the ' +
+                                        'Shirts.io web interface. See https://www.shirts.io for details.)')
+    end
+
+    request_opts = { :verify_ssl => false }
+
+    params = Util.objects_to_ids(params)
+    params.update(:api_key => @api_key)
+    url = api_url(url)
+
+    case method.to_s.downcase.to_sym
+      when :get, :head, :delete
+        # Make params into GET parameters
+        url += "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params && params.any?
+        payload = nil
+      else
+        #payload = uri_encode(params)
+        payload = params
+    end
+
+    request_opts.update(:method => method, :open_timeout => 30,
+                        :payload => payload, :url => url, :timeout => 80)
+
+    begin
+      #puts "in shirtsio.rb"
+      #puts request_opts
+      response = execute_request(request_opts)
+    rescue SocketError => e
+      handle_restclient_error(e)
+    rescue NoMethodError => e
+      # Work around RestClient bug
+      if e.message =~ /\WRequestFailed\W/
+        e = APIConnectionError.new('Unexpected HTTP response code')
+        handle_restclient_error(e)
+      else
+        raise
+      end
+    rescue RestClient::ExceptionWithResponse => e
+      if rcode = e.http_code and rbody = e.http_body
+        handle_api_error(rcode, rbody)
+      else
+        handle_restclient_error(e)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      handle_restclient_error(e)
+    end
+
+    [parse(response), api_key]
+  end
+
+  private
+
+  def self.user_agent
+    @uname ||= get_uname
+    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+    {
+        :bindings_version => Shirtsio::VERSION,
+        :lang => 'ruby',
+        :lang_version => lang_version,
+        :platform => RUBY_PLATFORM,
+        :publisher => 'shirtsio',
+        :uname => @uname
+    }
+
+  end
+
+  def self.get_uname
+    `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+  rescue Errno::ENOMEM => ex # couldn't create subprocess
+    "uname lookup failed"
+  end
+
+  def self.uri_encode(params)
+    Util.flatten_params(params).
+        map { |k,v| "#{k}=#{Util.url_encode(v)}" }.join('&')
+  end
+
+  def self.request_headers(api_key)
+    headers = {
+        :user_agent => "Stripe/v1 RubyBindings/#{Shirtsio::VERSION}",
+        :authorization => "Bearer #{api_key}",
+        :content_type => 'application/x-www-form-urlencoded'
+    }
+
+    headers[:stripe_version] = api_version if api_version
+
+    begin
+      headers.update(:x_stripe_client_user_agent => Shirtsio::JSON.dump(user_agent))
+    rescue => e
+      headers.update(:x_stripe_client_raw_user_agent => user_agent.inspect,
+                     :error => "#{e} (#{e.class})")
+    end
+  end
+
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  end
+
+  def self.parse(response)
+    begin
+      # Would use :symbolize_names => true, but apparently there is
+      # some library out there that makes symbolize_names not work.
+      response = Shirtsio::JSON.load(response.body)
+    rescue MultiJson::DecodeError
+      raise general_api_error(response.code, response.body)
+    end
+
+    Util.symbolize_names(response)
+  end
+
+  def self.general_api_error(rcode, rbody)
+    APIError.new("Invalid response object from API: #{rbody.inspect} " +
+                     "(HTTP response code was #{rcode})", rcode, rbody)
+  end
+
+  def self.handle_api_error(rcode, rbody)
+    begin
+      error_obj = Shirtsio::JSON.load(rbody)
+      error_obj = Util.symbolize_names(error_obj)
+      error = error_obj[:error] or raise Shirtsio.new # escape from parsing
+
+    rescue MultiJson::DecodeError, Shirtsio
+      raise general_api_error(rcode, rbody)
+    end
+
+    case rcode
+      when 400, 404
+        raise invalid_request_error error, rcode, rbody, error_obj
+      when 401
+        raise authentication_error error, rcode, rbody, error_obj
+      when 402
+        raise card_error error, rcode, rbody, error_obj
+      else
+        raise api_error error, rcode, rbody, error_obj
+    end
+
+  end
+
+  def self.invalid_request_error(error, rcode, rbody, error_obj)
+    InvalidRequestError.new(error, nil, rcode,
+                            rbody, error_obj)
+  end
+
+  def self.authentication_error(error, rcode, rbody, error_obj)
+    AuthenticationError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.card_error(error, rcode, rbody, error_obj)
+    CardError.new(error[:message], error[:param], error[:code],
+                  rcode, rbody, error_obj)
+  end
+
+  def self.api_error(error, rcode, rbody, error_obj)
+    APIError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.handle_restclient_error(e)
+    case e
+      when RestClient::ServerBrokeConnection, RestClient::RequestTimeout
+        message = "Could not connect to Shirts.io (#{@api_base}). " +
+            "Please check your internet connection and try again. "
+
+      when RestClient::SSLCertificateNotVerified
+        message = "Could not verify Stripe's SSL certificate. " +
+            "Please make sure that your network is not intercepting certificates. "
+
+      when SocketError
+        message = "Unexpected error communicating when trying to connect to Stripe. " +
+            "You may be seeing this message because your DNS is not working. " +
+            "To check, try running 'host www.shirts.io' from the command line."
+
+      else
+        message = "Unexpected error communicating with Stripe. " +
+            "If this problem persists, let us know at jerry@ooshirts.com."
+
+    end
+
+    raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+  end
+end

data/lib/shirtsio/api_resource.rb

@@ -0,0 +1,35 @@
+module Shirtsio
+  class APIResource < ShirtsioObject
+    def self.class_name
+      self.name.split('::')[-1]
+    end
+
+    def self.url()
+      if self == APIResource
+        raise NotImplementedError.new('APIResource is an abstract class.  You should perform actions on its subclasses (Charge, Customer, etc.)')
+      end
+      "/v1/#{CGI.escape(class_name.downcase)}s"
+    end
+
+    def url
+      unless id = self['id']
+        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
+      end
+      "#{self.class.url}/#{CGI.escape(id)}"
+    end
+
+    def refresh
+      puts "in api_resource"
+      puts url
+      response, api_key = Shirtsio.request(:get, url, @api_key, @retrieve_options)
+      refresh_from(response, api_key)
+      self
+    end
+
+    def self.retrieve(id, api_key=nil)
+      instance = self.new(id, api_key)
+      instance.refresh
+      instance
+    end
+  end
+end

data/lib/shirtsio/authentication.rb

@@ -0,0 +1,13 @@
+module Shirtsio
+  class Authentication < APIResource
+
+    @auth_url = 'internal/integration/auth/'
+
+    def Authentication.auth(params={})
+      response, api_key = Shirtsio.request(:get, @auth_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+  end
+end

data/lib/shirtsio/category.rb

@@ -0,0 +1,12 @@
+module Shirtsio
+  class Category < APIResource
+
+    @category_url = 'products/category/'
+
+    def Category.all(params={})
+      response, api_key = Shirtsio.request(:get, @category_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+    end
+
+  end
+end

data/lib/shirtsio/errors/api_connection_error.rb

@@ -0,0 +1,4 @@
+module Shirtsio
+  class APIConnectionError < ShirtsioError
+  end
+end

data/lib/shirtsio/errors/api_error.rb

@@ -0,0 +1,4 @@
+module Shirtsio
+  class APIError < ShirtsioError
+  end
+end

data/lib/shirtsio/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+module Shirtsio
+  class AuthenticationError < ShirtsioError
+  end
+end

data/lib/shirtsio/errors/invalid_request_error.rb

@@ -0,0 +1,11 @@
+module Shirtsio
+  class InvalidRequestError < ShirtsioError
+    attr_accessor :param
+
+    def initialize(message, param, http_status=nil, http_body=nil, json_body=nil)
+
+      super(message, http_status, http_body, json_body)
+      @param = param
+    end
+  end
+end

data/lib/shirtsio/errors/shirtsio_error.rb

@@ -0,0 +1,20 @@
+module Shirtsio
+  class ShirtsioError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+end

data/lib/shirtsio/json.rb

@@ -0,0 +1,21 @@
+module Shirtsio
+  module JSON
+    if MultiJson.respond_to?(:dump)
+      def self.dump(*args)
+        MultiJson.dump(*args)
+      end
+
+      def self.load(*args)
+        MultiJson.load(*args)
+      end
+    else
+      def self.dump(*args)
+        MultiJson.encode(*args)
+      end
+
+      def self.load(*args)
+        MultiJson.decode(*args)
+      end
+    end
+  end
+end

data/lib/shirtsio/order.rb

@@ -0,0 +1,13 @@
+module Shirtsio
+  class Order < APIResource
+
+    @order_url = 'order/'
+
+    def Order.place_order(params={})
+      response, api_key = Shirtsio.request(:post, @order_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+  end
+end

data/lib/shirtsio/product.rb

@@ -0,0 +1,31 @@
+module Shirtsio
+  class Product < APIResource
+
+    @products_url = 'products/'
+    @category_url = 'products/category/'
+
+    def Product.list_products(params={})
+      category_id = params[:category_id]
+      list_products_url = @category_url + category_id + "/"
+      response, api_key = Shirtsio.request(:get, list_products_url, @api_key, params={})
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+    def Product.get_product(params={})
+      product_id = params[:product_id]
+      get_product_url = @products_url + product_id + "/"
+      response, api_key = Shirtsio.request(:get, get_product_url, @api_key, params={})
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+    def Product.inventory_count(params={})
+      product_id = params.delete(:product_id)
+      get_product_url = @products_url + product_id + "/"
+      response, api_key = Shirtsio.request(:get, get_product_url, @api_key, params)
+      #Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+  end
+end

data/lib/shirtsio/quote.rb

@@ -0,0 +1,13 @@
+module Shirtsio
+  class Quote < APIResource
+
+    @quote_url = 'quote/'
+
+    def Quote.get_quote(params={})
+      response, api_key = Shirtsio.request(:get, @quote_url, @api_key, params)
+      #Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+  end
+end

data/lib/shirtsio/shirtsio_object.rb

@@ -0,0 +1,158 @@
+module Shirtsio
+  class ShirtsioObject
+    include Enumerable
+
+    attr_accessor :api_key
+    @@permanent_attributes = Set.new([:api_key, :id])
+
+    # The default :id method is deprecated and isn't useful to us
+    if method_defined?(:id)
+      undef :id
+    end
+
+    def initialize(id=nil, api_key=nil)
+      # parameter overloading!
+      if id.kind_of?(Hash)
+        @retrieve_options = id.dup
+        @retrieve_options.delete(:id)
+        id = id[:id]
+      else
+        @retrieve_options = {}
+      end
+
+      @api_key = api_key
+      @values = {}
+      # This really belongs in APIResource, but not putting it there allows us
+      # to have a unified inspect method
+      @unsaved_values = Set.new
+      @transient_values = Set.new
+      self.id = id if id
+    end
+
+    def self.construct_from(values, api_key=nil)
+      obj = self.new(values[:id], api_key)
+      obj.refresh_from(values, api_key)
+      obj
+    end
+
+    def to_s(*args)
+      ShirtsioObject::JSON.dump(@values, :pretty => true)
+    end
+
+    def inspect()
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + ShirtsioObject::JSON.dump(@values, :pretty => true)
+    end
+
+    def refresh_from(values, api_key, partial=false)
+      @api_key = api_key
+
+      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
+      added = Set.new(values.keys - @values.keys)
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added)
+      end
+      removed.each do |k|
+        @values.delete(k)
+        @transient_values.add(k)
+        @unsaved_values.delete(k)
+      end
+      values.each do |k, v|
+        @values[k] = Util.convert_to_shirtsio_object(v, api_key)
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+    end
+
+    def [](k)
+      @values[k.to_sym]
+    end
+
+    def []=(k, v)
+      send(:"#{k}=", v)
+    end
+
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*a)
+      ShirtsioObject::JSON.dump(@values)
+    end
+
+    def as_json(*a)
+      @values.as_json(*a)
+    end
+
+    def to_hash
+      @values
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+
+    def add_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          define_method(k) { @values[k] }
+          define_method(k_eq) do |v|
+            @values[k] = v
+            @unsaved_values.add(k)
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      # TODO: only allow setting in updateable classes.
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        @values[attr] = args[0]
+        @unsaved_values.add(attr)
+        add_accessors([attr])
+        return
+      else
+        return @values[name] if @values.has_key?(name)
+      end
+
+      begin
+        super
+      rescue NoMethodError => e
+        if @transient_values.include?(name)
+          raise NoMethodError.new(e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Stripe's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}")
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/shirtsio/status.rb

@@ -0,0 +1,13 @@
+module Shirtsio
+  class Status < APIResource
+
+    @status_url = 'status/'
+
+    def Status.get_order_status(params={})
+      response, api_key = Shirtsio.request(:get, @status_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+  end
+end

data/lib/shirtsio/util.rb

@@ -0,0 +1,106 @@
+module Shirtsio
+  module Util
+    def self.objects_to_ids(h)
+      case h
+        when APIResource
+          h.id
+        when Hash
+          res = {}
+          h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+          res
+        when Array
+          h.map { |v| objects_to_ids(v) }
+        else
+          h
+      end
+    end
+
+    def self.convert_to_shirtsio_object(resp, api_key)
+      types = {
+          'category' => Category,
+          'product' => Product,
+          'quote' => Quote,
+          'authentication' => Authentication,
+          'webhooks' => Webhooks,
+          'status' => Status,
+          'order' => Order
+      }
+      case resp
+        when Array
+          resp.map { |i| convert_to_shirtsio_object(i, api_key) }
+        when Hash
+          #puts "in api resource"
+          #puts resp
+          #puts "end api resource"
+          # Try converting to a known object class.  If none available, fall back to generic APIResource
+          if klass_name = resp[:object]
+            klass = types[klass_name]
+          end
+          klass ||= ShirtsioObject
+          klass.construct_from(resp, api_key)
+        else
+          resp
+      end
+    end
+
+    def self.file_readable(file)
+      begin
+        File.open(file) { |f| }
+      rescue
+        false
+      else
+        true
+      end
+    end
+
+    def self.symbolize_names(object)
+      case object
+        when Hash
+          new = {}
+          object.each do |key, value|
+            key = (key.to_sym rescue key) || key
+            new[key] = symbolize_names(value)
+          end
+          new
+        when Array
+          object.map { |value| symbolize_names(value) }
+        else
+          object
+      end
+    end
+
+    def self.url_encode(key)
+      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def self.flatten_params(params, parent_key=nil)
+      result = []
+      params.each do |key, value|
+        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+        if value.is_a?(Hash)
+          result += flatten_params(value, calculated_key)
+        elsif value.is_a?(Array)
+          result += flatten_params_array(value, calculated_key)
+        else
+          result << [calculated_key, value]
+        end
+      end
+      result
+    end
+
+    def self.flatten_params_array(value, calculated_key)
+      result = []
+      value.each do |elem|
+        if elem.is_a?(Hash)
+          result += flatten_params(elem, calculated_key)
+        elsif elem.is_a?(Array)
+          result += flatten_params_array(elem, calculated_key)
+        else
+          result << ["#{calculated_key}[]", elem]
+        end
+      end
+      result
+    end
+  end
+
+end

data/lib/shirtsio/version.rb

@@ -0,0 +1,3 @@
+module Shirtsio
+  VERSION = "1.0.0"
+end

data/lib/shirtsio/webhooks.rb

@@ -0,0 +1,34 @@
+module Shirtsio
+  class Webhooks < APIResource
+
+    @webhooks_url = 'webhooks/'
+
+    def Webhooks.list(params={})
+      webhooks_list_url = @webhooks_url + 'list/'
+      response, api_key = Shirtsio.request(:get, webhooks_list_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+    def Webhooks.register(params={})
+      webhooks_register_url = @webhooks_url + 'register/'
+      response, api_key = Shirtsio.request(:post, webhooks_register_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+    def Webhooks.delete(params={})
+      webhooks_delete_url = @webhooks_url + 'delete/'
+      response, api_key = Shirtsio.request(:post, webhooks_delete_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+
+    def Webhooks.register_payment(params={})
+      webhooks_payment_url = 'payment/status'
+      response, api_key = Shirtsio.request(:post, webhooks_payment_url, @api_key, params)
+      Util.convert_to_shirtsio_object(response, api_key)
+      response
+    end
+  end
+end

data/shirtsio.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "shirtsio/version"
+require "rake"
+
+Gem::Specification.new do |spec|
+  spec.name          = "shirtsio-ruby"
+  spec.version       = Shirtsio::VERSION
+  spec.authors       = ["Dean Hailin Song"]
+  spec.email         = ["dean.song@movit-tech.com"]
+  spec.description   = "The Shirts.io client library"
+  spec.summary       = "Ruby version for the Shirts.io client library"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.files         += FileList["lib/shirtsio/errors/*.rb"]
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency('rest-client', '~> 1.4')
+  spec.add_dependency('multi_json', '>= 1.0.4', '< 2')
+
+end
+

data/test/example.rb

@@ -0,0 +1,76 @@
+#require File.expand_path('../../lib/*', __FILE__)
+require "shirtsio"
+
+Shirtsio.api_key = '3ef58f89c6c8d0ce3f71e4ab3537db4e24d6ac40'
+
+
+###### Category ######
+#categories = Shirtsio::Category.all()
+#puts categories.result
+
+
+###### Product ######
+#products = Shirtsio::Product.list_products(:category_id => "3")
+#puts products[:result]
+#
+#product = Shirtsio::Product.get_product(:product_id => "5")
+#puts product[:result]
+#
+#product = Shirtsio::Product.inventory_count(:product_id => "5", :color => "White", :state => "CA")
+#puts product[:result][:inventory]
+
+
+###### Quote ######
+#params = {'garment[0][product_id]' => 3, 'garment[0][color]' => 'White',
+#          'garment[0][sizes][med]' => 100, 'print[front][color_count]' => 5}
+#quote = Shirtsio::Quote.get_quote(params)
+#puts quote[:result][:subtotal]
+
+
+###### Auth ######
+#params = {'username' => 'deantest', 'password' => 'Pa$$w0rd'}
+#auth_result = Shirtsio::Authentication.auth(params)
+#puts auth_result[:result][:api_key]
+
+
+###### Webhooks ######
+#new_webhooks = Shirtsio::Webhooks.register(:url => 'www.baidu.com')
+#puts new_webhooks[:result]
+#
+#delete_webhooks = Shirtsio::Webhooks.delete(:url => 'www.baidu.com')
+#puts delete_webhooks[:result]
+#
+#webhooks = Shirtsio::Webhooks.list()
+#puts webhooks[:result][:listener_url]
+
+
+###### Order ######
+#Dir.chdir(File.dirname(__FILE__))
+#artwork_front = File.new("front.png", 'rb')
+#proof_front = File.new("front.jpg", 'rb')
+#artwork_back = File.new("back.png", 'rb')
+#proof_back = File.new("back.jpg", 'rb')
+#puts artwork_front
+#
+#data = {
+#    :multipart => true,
+#    'test' => "True", 'price' => '79.28',
+#    'print[back][color_count]' => '4', 'print[back][colors][0]' => "101C", 'print[back][colors][1]' => '107U',
+#    'addresses[0][name]' => 'John Doe', 'addresses[0][address]' => '123 Hope Ln.',
+#    'addresses[0][city]' => 'Las Vegas', 'addresses[0][state]' => 'Nevada', 'addresses[0][country]' => 'US',
+#    'addresses[0][zipcode]' => '12345', 'addresses[0][batch]' => 1, 'addresses[0][sizes][med]' => '2',
+#    'addresses[0][sizes][lrg]' => '2',
+#    'print_type' => 'Digital Print', 'ship_type' => 'Standard',
+#    'garment[0][product_id]' => '2', 'garment[0][color]' => "White",
+#    'garment[0][sizes][med]' => '2', 'garment[0][sizes][lrg]' => '2', 'print[front][color_count]' => '5',
+#    'print[front][artwork]' => artwork_front, 'print[front][proof]' => proof_front,
+#    'print[back][artwork]' => artwork_back, 'print[back][proof]' => proof_back
+#}
+#
+#order = Shirtsio::Order.place_order(data)
+#puts order[:result]
+
+
+###### Status ######
+#order_status = Shirtsio::Status.get_order_status(:order_id => '999999')
+#puts order_status

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: shirtsio-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Dean Hailin Song
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+    - - <
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+    - - <
+      - !ruby/object:Gem::Version
+        version: '2'
+description: The Shirts.io client library
+email:
+- dean.song@movit-tech.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .idea/dictionaries/dean.xml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shirtsio.rb
+- lib/shirtsio/api_resource.rb
+- lib/shirtsio/authentication.rb
+- lib/shirtsio/category.rb
+- lib/shirtsio/errors/api_connection_error.rb
+- lib/shirtsio/errors/api_error.rb
+- lib/shirtsio/errors/authentication_error.rb
+- lib/shirtsio/errors/invalid_request_error.rb
+- lib/shirtsio/errors/shirtsio_error.rb
+- lib/shirtsio/json.rb
+- lib/shirtsio/order.rb
+- lib/shirtsio/product.rb
+- lib/shirtsio/quote.rb
+- lib/shirtsio/shirtsio_object.rb
+- lib/shirtsio/status.rb
+- lib/shirtsio/util.rb
+- lib/shirtsio/version.rb
+- lib/shirtsio/webhooks.rb
+- shirtsio.gemspec
+- test/example.rb
+homepage: ''
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby version for the Shirts.io client library
+test_files:
+- test/example.rb