tickethub 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d3318c8a3beae9788a9da8e2b31ef7f013f70ec
+  data.tar.gz: 566e852760436eea922e39ed659e71f91597da50
+SHA512:
+  metadata.gz: 4fa2a0d645c5d6c8d167387289ca4d2294c38facd25d7a67c090a1c44cd1615ae8c5a2ae1d732b4b8826a9063085d406d5fc20886c1f04f308a2795e48fe1e2a
+  data.tar.gz: 2284002231679ecee50ae1a29ded39dfb589796d60d7f68f330589d75310ed7bf55f69a91e4e2c4ba843e4f91421ed6602763d3a7397a27983ec152c6a929504

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/Gemfile

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

data/lib/tickethub/address.rb

@@ -0,0 +1,5 @@
+module Tickethub
+  class Address < Resource
+    # read_only!
+  end
+end

data/lib/tickethub/app/package.rb

@@ -0,0 +1,9 @@
+module Tickethub
+  class App::Package < Resource
+    path '/app/packages'
+
+    require_relative '../app'
+
+    association :app, Tickethub::App
+  end
+end

data/lib/tickethub/app/subscription.rb

@@ -0,0 +1,11 @@
+require_relative '../resource'
+
+module Tickethub
+  class App::Subscription < Resource
+    path '/app/subscriptions'
+
+    require_relative 'package'
+
+    association :package, App::Package
+  end
+end

data/lib/tickethub/app.rb

@@ -0,0 +1,36 @@
+module Tickethub
+  class App < Resource
+    path '/apps'
+
+    require_relative 'contact'
+    require_relative 'category'
+    require_relative 'app/package'
+    require_relative 'app/subscription'
+
+    association :contact, Tickethub::Contact
+    association :token, Tickethub::Token
+    association :category, Tickethub::Category
+
+    collection :packages, App::Package
+    collection :subscriptions, App::Subscription
+
+    attribute :currency, type: :currency
+
+    def self.[](attributes)
+      token = attributes[:token].is_a?(String) ? attributes[:token]
+        : attributes[:token][:access_token]
+      self.new Tickethub.endpoint['/app', auth_type: :bearer, password: token]
+    end
+
+    def initialize(endpoint, attributes = nil)
+      attributes ||= endpoint.get
+
+      if attributes['token']
+        endpoint = Tickethub.endpoint['/app', {
+          auth_type: :bearer, password: attributes['token']['access_token'] }]
+      end
+
+      super(endpoint, attributes)
+    end
+  end
+end

data/lib/tickethub/category.rb

@@ -0,0 +1,7 @@
+module Tickethub
+  class Category < Resource
+    path '/categories'
+
+    collection :apps, Tickethub::App
+  end
+end

data/lib/tickethub/collection.rb

@@ -0,0 +1,150 @@
+require_relative 'helpers'
+
+module Tickethub
+  class Collection < Enumerator
+    attr_accessor :cache
+    attr_reader :count, :endpoint
+
+    def initialize(endpoint, klass, params = {})
+      @params = params.dup
+      @endpoint = endpoint
+      @klass = klass
+
+      klass.registered_types.each do |type, options|
+        define_singleton_method type do
+          instance_variable_defined?("@#{type}") ? instance_variable_get("@#{type}") :
+            instance_variable_set("@#{type}", Tickethub::Collection.new(@endpoint[type], options[:klass]))
+        end
+      end
+
+      klass.scopes.each do |key, block|
+        define_singleton_method key, &block
+      end
+
+      super() do |yielder|
+        self.reload! if @cache.nil?
+
+        @cache.each do |row|
+          yielder << @klass.load(@endpoint, row)
+        end
+
+        while @cache.length < @count
+          offset = @offset + @cache.length
+          response = @endpoint.get @params.merge(offset: @cache.length)
+          response.decoded.each do |row| @cache << row
+            yielder << @klass.load(@endpoint, row)
+          end
+        end
+      end
+    end
+
+    def reload!
+      @cache = (response = @endpoint.get @params).decoded
+      @count, @offset, @limit =
+        response.status == 206 ? 
+          response.headers.values_at(*%w(x-total-count x-offset x-limit))
+            .collect { |value| value[0].to_i } : [@cache.length, 0, @cache.length]
+    end
+
+    def limit(value = nil)
+      if value.nil?
+        reload! if @limit.nil?
+        return @limit
+      else
+        self.class.new @endpoint, @klass,
+          @params.merge(limit: value)
+      end
+    end
+
+    def offset(value = nil)
+      if value.nil?
+        reload! if @offset.nil?
+        return @offset
+      else
+        self.class.new @endpoint, @klass,
+          @params.merge(offset: value)
+      end
+    end
+
+    def filter(value)
+      self.class.new @endpoint, @klass,
+        @params.merge(filters: (@params[:filters] || {}).merge(value))
+    end
+
+    def filters
+      @params[:filters].dup
+    end
+
+    def order(value = nil)
+      return @params[:order].dup if value.nil?
+      order = (@params[:order] || []) + (case value
+        when Symbol, String then [value.to_s]
+        when Hash
+          value.collect do |key, direction|
+            direction.to_s == 'desc' ? "-#{key}" : key
+          end
+        end)
+
+      self.class.new @endpoint, @klass,
+        @params.merge(order: order)
+    end
+
+    [:get, :post, :patch, :delete].each do |key|
+      define_method key do |path, params = {}, options = {}|
+        endpoint = (if path.is_a? Hash
+          params, options = [path, params]
+          self.endpoint
+        else self.endpoint[path] end)
+
+        if (response = endpoint.send(key, @params.merge(params), options)).body.length > 2
+          return response.decoded
+        end
+      end
+    end
+
+    def empty?
+      count.zero?
+    end
+
+    def any?(&block)
+      block_given?? super : ! empty?
+    end
+
+    def limit
+      self.reload! if @limit.nil?
+      return @limit
+    end
+
+    def count
+      self.reload! if @count.nil?
+      return @count
+    end
+
+    def [](*args)
+      case (key = args[0])
+      when Fixnum
+        self.offset(key).first
+      when Hash
+        self.filter(key).first
+      when Range
+        self.offset(key.min).first(key.max)
+      when String
+        options = { params: args[1] || {} }.merge args[2] || {}
+        @klass.load(@endpoint[nil, options], 'id' => key).reload!
+      else
+        raise ArgumentError, 'invalid search value type'
+      end
+    end
+
+    def create(attributes = {})
+      @klass.new @endpoint, @endpoint.post(attributes).decoded
+    rescue Tickethub::ResourceInvalid => err
+      @klass.new @endpoint, Tickethub::Response.new(err.response).decoded
+    end
+
+    def scope(key, params = {}, options = {})
+      Tickethub::Collection.new @endpoint[key, options.merge(params: params)], @klass,
+        filters: @filters, order: @order
+    end
+  end
+end

data/lib/tickethub/connection.rb

@@ -0,0 +1,140 @@
+require 'uri'
+require 'net/https'
+
+module Tickethub
+  class Connection
+    UriParser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+
+    attr_accessor :timeout, :ssl_options
+    attr_reader :endpoint, :timeout, :proxy, :ssl_options
+
+    # The +endpoint+ parameter is required and will set the +endpoint+
+    # attribute to the URI for the remote resource service.
+    def initialize(endpoint, options = {})
+      self.endpoint = endpoint
+
+      options.each do |key, value|
+        self.send("#{key}=", value) unless value.nil?
+      end
+    end
+
+    # Set URI for remote service.
+    def endpoint=(endpoint)
+      @endpoint = endpoint.is_a?(URI) ? endpoint : UriParser.parse(endpoint)
+    end
+
+    # Set the proxy for remote service.
+    def proxy=(proxy)
+      @proxy = proxy.is_a?(URI) ? proxy : UriParser.parse(proxy)
+    end
+
+    def get(path, headers = {}, &block)
+      request(:get, path, headers, &block)
+    end
+
+    def delete(path, headers = {}, &block)
+      request(:delete, path, headers, &block)
+    end
+
+    def head(path, headers = {}, &block)
+      request(:head, path, headers, &block)
+    end
+
+    def patch(path, body = '', headers = {}, &block)
+      request(:patch, path, body, headers, &block)
+    end
+
+    def post(path, body = '', headers = {}, &block)
+      request(:post, path, body, headers, &block)
+    end
+
+    protected
+
+    # Makes a request to the remote service.
+    def request(method, path, *arguments)
+      response = http.send(method, path, *arguments)
+      handle_response(response)
+
+    rescue Timeout::Error => e
+      raise TimeoutError.new(e.message)
+    rescue OpenSSL::SSL::SSLError => e
+      raise SSLError.new(e.message)
+    end
+
+    # Handles response and error codes from the remote service.
+    def handle_response(response)
+      case response.code.to_i
+        when 301,302
+          raise Redirection.new(response)
+        when 200...400
+          response
+        when 400
+          raise BadRequest.new(response)
+        when 401
+          raise UnauthorizedAccess.new(response)
+        when 403
+          raise ForbiddenAccess.new(response)
+        when 404
+          raise ResourceNotFound.new(response)
+        when 405
+          raise MethodNotAllowed.new(response)
+        when 409
+          raise ResourceConflict.new(response)
+        when 410
+          raise ResourceGone.new(response)
+        when 422
+          raise ResourceInvalid.new(response)
+        when 401...500
+          raise ClientError.new(response)
+        when 500...600
+          raise ServerError.new(response)
+        else
+          raise ConnectionError.new(
+            response, "Unknown response code: #{response.code}"
+          )
+      end
+    end
+
+    # Creates new Net::HTTP instance for communication with the
+    # remote service and resources.
+    def http
+      configure_http(new_http)
+    end
+
+    def new_http
+      if proxy
+        Net::HTTP.new(endpoint.host, endpoint.port,
+                      proxy.host, proxy.port,
+                      proxy.user, proxy.password)
+      else
+        Net::HTTP.new(endpoint.host, endpoint.port)
+      end
+    end
+
+    def configure_http(http)
+      http = apply_ssl_options(http)
+
+      # Net::HTTP timeouts default to 60 seconds.
+      if timeout
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+      end
+
+      http
+    end
+
+    def apply_ssl_options(http)
+      return http unless endpoint.is_a?(URI::HTTPS)
+
+      http.use_ssl     = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      return http unless ssl_options
+
+      ssl_options.each do |key, value|
+        http.send("#{key}=", value)
+      end
+
+      http
+    end
+  end
+end

data/lib/tickethub/contact.rb

@@ -0,0 +1,5 @@
+module Tickethub
+  class Contact < Resource
+    # read_only!
+  end
+end

data/lib/tickethub/endpoint.rb

@@ -0,0 +1,36 @@
+require_relative 'request'
+require_relative 'response'
+require_relative 'helpers'
+
+module Tickethub
+  class Endpoint
+    attr_reader :options, :url
+
+    def initialize(url, options = {})
+      @url     = url
+      @options = options
+    end
+
+    def [](suburl, options = {})
+      url = (if suburl.nil? then self.url
+        else
+          suburl = suburl.to_s
+          base   = self.url
+          base  += "/" unless base =~ /\/$/
+          URI.join(base, suburl).to_s
+        end)
+
+      self.class.new url, Tickethub::Helpers.deep_merge(@options, options)
+    end
+
+    [:get, :post, :delete, :patch].each do |method|
+      define_method method do |params = {}, options = {}|
+        request options.merge(method: method, params: params)
+      end
+    end
+
+    def request(options = {})
+      Tickethub::Request.new(url, Tickethub::Helpers.deep_merge(@options, options)).execute
+    end
+  end
+end

data/lib/tickethub/errors.rb

@@ -0,0 +1,34 @@
+module Tickethub
+  class Errors
+
+    def initialize(errors)
+      @errors = errors || {}
+    end
+
+    def full_messages_for(attribute)
+      send attribute
+    end
+
+    def on(attribute)
+      @errors[attribute.to_s]
+    end
+
+    def valid?(attribute)
+      send(attribute).empty?
+    end
+
+    def invalid?(attribute)
+      send(attribute).any?
+    end
+
+    def [](key)
+      send key
+    end
+
+    protected
+
+      def method_missing(method, *arguments)
+        on(method) || []
+      end
+  end
+end

data/lib/tickethub/exceptions.rb

@@ -0,0 +1,73 @@
+module Tickethub
+  class ConnectionError < StandardError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      message = "Failed."
+      message << "  Response code = #{response.code}." if response.respond_to?(:code)
+      message << "  Response message = #{response.message}." if response.respond_to?(:message)
+      message << "  Response Body = #{response.body}." if response.respond_to?(:body)
+      message
+    end
+  end
+
+  # Raised when a Timeout::Error occurs.
+  class TimeoutError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
+  # Raised when a OpenSSL::SSL::SSLError occurs.
+  class SSLError < ConnectionError
+    def initialize(message)
+      @message = message
+    end
+    def to_s; @message ;end
+  end
+
+  # 3xx Redirection
+  class Redirection < ConnectionError # :nodoc:
+    def to_s; response['Location'] ? "#{super} => #{response['Location']}" : super; end
+  end
+
+  # 4xx Client Error
+  class ClientError < ConnectionError; end # :nodoc:
+
+  # 400 Bad Request
+  class BadRequest < ClientError; end # :nodoc
+
+  # 401 Unauthorized
+  class UnauthorizedAccess < ClientError; end # :nodoc
+
+  # 403 Forbidden
+  class ForbiddenAccess < ClientError; end # :nodoc
+
+  # 404 Not Found
+  class ResourceNotFound < ClientError; end # :nodoc:
+
+  # 409 Conflict
+  class ResourceConflict < ClientError; end # :nodoc:
+
+  # 410 Gone
+  class ResourceGone < ClientError; end # :nodoc:
+
+  # 422 Invalid
+  class ResourceInvalid < ClientError; end # :nodoc:
+
+  # 5xx Server Error
+  class ServerError < ConnectionError; end # :nodoc:
+
+  # 405 Method Not Allowed
+  class MethodNotAllowed < ClientError # :nodoc:
+    def allowed_methods
+      @response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
+    end
+  end
+end

data/lib/tickethub/formats/form_format.rb

@@ -0,0 +1,17 @@
+module Tickethub
+  module Formats
+    class FormFormat < Format
+      def mime_type
+        'application/x-www-form-urlencoded'
+      end
+
+      def encode(params, options = nil)
+        Helpers.to_param(params)
+      end
+
+      def decode(body)
+        body
+      end
+    end
+  end
+end

data/lib/tickethub/formats/json_format.rb

@@ -0,0 +1,25 @@
+begin
+  require 'json'
+rescue LoadError => e
+  require 'json/pure'
+end
+
+module Tickethub
+  module Formats
+    class JSONFormat < Format
+      def mime_type
+        'application/json'
+      end
+
+      def encode(hash, options = nil)
+        hash.to_json(options)
+      end
+
+      def decode(json)
+        JSON.parse(json)
+      end
+    end
+
+    JsonFormat = JSONFormat
+  end
+end

data/lib/tickethub/formats.rb

@@ -0,0 +1,35 @@
+module Tickethub
+  module Formats
+    class Format
+      def mime_type
+      end
+
+      def encode(*args)
+      end
+
+      def decode(*args)
+      end
+    end
+
+    MAPPING = {
+      'application/json' => :json
+    }
+
+    def self.for(type)
+      format = MAPPING[type]
+      format && self[format]
+    end
+
+    # Lookup the format class from a mime type reference symbol. Example:
+    #
+    #   Tickethub::Formats[:json] # => Tickethub::Formats::JsonFormat
+    def self.[](mime_type_reference)
+      Tickethub::Formats.const_get(Helpers.camelize(mime_type_reference.to_s) + 'Format')
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/formats/*.rb'].sort.each do |path|
+  filename = File.basename(path)
+  require_relative "formats/#{filename}"
+end