ruby-transmitsms 0.0.1

data/lib/swagger.rb

@@ -0,0 +1,84 @@
+require 'monkey'
+require 'swagger/configuration'
+require 'swagger/request'
+require 'swagger/response'
+require 'swagger/version'
+require 'logger'
+
+module Swagger
+    
+  class << self
+    attr_accessor :logger
+    
+    # A Swagger configuration object. Must act like a hash and return sensible
+    # values for all Swagger configuration options. See Swagger::Configuration.
+    attr_accessor :configuration
+
+    attr_accessor :resources
+    
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Swagger.configure do |config|
+    #     config.api_key = '1234567890abcdef'     # required
+    #     config.username = 'wordlover'           # optional, but needed for user-related functions
+    #     config.password = 'i<3words'            # optional, but needed for user-related functions
+    #     config.format = 'json'                  # optional, defaults to 'json'
+    #   end
+    #
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+
+      # Configure logger.  Default to use Rails
+      self.logger ||= configuration.logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
+
+      # remove :// from scheme
+      configuration.scheme.sub!(/:\/\//, '')
+
+      # remove http(s):// and anything after a slash
+      configuration.host.sub!(/https?:\/\//, '')
+      configuration.host = configuration.host.split('/').first
+
+      # Add leading and trailing slashes to base_path
+      configuration.base_path = "/#{configuration.base_path}".gsub(/\/+/, '/')
+      configuration.base_path = "" if configuration.base_path == "/"
+    end
+    
+    def authenticated?
+      Swagger.configuration.auth_token.present?
+    end
+    
+    def de_authenticate
+      Swagger.configuration.auth_token = nil
+    end
+    
+    def authenticate
+      return if Swagger.authenticated?
+      
+      if Swagger.configuration.username.blank? || Swagger.configuration.password.blank?
+        raise ClientError, "Username and password are required to authenticate."
+      end
+      
+      request = Swagger::Request.new(
+        :get, 
+        "account/authenticate/{username}", 
+        :params => {
+          :username => Swagger.configuration.username, 
+          :password => Swagger.configuration.password
+        }
+      )
+      
+      response_body = request.response.body
+      Swagger.configuration.auth_token = response_body['token']
+    end
+
+  end
+  
+end
+
+class ServerError < StandardError
+end
+
+class ClientError < StandardError
+end

data/lib/swagger/configuration.rb

@@ -0,0 +1,22 @@
+module Swagger
+
+  class Configuration
+    require 'swagger/version'    
+    
+    attr_accessor :format, :api_key, :username, :password, :auth_token, :scheme, :host, :base_path, :user_agent, :logger, :inject_format, :force_ending_format, :camelize_params, :user_agent
+    
+    # Defaults go in here..
+    def initialize
+      @format = 'json'
+      @scheme = 'http'
+      @host = 'petstore.swagger.io'
+      @base_path = '/v2'
+      @user_agent = "ruby-swagger-#{Swagger::VERSION}"
+      @inject_format = false
+      @force_ending_format = false
+      @camelize_params = true
+    end
+
+  end
+
+end

data/lib/swagger/request.rb

@@ -0,0 +1,212 @@
+module Swagger
+
+  class Request
+    require 'uri'
+    require 'addressable/uri'
+    require 'typhoeus'
+    require "swagger/version"
+
+    attr_accessor :host, :path, :format, :params, :body, :http_method, :headers, :form_params
+
+
+    # All requests must have an HTTP method and a path
+    # Optionals parameters are :params, :headers, :body, :format, :host
+    # 
+    def initialize(http_method, path, attributes={})
+      attributes[:format] ||= Swagger.configuration.format
+      attributes[:params] ||= {}
+
+      # Set default headers
+      default_headers = {
+        'Content-Type' => "application/#{attributes[:format].downcase}",
+        :api_key => Swagger.configuration.api_key,
+        'User-Agent' => Swagger.configuration.user_agent
+      }
+
+      # api_key from headers hash trumps the default, even if its value is blank
+      if attributes[:headers].present? && attributes[:headers].has_key?(:api_key)
+        default_headers.delete(:api_key)
+      end
+      
+      # api_key from params hash trumps all others (headers and default_headers)
+      if attributes[:params].present? && attributes[:params].has_key?(:api_key)
+        default_headers.delete(:api_key)
+        attributes[:headers].delete(:api_key) if attributes[:headers].present?
+      end
+      
+      # Merge argument headers into defaults
+      attributes[:headers] = default_headers.merge(attributes[:headers] || {})
+      
+      # Stick in the auth token if there is one
+      if Swagger.authenticated?
+        attributes[:headers].merge!({:auth_token => Swagger.configuration.auth_token})
+      end
+            
+      self.http_method = http_method.to_sym
+      self.path = path
+      attributes.each do |name, value|
+        send("#{name.to_s.underscore.to_sym}=", value)
+      end
+    end
+
+    # Construct a base URL
+    #
+    def url(options = {})  
+      u = Addressable::URI.new(
+        :scheme => Swagger.configuration.scheme,
+        :host => Swagger.configuration.host,
+        :path => self.interpreted_path,
+        :query => self.query_string.sub(/\?/, '')
+      ).to_s
+      
+      # Drop trailing question mark, if present
+      u.sub! /\?$/, ''
+      
+      # Obfuscate API key?
+      u.sub! /api\_key=\w+/, 'api_key=YOUR_API_KEY' if options[:obfuscated]
+      
+      u
+    end
+
+    # Iterate over the params hash, injecting any path values into the path string
+    #
+    # e.g. /word.{format}/{word}/entries => /word.json/cat/entries
+    def interpreted_path
+      p = self.path.dup
+
+      # Stick a .{format} placeholder into the path if there isn't
+      # one already or an actual format like json or xml
+      # e.g. /words/blah => /words.{format}/blah
+      if Swagger.configuration.inject_format
+        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+          p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+        end
+      end
+
+      # Stick a .{format} placeholder on the end of the path if there isn't
+      # one already or an actual format like json or xml
+      # e.g. /words/blah => /words/blah.{format}
+      if Swagger.configuration.force_ending_format
+        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+          p = "#{p}.#{format}"   
+        end
+      end
+
+      p = p.sub("{format}", self.format.to_s)
+      
+      URI.encode [Swagger.configuration.base_path, p].join("/").gsub(/\/+/, '/')
+    end
+  
+    # Massage the request body into a state of readiness
+    # If body is a hash, camelize all keys then convert to a json string
+    #
+    def body=(value)      
+      if value.is_a?(Hash)
+        value = value.inject({}) do |memo, (k,v)|
+          memo[k.to_s.camelize(:lower).to_sym] = v
+          memo
+        end
+      end
+      @body = value
+    end
+    
+    # If body is an object, JSONify it before making the actual request.
+    # For form parameters, remove empty value 
+    def outgoing_body
+      # http form
+      if @body.nil? && @form_params && !@form_params.empty?
+        data = form_params.dup
+        data.each do |key, value|
+          data[key] = value.to_s if value && !value.is_a?(File) # remove emtpy form parameter
+        end
+        data
+      else # http body is JSON
+        @body.is_a?(String) ? @body : @body.to_json
+      end
+    end
+    
+    # Construct a query string from the query-string-type params
+    def query_string
+
+      # Iterate over all params,
+      # .. removing the ones that are part of the path itself.
+      # .. stringifying values so Addressable doesn't blow up.
+      query_values = {}
+      self.params.each_pair do |key, value|
+        next if self.path.include? "{#{key}}"                                   # skip path params
+        next if value.blank? && value.class != FalseClass                       # skip empties
+        if Swagger.configuration.camelize_params
+          key = key.to_s.camelize(:lower).to_sym unless key.to_sym == :api_key    # api_key is not a camelCased param
+        end
+        query_values[key] = value.to_s
+      end
+    
+      # We don't want to end up with '?' as our query string
+      # if there aren't really any params
+      return "" if query_values.blank?
+    
+      # Addressable requires query_values to be set after initialization..
+      qs = Addressable::URI.new
+      qs.query_values = query_values
+      qs.to_s
+    end
+  
+    def make
+      #TODO use configuration setting to determine if debugging
+      #logger = Logger.new STDOUT
+      #logger.debug self.url
+      response = case self.http_method.to_sym
+      when :get,:GET
+        Typhoeus::Request.get(
+          self.url,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :post,:POST
+        Typhoeus::Request.post(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :patch,:PATCH
+        Typhoeus::Request.patch(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :put,:PUT
+        Typhoeus::Request.put(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+      
+      when :delete,:DELETE
+        Typhoeus::Request.delete(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+      end
+      Response.new(response)
+    end
+  
+    def response
+      self.make
+    end
+  
+    def response_code_pretty
+      return unless @response.present?
+      @response.code.to_s    
+    end
+  
+    def response_headers_pretty
+      return unless @response.present?
+      # JSON.pretty_generate(@response.headers).gsub(/\n/, '<br/>') # <- This was for RestClient
+      @response.headers.gsub(/\n/, '<br/>') # <- This is for Typhoeus
+    end
+
+  end
+end

data/lib/swagger/response.rb

@@ -0,0 +1,70 @@
+module Swagger
+
+  class Response
+    require 'json'
+
+    attr_accessor :raw
+
+    def initialize(raw)
+      self.raw = raw
+
+#      case self.code
+#      when 500..510 then raise(ServerError, self.error_message)
+#      when 299..426 then raise(ClientError, self.error_message)
+#      end
+    end
+
+    def code
+      raw.code
+    end
+    
+    # Account for error messages that take different forms...
+    def error_message
+      body['message']
+    rescue
+      body
+    end
+
+    # If body is JSON, parse it
+    # Otherwise return raw string
+    def body
+      JSON.parse raw.body
+    rescue
+      raw.body
+    end
+
+    # `headers_hash` is a Typhoeus-specific extension of Hash, 
+    # so simplify it back into a regular old Hash.
+    def headers
+      h = {}
+      raw.headers_hash.each {|k,v| h[k] = v }
+      h
+    end
+
+    # Extract the response format from the header hash
+    # e.g. {'Content-Type' => 'application/json'}
+    def format
+      headers['Content-Type'].split("/").last.downcase
+    end
+
+    def json?
+      format == 'json'
+    end
+
+    def xml?
+      format == 'xml'
+    end
+
+    def pretty_body
+      return unless body.present?
+      case format
+      when 'json' then JSON.pretty_generate(body).gsub(/\n/, '<br/>')
+      end
+    end
+
+    def pretty_headers
+      JSON.pretty_generate(headers).gsub(/\n/, '<br/>')
+    end
+    
+  end
+end

data/lib/swagger/version.rb

@@ -0,0 +1,4 @@
+module Swagger
+  VERSION = "4.06.08"
+end
+

data/ruby-transmitsms.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+#$:.push File.expand_path("../lib", __FILE__)
+#require "swagger/version"
+
+Gem::Specification.new do |s|
+  s.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  s.name        = "ruby-transmitsms"
+  s.version     = "0.0.1"
+  s.authors     = ["Jeremiah John Macariola"]
+  s.email       = ["maiah@burstsms.com"]
+  s.homepage    = "http://burstsms.com.au"
+  s.summary     = "Ruby SDK"
+  s.description = "Ruby gem to easily access TransmitSMS RESTful APIs"
+
+  s.add_runtime_dependency 'typhoeus', '>=0.2.1'
+  s.add_runtime_dependency 'addressable', '>=2.2.4'
+  s.add_runtime_dependency 'json', '>=1.4.6'
+
+  s.add_development_dependency 'rspec', '>=2.5.0'
+  s.add_development_dependency 'rspec-mocks'
+  s.add_development_dependency 'vcr', '>=2.9.3'
+  s.add_development_dependency 'webmock', '>=1.21.0'
+#  s.add_development_dependency 'autotest'  
+#  s.add_development_dependency 'autotest-rails-pure'
+#  s.add_development_dependency 'autotest-growl'
+#  s.add_development_dependency 'autotest-fsevent'
+
+  s.files         = `find *`.split("\n").uniq.sort.select{|f| !f.empty? }
+  s.test_files    = `find spec/*`.split("\n")
+  s.executables   = []
+  s.require_paths = ["lib", "models"]
+end

data/runtest.sh

@@ -0,0 +1,8 @@
+#bundle exec rspec
+ruby spec/sms_api_spec.rb
+ruby spec/numbers_api_spec.rb
+ruby spec/email_sms_api_spec.rb
+ruby spec/account_api_spec.rb
+ruby spec/keywords_api_spec.rb
+ruby spec/lists_api_spec.rb
+ruby spec/resellers_api_spec.rb

data/setup.sh

@@ -0,0 +1 @@
+bundle install

data/spec/account_api_spec.rb

@@ -0,0 +1,30 @@
+require "rubygems"
+require "bundler/setup"
+require "ruby-transmitsms"
+require "test/unit"
+require "vcr"
+
+VCR.configure do |c|
+  c.cassette_library_dir = "fixtures/vcr_cassettes"
+  c.hook_into :webmock
+end
+
+class AccountApiTest < Test::Unit::TestCase
+
+  def setup()
+    @api = AccountApi.new("15ad266c538fb36c4d90f01055aef494", "moose")
+  end
+
+  def test_get_balance()
+    VCR.use_cassette("account_api_get_balance") do
+      response = @api.get_balance()
+
+      assert response.code == 200
+      assert response.body["balance"] > 0.00
+      assert response.body["currency"] == "SGD"
+      assert response.body["error"]["code"] == "SUCCESS"
+      assert response.body["error"]["description"] == "OK"
+    end
+  end
+
+end