ticketinghub 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 130aebb5aef14ed672ce1cde1860e5e0b448ed02
+  data.tar.gz: 7d9fc8c378fae6e5c96674ec0d2ec9adda1c36d8
+SHA512:
+  metadata.gz: 3874d989f510f5c9f311362bb73a2c6113fd46a558a9654884411756156ad986e3e439b759e184e1eeeeb7d1d8251abb7dbba439857a29ebf270a90ee764ed32
+  data.tar.gz: 97acdb59c6818625a952420cf489e6f5bf7245f23dcc624f788e982ec9da92e8cc438c0daf02a5686a542d8832e3fd015edd1ae82971f1b3b660de8ef826d536

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+features/**/*.feature
+-
+LICENSE.md

data/CONTRIBUTING.md

@@ -0,0 +1,18 @@
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add specs for your unimplemented feature or bug fix.
+4. Run `bundle exec rake spec`. If your specs pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake spec`. If your specs fail, return to step 5.
+7. Run `open coverage/index.html`. If your changes are not completely covered
+   by your tests, return to step 3.
+8. Add documentation for your feature or bug fix.
+9. Run `bundle exec rake doc:yard`. If your changes are not 100% documented, go
+   back to step 8.
+10. Add, commit, and push your changes.
+11. [Submit a pull request.][pr]
+
+[fork]: https://help.github.com/articles/fork-a-repo
+[branch]: http://learn.github.com/p/branching.html
+[pr]: https://help.github.com/articles/using-pull-requests

data/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2013 TicketingHub Ltd
+
+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/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec
+
+namespace :doc do
+  require 'yard'
+  YARD::Rake::YardocTask.new do |task|
+    task.files   = ['README.md', 'LICENSE.md', 'lib/**/*.rb']
+    task.options = [
+      '--output-dir', 'doc/yard',
+      '--markup', 'markdown',
+    ]
+  end
+end

data/lib/ticketing_hub.rb

@@ -0,0 +1,22 @@
+require_relative 'ticketing_hub/configuration'
+require_relative 'ticketing_hub/client'
+require_relative 'ticketing_hub/error'
+
+module TicketingHub
+  extend Configuration
+
+  class << self
+    def new(options={})
+      TicketingHub::Client.new options
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to? method
+      new.send method, *args, &block
+    end
+
+    def respond_to?(method, include_private=false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+  end
+end

data/lib/ticketing_hub/authentication.rb

@@ -0,0 +1,11 @@
+module TicketingHub
+  module Authentication
+    def authentication
+      { token: token, secret: secret }
+    end
+
+    def authenticated?
+      ! authentication[:secret].nil?
+    end
+  end
+end

data/lib/ticketing_hub/client.rb

@@ -0,0 +1,27 @@
+require_relative 'authentication'
+require_relative 'connection'
+require_relative 'request'
+require_relative 'resource'
+
+require_relative 'venue'
+require_relative 'order'
+require_relative 'consumer'
+require_relative 'tier'
+require_relative 'ticket'
+
+module TicketingHub
+  class Client
+    include TicketingHub::Authentication
+    include TicketingHub::Connection
+    include TicketingHub::Request
+
+    attr_accessor(*Configuration::VALID_OPTIONS_KEYS)
+
+    def initialize(options={})
+      options = TicketingHub.options.merge(options)
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+  end
+end

data/lib/ticketing_hub/collection.rb

@@ -0,0 +1,52 @@
+require 'active_support'
+
+module TicketingHub
+  class Collection
+    include Enumerable
+
+    def self.from_association parent, child_class, options={}      
+      path = [ parent.model_name.route_key, parent.id,
+               child_class.model_name.route_key ].join '/'
+      new path, parent, child_class
+    end
+
+    attr_accessor :elements, :parent, :child_class
+
+    def initialize(elements, parent, child_class)
+      self.elements = elements
+      self.parent = parent
+      self.child_class = child_class
+    end
+
+    def to_a
+      elements.dup
+    end
+
+    def elements
+      unless @elements.is_a? Array
+        @elements = parent.client.get(path, options)
+          .map { |attrs| child_class.new attrs, parent.client }
+      end
+
+      @elements
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless [].respond_to? method
+      elements.send method, *args, &block
+    end
+
+    def build(attributes = {})
+      child_class.new.tap do |resource|
+        { parent.foreign_key => parent.id,
+          parent.model_name.singular_route_key => parent }.merge(attributes).each do |key, value|
+            resource.send "#{key}=", value if resource.respond_to? "#{key}="
+          end
+      end
+    end
+
+    def create(*args)
+      build.create *args
+    end
+  end
+end

data/lib/ticketing_hub/configuration.rb

@@ -0,0 +1,67 @@
+require 'faraday'
+require_relative 'version'
+
+module TicketingHub
+  module Configuration
+
+    VALID_OPTIONS_KEYS = [
+      :adapter,
+      :faraday_config_block,
+      :api_version,
+      :api_endpoint,
+      :web_endpoint,
+      :status_api_endpoint,
+      :token,
+      :secret,
+      :proxy,
+      :user_agent,
+      :request_host,
+      :auto_traversal].freeze
+
+    DEFAULT_ADAPTER        = Faraday.default_adapter
+    DEFAULT_API_VERSION    = 1
+    DEFAULT_API_ENDPOINT   = ENV['TH_API_ENDPOINT'] || 'https://api.ticketinghub.com/reseller/'
+    DEFAULT_USER_AGENT     = "TicketingHub Ruby Gem #{TicketingHub::VERSION}".freeze
+    DEFAULT_AUTO_TRAVERSAL = false
+
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    def self.extended(base)
+      base.reset
+    end
+
+    def configure
+      yield self
+    end
+
+    def options
+      VALID_OPTIONS_KEYS.each_with_object Hash.new do |key, memo|
+        memo[key] = send key
+      end
+    end
+
+    def api_endpoint=(value)
+      @api_endpoint = File.join value, ''
+    end
+
+    def web_endpoint=(value)
+      @web_endpoint = File.join value, ''
+    end
+
+    def faraday_config(&block)
+      @faraday_config_block = block
+    end
+
+    def reset
+      self.adapter             = DEFAULT_ADAPTER
+      self.api_version         = DEFAULT_API_VERSION
+      self.api_endpoint        = DEFAULT_API_ENDPOINT
+      self.token               = nil
+      self.secret              = nil
+      self.proxy               = nil
+      self.request_host        = nil
+      self.user_agent          = DEFAULT_USER_AGENT
+      self.auto_traversal      = DEFAULT_AUTO_TRAVERSAL
+    end
+  end
+end

data/lib/ticketing_hub/connection.rb

@@ -0,0 +1,52 @@
+require 'faraday_middleware'
+require_relative 'error'
+
+module TicketingHub
+  class ErrorHandler < Faraday::Response::Middleware
+    ERROR_MAP = {
+      400 => TicketingHub::BadRequest,
+      401 => TicketingHub::Unauthorized,
+      403 => TicketingHub::Forbidden,
+      404 => TicketingHub::NotFound,
+      406 => TicketingHub::NotAcceptable,
+      422 => TicketingHub::UnprocessableEntity,
+      500 => TicketingHub::InternalServerError,
+      501 => TicketingHub::NotImplemented,
+      502 => TicketingHub::BadGateway,
+      503 => TicketingHub::ServiceUnavailable
+    }
+
+    def on_complete(response)
+      key = response[:status].to_i
+      raise ERROR_MAP[key].new(response) if ERROR_MAP.has_key? key
+    end
+  end
+
+  # @private
+  module Connection
+    private
+      def connection(options={})
+        options = {
+          authenticate:     true,
+          force_urlencoded: false,
+          raw:              false,
+          ssl:              { verify: false }
+        }.merge(options)
+
+        options.merge! proxy: proxy unless proxy.nil?
+
+        # TODO: Don't build on every request
+        Faraday.new(options) do |builder|
+          builder.request options[:force_urlencoded] ? :url_encoded : :json
+          builder.use ErrorHandler
+          builder.use FaradayMiddleware::FollowRedirects
+          builder.use FaradayMiddleware::ParseJson, content_type: /\bjson$/
+          faraday_config_block.call builder if faraday_config_block
+          builder.adapter *adapter
+        end.tap do |connection|
+          connection.headers[:user_agent] = user_agent
+          connection.basic_auth authentication[:token], authentication[:secret]
+        end
+      end
+  end
+end

data/lib/ticketing_hub/consumer.rb

@@ -0,0 +1,27 @@
+module TicketingHub
+  class Consumer < Resource
+    schema do
+      integer :id
+      string :first_name, :last_name, :email, :country
+    end
+
+    def self.from_fields fields      
+      new.tap do |consumer|
+        consumer.instance_eval do
+          @schema ||= singleton_class.schema do
+            fields.each do |field|
+              type = Schema::KNOWN_ATTRIBUTE_TYPES.member?(field['type']) ? field['type'] : 'string'
+              send type, field['name']
+            end
+          end
+
+          fields.each do |field|
+            singleton_class.validates_presence_of field['name'] if field['required']
+            send "#{field['name']}=", field['value']
+            field['errors'].each { |error| errors.add field['name'], error }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ticketing_hub/error.rb

@@ -0,0 +1,70 @@
+module TicketingHub
+  # Custom error class for rescuing from all GitHub errors
+  class Error < StandardError
+    attr_accessor :response
+
+    def initialize(response=nil)
+      @response = response
+      super build_error_message
+    end
+
+    def response_body
+      @response_body ||=
+        if (body = @response[:body]) && !body.empty?
+          if body.is_a?(String)
+            MultiJson.load(body, :symbolize_keys => true)
+          else
+            body
+          end
+        else
+          nil
+        end
+    end
+
+    private
+
+    def build_error_message
+      return nil  if @response.nil?
+
+      message = if response_body
+        ": #{response_body[:error] || response_body[:message] || ''}"
+      else
+        ''
+      end
+      errors = unless message.empty?
+        response_body[:errors] ?  ": #{response_body[:errors].map{|e|e[:message]}.join(', ')}" : ''
+      end
+      "#{@response[:method].to_s.upcase} #{@response[:url].to_s}: #{@response[:status]}#{message}#{errors}"
+    end
+  end
+
+  # Raised when GitHub returns a 400 HTTP status code
+  class BadRequest < Error; end
+
+  # Raised when GitHub returns a 401 HTTP status code
+  class Unauthorized < Error; end
+
+  # Raised when GitHub returns a 403 HTTP status code
+  class Forbidden < Error; end
+
+  # Raised when GitHub returns a 404 HTTP status code
+  class NotFound < Error; end
+
+  # Raised when GitHub returns a 406 HTTP status code
+  class NotAcceptable < Error; end
+
+  # Raised when GitHub returns a 422 HTTP status code
+  class UnprocessableEntity < Error; end
+
+  # Raised when GitHub returns a 500 HTTP status code
+  class InternalServerError < Error; end
+
+  # Raised when GitHub returns a 501 HTTP status code
+  class NotImplemented < Error; end
+
+  # Raised when GitHub returns a 502 HTTP status code
+  class BadGateway < Error; end
+
+  # Raised when GitHub returns a 503 HTTP status code
+  class ServiceUnavailable < Error; end
+end

data/lib/ticketing_hub/order.rb

@@ -0,0 +1,67 @@
+require 'money'
+require 'active_support'
+
+module TicketingHub
+  class Order < Resource
+    schema do
+      integer :id, :venue_id, :consumer_id
+      float :commission, :total, default: 0
+      string :currency
+      datetime :confirmed_at
+    end
+
+    attr_accessor :consumer_fields
+
+    has_many :tickets
+
+    belongs_to :venue
+    belongs_to :consumer
+
+    def total
+      attributes[:total].to_money currency
+    end
+
+    def commission
+      attributes[:commission].to_money currency
+    end
+
+    def consumer_fields
+      @consumer_fields ||= client.get("venues/#{venue_id}/orders/new")['consumer_fields'].map do |field|
+        HashWithIndifferentAccess.new field
+      end
+    end
+
+    def tickets=(tickets)
+      @tickets = tickets.map { |ticket| Ticket.new ticket, client }
+    end
+
+    def consumer_fields=(fields)
+      @consumer_fields = fields
+      self.consumer = Consumer.from_fields consumer_fields
+    end
+
+    def pdf
+      client.get("orders/#{id}", accept: 'application/pdf')
+    end
+
+    def create attributes={}
+      self.attributes = attributes
+      if tiers = attributes.delete(:tiers)
+        tickets = attributes[:tickets_attributes] ||= []
+        tiers.each do |tier_id, qty|
+          qty.to_i.times { tickets.push tier_id: tier_id.to_i }
+        end
+      end
+
+      if (consumer = attributes.delete(:consumer)).try :persisted?
+        (attributes[:consumer_attributes] ||= {})[:email] = consumer.email
+      end
+
+      venue.orders.build client.post("venues/#{venue_id}/orders", attributes)
+    rescue TicketingHub::BadRequest => error
+      self.tap { errors.add :tickets, error.response_body['message'] }
+    rescue TicketingHub::UnprocessableEntity => error
+      venue.orders.build error.response_body
+    end
+  end
+end

data/lib/ticketing_hub/request.rb

@@ -0,0 +1,80 @@
+require 'multi_json'
+
+module TicketingHub
+  module Request
+
+    def delete(path, options={})
+      request(:delete, path, options).body
+    end
+
+    def get(path, options={})
+      response = request(:get, path, options)
+      body = response.body
+
+      if auto_traversal && body.is_a?(Array)
+        while next_url = links(response)['next']
+          response = request(:get, next_url, options)
+          body += response.body
+        end
+      end
+
+      body
+    end
+
+    def patch(path, options={})
+      request(:patch, path, options).body
+    end
+
+    def post(path, options={})
+      request(:post, path, options).body
+    end
+
+    def put(path, options={})
+      request(:put, path, options).body
+    end
+
+    private
+
+      # Executes the request, checking if it was successful
+      #
+      # @return [Boolean] True on success, false otherwise
+      def boolean_from_response(method, path, options={})
+       request(method, path, options).status == 204
+      rescue TicketingHub::NotFound
+        false
+      end
+
+      def request(method, path, options={})
+        force_urlencoded = options.delete(:force_urlencoded) || false
+        url = options.delete(:endpoint) || api_endpoint
+        conn_options = { force_urlencoded: force_urlencoded, url: url }
+
+        connection(conn_options).send(method) do |request|
+          request.headers['Accept'] =  options.delete(:accept) || 'application/json'
+
+          case method
+          when :get, :delete, :head
+            request.url(path, options)
+          when :patch, :post, :put
+            request.path = path
+            unless options.empty?
+              request.body = force_urlencoded ? options : MultiJson.dump(options)
+            end
+          end
+
+          if TicketingHub.request_host
+            request.headers['Host'] = TicketingHub.request_host
+          end
+        end
+      end
+
+      def links(response)
+        links = ( response.headers["Link"] || "" ).split(', ').map do |link|
+          url, type = link.match(/<(.*?)>; rel="(\w+)"/).captures
+          [ type, url ]
+        end
+
+        Hash[ *links.flatten ]
+      end
+    end
+end

data/lib/ticketing_hub/resource.rb

@@ -0,0 +1,168 @@
+require 'active_model'
+require 'active_support'
+require_relative 'schema'
+require_relative 'collection'
+
+module TicketingHub
+  class Resource
+    extend ActiveModel::Callbacks
+    extend ActiveModel::Naming
+
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+
+    class << self
+      def has_many key
+        attr_accessor key
+        define_method key do
+          klass = "TicketingHub::#{key.to_s.singularize.classify}".constantize
+          value = instance_variable_get "@#{key}"
+          value || Collection.from_association(self, klass).tap do |collection|
+            instance_variable_set "@#{key}", collection
+          end
+        end
+
+        define_method "#{key}=" do |values|
+          klass = "TicketingHub::#{key.to_s.singularize.classify}".constantize
+          instance_variable_set "@#{key}", Collection.new(values.map do |value|
+            value.is_a?(klass) ? value : send(key).build(value)
+          end, self, klass)
+        end
+      end
+
+      def belongs_to key
+        attr_accessor key
+
+        define_method "#{key}=" do |value|
+          klass = "TicketingHub::#{key.to_s.classify}".constantize
+          value = value.is_a?(Hash) ? klass.new(value.merge({
+            foreign_key => id,
+            model_name.singular_route_key => self
+          })) : value
+          send "#{klass.foreign_key}=", value.id
+          instance_variable_set "@#{key}", value
+        end
+
+        define_method key do
+          klass = "TicketingHub::#{key.to_s.classify}".constantize
+          value = instance_variable_get "@#{key}"
+          if value.nil? && (fk = send(klass.foreign_key)).present?
+            klass.find(fk).tap do |record|
+              instance_variable_set "@#{key}", record
+            end
+          else value end
+        end
+      end
+
+      def create attributes={}
+        new.create attributes
+      end
+
+      def model_name
+        @_model_name ||= ActiveModel::Name.new self, TicketingHub
+      end
+
+      def foreign_key
+        name.to_s.foreign_key
+      end
+
+      def default_client
+        TicketingHub::Client.new
+      end
+
+      def all
+        default_client.get(model_name.route_key).map { |attributes| new attributes }
+      end
+
+      def find id
+        new default_client.get("#{model_name.route_key}/#{id}")
+      end
+
+      def schema(&block)
+        if block_given?
+          undefine_attribute_methods @schema.keys if @schema.present?
+          @schema = TicketingHub::Schema.new(&block).tap do |schema|
+            attr_accessor *schema.keys
+            define_attribute_methods schema.keys
+          end
+        else
+          @schema ||= TicketingHub::Schema.new
+        end
+      end
+
+      def endpoint=(value)
+        @endpoint = value unless value.empty?
+      end
+
+      def endpoint
+        @endpoint || model_name.plural
+      end
+    end
+
+    delegate :foreign_key, :model_name, :schema, to: :class
+
+    attr_accessor :client, :errors, :attributes
+    define_model_callbacks :create, :save, :update, :destroy
+
+    def initialize(attributes = {}, client = self.class.default_client)
+      self.client = client
+      self.attributes = attributes
+      @errors = ActiveModel::Errors.new self
+    end
+
+    def ==(other)
+      other.equal?(self) ||
+        (other.instance_of?(self.class) && other.id == id && ! other.new_record?)
+    end
+
+    def ===(other)
+      object.is_a? self
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      id.hash
+    end
+
+    def endpoint
+      new_record?? model_name.plural : [model_name.singular, id].join('/')
+    end
+
+    def create attributes={}
+      throw 'Cannot create existing record.' if persisted?
+      self.attributes = client.post(endpoint, self.attributes.merge(attributes))
+    end
+
+    def new_record?
+      id.nil?
+    end
+
+    def persisted?
+      ! new_record?
+    end
+
+    def attributes
+      schema.keys.each_with_object Hash.new do |key, memo|
+        memo[key.to_sym] = instance_variable_get "@#{key}"
+      end
+    end
+
+    def attributes=(values)
+      values.each do |key, value|
+        send("#{key}=", value) if respond_to? "#{key}="
+      end
+    end
+
+    def column_for_attribute(name)
+      Class.new do
+        def type; schema[name] end
+      end
+    end
+  end
+end

data/lib/ticketing_hub/schema.rb

@@ -0,0 +1,30 @@
+module TicketingHub
+  class Schema
+    KNOWN_ATTRIBUTE_TYPES = %w(string text integer float decimal datetime timestamp time date binary boolean)
+
+    def [] key
+      @attrs[key.to_s].to_sym
+    end
+
+    def initialize &block
+      @attrs = Hash.new
+      instance_eval &block if block_given?
+    end
+
+    def keys
+      @attrs.keys
+    end
+
+    def attribute name, type, options = {}
+      raise ArgumentError, "Unknown Attribute type: #{type.inspect} for key: #{name.inspect}" unless type.nil? || Schema::KNOWN_ATTRIBUTE_TYPES.include?(type.to_s)
+      tap { @attrs[name.to_s] = [type.to_s, options] }
+    end
+
+    KNOWN_ATTRIBUTE_TYPES.each do |type|
+      define_method type do |*args|
+        options = args.last.is_a?(::Hash) ? args.pop : {}
+        args.each { |name| attribute name, type, options }
+      end
+    end
+  end
+end

data/lib/ticketing_hub/ticket.rb

@@ -0,0 +1,23 @@
+require 'money'
+
+module TicketingHub
+  class Ticket < Resource
+    schema do
+      integer :id, :tier_id, :order_id
+      float :commission, :price, default: 0
+      string :code
+    end
+
+    belongs_to :tier
+    belongs_to :order
+    delegate :currency, to: :order
+
+    def price
+      attributes[:price].to_money currency
+    end
+
+    def commission
+      attributes[:commission].to_money currency
+    end
+  end
+end

data/lib/ticketing_hub/tier.rb

@@ -0,0 +1,24 @@
+require 'money'
+
+module TicketingHub
+  class Tier < Resource
+    schema do
+      integer :id, :venue_id
+      string :name
+      text :description
+      float :commission, :price, default: 0
+    end
+
+    attr_accessor :venue
+    delegate :currency, to: :venue
+    belongs_to :venue
+
+    def price
+      attributes[:price].to_money currency
+    end
+
+    def commission
+      attributes[:commission].to_money currency
+    end
+  end
+end

data/lib/ticketing_hub/venue.rb

@@ -0,0 +1,14 @@
+module TicketingHub
+  class Venue < Resource
+    attr_accessor :tiers, :orders
+
+    schema do
+      integer :id
+      string :name, :street_1, :street_2, :city, :region, :postcode, :country, :category, :currency
+      float :lat, :lng
+    end
+
+    has_many :tiers
+    has_many :orders
+  end
+end

data/lib/ticketing_hub/version.rb

@@ -0,0 +1,3 @@
+module TicketingHub
+  VERSION = '0.0.2' unless defined?(TicketingHub::VERSION)
+end

data/spec/helper.rb

@@ -0,0 +1,87 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require 'ticketing_hub'
+require 'rspec'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect! allow: 'coveralls.io'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+def a_delete(url)
+  a_request(:delete, ticketinghub_url(url))
+end
+
+def a_get(url)
+  a_request(:get, ticketinghub_url(url))
+end
+
+def a_patch(url)
+  a_request(:patch, ticketinghub_url(url))
+end
+
+def a_post(url)
+  a_request(:post, ticketinghub_url(url))
+end
+
+def a_put(url)
+  a_request(:put, ticketinghub_url(url))
+end
+
+def stub_delete(url)
+  stub_request(:delete, ticketinghub_url(url))
+end
+
+def stub_get(url)
+  stub_request(:get, ticketinghub_url(url))
+end
+
+def stub_head(url)
+  stub_request(:head, ticketinghub_url(url))
+end
+
+def stub_patch(url)
+  stub_request(:patch, ticketinghub_url(url))
+end
+
+def stub_post(url)
+  stub_request(:post, ticketinghub_url(url))
+end
+
+def stub_put(url)
+  stub_request(:put, ticketinghub_url(url))
+end
+
+def fixture_path
+  File.expand_path("../fixtures", __FILE__)
+end
+
+def fixture(file)
+  File.new(fixture_path + '/' + file)
+end
+
+def json_response(file)
+  { body: fixture(file),
+    headers: { content_type: 'application/json; charset=utf-8' } }
+end
+
+def ticketinghub_url(url)
+  if url =~ /^http/
+    url
+  elsif @client && @client.authenticated?
+    "https://#{@client.token}:#{@client.secret}@api.ticketinghub.com#{url}"
+  else
+    "https://api.ticketinghub.com#{url}"
+  end
+end

data/ticketinghub.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ticketing_hub/version'
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.add_dependency 'addressable', '~> 2.3.3'
+  spec.add_dependency 'faraday', '~> 0.8.6'
+  spec.add_dependency 'faraday_middleware', '~> 0.9.0'
+  spec.add_dependency 'multi_json', '~> 1.6.1'
+  spec.add_dependency 'money', '~> 5.1.1'
+  spec.add_dependency 'activemodel', '>= 3.2.12'
+  spec.authors = ['Oliver Morgan']
+  spec.description = %q{Wrapper for TicketingHub API}
+  spec.email = ['olly@ticketinghub.com']
+  spec.files = %w(.document CONTRIBUTING.md LICENSE.md Rakefile ticketinghub.gemspec)
+  spec.files += Dir['lib/**/*.rb']
+  spec.files += Dir['spec/**/*']
+  spec.homepage = 'https://github.com/ticketinghub/ruby-api'
+  spec.licenses = ['MIT']
+  spec.name = 'ticketinghub'
+  spec.platform = Gem::Platform::RUBY
+  spec.required_ruby_version = '>= 1.9.3'
+  spec.require_paths = ['lib']
+  spec.required_rubygems_version = '>= 1.3.6'
+  spec.summary = spec.description
+  spec.test_files = Dir['spec/**/*']
+  spec.version = TicketingHub::VERSION
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: ticketinghub
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Oliver Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.3
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.1.1
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+description: Wrapper for TicketingHub API
+email:
+- olly@ticketinghub.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- CONTRIBUTING.md
+- LICENSE.md
+- Rakefile
+- ticketinghub.gemspec
+- lib/ticketing_hub/authentication.rb
+- lib/ticketing_hub/client.rb
+- lib/ticketing_hub/collection.rb
+- lib/ticketing_hub/configuration.rb
+- lib/ticketing_hub/connection.rb
+- lib/ticketing_hub/consumer.rb
+- lib/ticketing_hub/error.rb
+- lib/ticketing_hub/order.rb
+- lib/ticketing_hub/request.rb
+- lib/ticketing_hub/resource.rb
+- lib/ticketing_hub/schema.rb
+- lib/ticketing_hub/ticket.rb
+- lib/ticketing_hub/tier.rb
+- lib/ticketing_hub/venue.rb
+- lib/ticketing_hub/version.rb
+- lib/ticketing_hub.rb
+- spec/helper.rb
+- spec/ticketing_hub/venue_spec.rb
+homepage: https://github.com/ticketinghub/ruby-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Wrapper for TicketingHub API
+test_files:
+- spec/helper.rb
+- spec/ticketing_hub/venue_spec.rb
+has_rdoc: