tickethub 0.0.1

data/lib/tickethub/helpers.rb

@@ -0,0 +1,108 @@
+require 'uri'
+
+module Tickethub
+  module Helpers extend self
+    def to_path(*params)
+      params.map(&:to_s).reject(&:empty?) * '/'
+    end
+
+    def camelize(value)
+      value.to_s.split('_').map {|w| w.capitalize }.join
+    end
+
+    def deep_merge(hash, other_hash)
+      hash.merge(other_hash) do |key, oldval, newval|
+        oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+        newval = newval.to_hash if newval.respond_to?(:to_hash)
+        oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? deep_merge(oldval, newval) : newval
+      end
+    end
+
+    # Stolen from Rack:
+
+    DEFAULT_SEP = /[&;] */n
+
+    def to_param(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          to_param(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          to_param(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+        }.join("&")
+      else
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{escape(value)}"
+      end
+    end
+
+    def from_param(param)
+      Rack::Utils.parse_nested_query(param)
+      (value || '').split('&').each do |res|
+        key, value = res.split('=')
+        @params[key] = value
+      end
+    end
+
+    def from_param(qs, d = nil)
+      params = {}
+
+      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
+        k, v = p.split('=', 2).map { |s| unescape(s) }
+
+        normalize_params(params, k, v)
+      end
+
+      params
+    end
+
+    def escape(s)
+      URI.encode_www_form_component(s)
+    end
+
+    if defined?(::Encoding)
+      def unescape(s, encoding = Encoding::UTF_8)
+        URI.decode_www_form_component(s, encoding)
+      end
+    else
+      def unescape(s, encoding = nil)
+        URI.decode_www_form_component(s, encoding)
+      end
+    end
+
+    protected
+
+    def normalize_params(params, name, v = nil)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      return if k.empty?
+
+      if after == ""
+        params[k] = v
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        params[k] << v
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params[k].last.kind_of?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params(params.class.new, child_key, v)
+        end
+      else
+        params[k] ||= params.class.new
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].kind_of?(Hash)
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      return params
+    end
+  end
+end

data/lib/tickethub/request.rb

@@ -0,0 +1,130 @@
+module Tickethub
+  class Request
+    attr_reader :options, :format, :url
+    attr_accessor :params, :body, :method, :headers
+
+    # Connection options
+    attr_accessor :proxy, :user, :password, :auth_type, :timeout, :ssl_options
+
+    def initialize(url, options = {})
+      @url     = url.to_s
+
+      @options = options
+      @options.each do |key, val|
+        method = "#{key}="
+        send(method, val) if respond_to?(method)
+      end
+
+      self.method  ||= :get
+      self.params  ||= {}
+      self.headers ||= {}
+      self.format  ||= :form
+    end
+
+    def format=(mime_or_format)
+      @format = mime_or_format.is_a?(Symbol) ?
+        Formats[mime_or_format].new : mime_or_format
+    end
+
+    def url=(value)
+      @url = value
+      @uri = nil
+      @url
+    end
+
+    def uri
+      return @uri if @uri
+
+      url = @url.match(/\Ahttps?:\/\//) ? @url : "http://#{@url}"
+
+      @uri = URI.parse(url)
+      @uri.path = '/' if @uri.path.empty?
+
+      if @uri.query
+        @params.merge!(Helpers.from_param(@uri.query))
+        @uri.query = nil
+      end
+
+      @uri
+    end
+
+    def path
+      uri.path
+    end
+
+    def execute
+      if encoded?
+        result = connection.send(method, path, encoded, build_headers)
+      else
+        result = connection.send(method, query_path, build_headers)
+      end
+
+      Response.new(result)
+
+    rescue Redirection => error
+      raise error unless error.response['Location']
+
+      location = URI.parse(error.response['Location'])
+
+      # Path is relative
+      unless location.host
+        location = URI.join(uri, location)
+      end
+
+      self.url = location.to_s
+      execute
+    end
+
+    protected
+
+    def connection
+      Connection.new(uri,
+        :proxy       => proxy,
+        :timeout     => timeout,
+        :ssl_options => ssl_options
+      )
+    end
+
+    def content_type_headers
+      if encoded?
+        {'Content-Type' => format.mime_type}
+      else
+        {}
+      end
+    end
+
+    def auth_headers
+      if auth_type == :bearer
+        { 'Authorization' => "Bearer #{@password}" }
+      elsif auth_type == :basic
+        { 'Authorization' => 'Basic ' + ["#{@user}:#{@password}"].pack('m').delete("\r\n") }
+      else
+        { }
+      end
+    end
+
+    def build_headers
+      auth_headers
+        .merge(content_type_headers)
+        .merge(headers)
+    end
+
+    def query_path
+      query_path = path
+
+      if params.any?
+        query_path += '?' + Helpers.to_param(params)
+      end
+
+      query_path
+    end
+
+    def encoded?
+      [:post, :patch].include?(method)
+    end
+
+    def encoded
+      params.any? ? format.encode(params) : body
+    end
+  end
+end

data/lib/tickethub/resource.rb

@@ -0,0 +1,279 @@
+require 'money'
+require 'iso8601'
+require 'timezone'
+require 'countries'
+
+require_relative 'collection'
+
+module Tickethub
+  class Resource
+
+    class << self
+      attr_reader :endpoint
+
+      def all(params = {})
+        Tickethub::Collection.new @endpoint, self, params
+      end
+
+      def polymorphic(type, options = {})
+        self.superclass.register_type type, **options
+      end
+
+      def register_type(type, klass: self, attribute: :type) # klass, attribute
+        registered_types[type] = { klass: klass, attribute: attribute }
+      end
+
+      def registered_types
+        @registered_types ||= {}
+      end
+
+      def scopes
+        @scopes ||= {}
+      end
+
+      def path(value, options = {})
+        @singleton = options.delete(:singleton) || false
+        @endpoint = Tickethub.endpoint[value, options]
+      end
+
+      def scope(key, proc = -> (params = {}) { self.scope key, params })
+        self.scopes[key] = proc
+      end
+
+      def singleton?
+        !! @singleton
+      end
+
+      def attribute(key, options = nil)
+        options.nil?? (self.attributes[key] ||= {}).dup
+          : self.attributes[key] = options
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def load_value(key, value, object)
+        return nil if value.nil? || (value.is_a?(String) && value.empty?)
+        case self.attribute(key)[:type]
+          when :date
+            case value
+              when String then ISO8601::Date.new(value)
+              else raise ArgumentError, 'invalid date value: ' + value
+            end
+          when :datetime
+            case value
+              when String then ISO8601::DateTime.new(value)
+              else raise ArgumentError, 'invalid datetime value: ' + value
+            end
+          when :time
+            case value
+              when String then ISO8601::Time.new(value)
+              else raise ArgumentError, 'invalid time value: ' + value
+            end
+          when :duration
+            case value
+              when String then ISO8601::Duration.new(value)
+              else raise ArgumentError, 'invalid time value: ' + value
+            end
+          when :money
+            currency = Money::Currency.new(object.currency)
+            raise ArgumentError, 'invalid money currency' if currency.blank?
+
+            case value
+              when Fixnum then Money.new(value, currency)
+              when Numeric, String
+                currency = Money::Currency.wrap(currency)
+                Money.new(value.to_d * currency.subunit_to_unit, currency)
+              else raise ArgumentError, 'invalid money value: ' + value
+            end
+          when :currency
+            case value
+              when String then Money::Currency.new(value)
+              else raise ArgumentError, 'invalid currency value: ' + value
+            end            
+          when :timezone
+            case value
+              when String then Timezone::Zone.new(zone: value)
+              else raise ArgumentError, 'invalid timezone value: ' + value
+            end
+          when :country
+            case value
+              when String then Country.new(value)
+              else raise ArgumentError, 'invalid country value: ' + value
+            end
+          else value
+        end
+      end
+
+      def dump_value(key, value)
+        case self.attribute(key)[:type]
+          when :date      then value.iso8601
+          when :datetime  then value.iso8601
+          when :time      then value.iso8601[10..-1]
+          when :duration  then value.iso8601
+          when :money     then value.fractional
+          when :timezone  then value.zone
+          when :country   then value.alpha2
+          when :currency  then value.iso_code
+          else value
+        end
+      end
+
+      def serialize(attributes)
+        attributes.collect do |key, value|
+          [key, dump_value(key, value)]
+        end.to_h
+      end
+
+      def load(endpoint, attributes = nil)
+        attributes ||= endpoint.get
+
+        klass = registered_types.find do |type, options|
+          attributes[options[:attribute].to_s] == type
+        end
+
+        klass = klass ? klass[1][:klass] : self
+
+        if id = attributes['id']
+          endpoint = klass.endpoint[id, endpoint.options]
+        end
+
+        klass.new endpoint, attributes
+      end
+
+      def association(key, klass, path: key)
+        define_method key do
+          instance_variable_defined?("@#{key}") ? instance_variable_get("@#{key}") :
+            instance_variable_set("@#{key}", klass.load(@endpoint[path]))
+        end
+
+        define_method "#{key}=" do |value|
+          instance_variable_set "@#{key}", ((value.nil? || value.is_a?(klass)) ? value :
+            klass.load(@endpoint[path], value))
+        end
+      end
+
+      def collection(key, klass, path: key, &block)
+
+        define_method key do |params = {}|
+          (instance_variable_defined?("@#{key}") ? instance_variable_get("@#{key}") :
+            (sinleton? || id?) ? instance_variable_set("@#{key}",
+              Tickethub::Collection.new(@endpoint[path], klass, params)) : []).tap do |collection|
+                collection.instance_eval &block if block
+              end
+        end
+
+        define_method "#{key}=" do |values|
+          instance_variable_set "@#{key}", (singleton? || id?) ?
+            (Tickethub::Collection.new(@endpoint[path], klass).tap do |collection|
+              collection.cache = values
+            end) : values.collect { |value| klass.load @endpoint, value }
+        end
+      end
+    end
+
+    attr_accessor :endpoint
+
+    def initialize(endpoint, attributes = nil)
+      @endpoint = endpoint
+      attributes ||= endpoint.get
+
+      self.load attributes
+    end
+
+    def valid?
+      errors.nil? || errors.valid?
+    end
+
+    def update(attributes)
+      self.load @endpoint.patch(attributes).decoded
+      return true
+    rescue Tickethub::ResourceInvalid => err
+      self.load Tickethub::Response.new(err.response).decoded
+      return false
+    end
+
+    def destroy
+      self.load @endpoint.delete.decoded
+    end
+
+    def singleton?
+      !! @singleton
+    end
+
+    def respond_to?(method, include_priv = false)
+      @attributes.key?(method.to_s.remove(/[=\?]\Z/).to_sym) || super
+    end
+
+    def reload!
+      self.load @endpoint.get
+    end
+
+    def load(attributes)
+      @attributes = {}
+      attributes.each do |key, value|
+        send "#{key}=", value
+      end
+      return self
+    end
+
+    def [](key)
+      send key
+    end
+
+    def []=(key, value)
+      send "#{key}=", value
+    end
+
+    def ==(other)
+      self.hash == other.hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      id?? id.hash : super
+    end
+
+    def to_param
+      self.id
+    end
+
+    def errors
+      @errors ||= Tickethub::Errors.new @attributes[:errors]
+    end
+
+    def to_h
+      @attributes
+    end
+
+    def to_s
+      self.id?? id : super
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_h}>"
+    end
+
+    protected
+
+    def method_missing(method, *arguments)
+      if match = method.to_s.match(/^(.+)(=|\?)$/)
+        key = match[1].to_sym
+
+        case match[2]
+          when '='
+            @attributes[key] = self.class
+              .load_value(key, arguments.first, self)
+          when "?"
+            !! @attributes[key]
+        end
+      else
+        @attributes.key?(method) ? @attributes[method] : super
+      end
+    end
+  end
+end

data/lib/tickethub/response/headers.rb

@@ -0,0 +1,31 @@
+module Tickethub
+  class Response #:nodoc:
+    class Headers
+      include ::Net::HTTPHeader
+
+      def initialize(header = {})
+        @header = header
+      end
+
+      def ==(other)
+        @header == other
+      end
+
+      def inspect
+        @header.inspect
+      end
+
+      def method_missing(name, *args, &block)
+        if @header.respond_to?(name)
+          @header.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method)
+        super || @header.respond_to?(method)
+      end
+    end
+  end
+end

data/lib/tickethub/response.rb

@@ -0,0 +1,49 @@
+module Tickethub
+  class Response
+    attr_reader :response, :body, :headers, :parser
+
+    def initialize(response, parser = nil)
+      @response = response
+      @body     = response.body
+      @headers  = Headers.new(response.to_hash)
+      @format   = Formats.for(headers.content_type)
+      @parser ||= @format && @format.new
+    end
+
+    def as_json
+      decoded
+    end
+
+    def to_json(*)
+      as_json.to_json
+    end
+
+    def code
+      response.code.to_i
+    end
+
+    alias_method :status, :code
+
+    def decoded
+      @decoded ||= parser ? parser.decode(body) : body
+    end
+
+    def respond_to?(name)
+      super || decoded.respond_to?(name) || response.respond_to?(name)
+    end
+
+    protected
+
+    def method_missing(name, *args, &block)
+      if decoded.respond_to?(name)
+        decoded.send(name, *args, &block)
+      elsif response.respond_to?(name)
+        response.send(name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end
+
+require_relative 'response/headers'

data/lib/tickethub/supplier/answer.rb

@@ -0,0 +1,11 @@
+require_relative '../resource'
+
+module Tickethub
+  class Supplier::Answer < Resource
+    path '/supplier/answers'
+
+    require_relative 'question'
+
+    association :question, Supplier::Question
+  end
+end

data/lib/tickethub/supplier/app.rb

@@ -0,0 +1,9 @@
+module Tickethub
+  class Supplier::App < Resource
+    path '/apps'
+
+    require_relative 'package'
+
+    collection :packages, Supplier::Package
+  end
+end

data/lib/tickethub/supplier/bill.rb

@@ -0,0 +1,11 @@
+require_relative '../resource'
+
+module Tickethub
+  class Supplier::Bill < Resource
+    path '/supplier/bills'
+
+    require_relative 'receipt'
+
+    collection :receipts, Supplier::Receipt
+  end
+end

data/lib/tickethub/supplier/booking.rb

@@ -0,0 +1,39 @@
+require_relative '../resource'
+
+module Tickethub
+  class Supplier::Booking < Resource
+    path '/supplier/bookings'
+
+    require_relative 'rate'
+    require_relative 'order'
+    require_relative 'ticket'
+    require_relative 'answer'
+    require_relative 'product'
+    require_relative 'variant'
+    require_relative 'message'
+    require_relative 'fee'
+
+    collection :tickets, Supplier::Ticket
+    collection :answers, Supplier::Answer
+    collection :messages, Supplier::Message
+    collection :fees, Supplier::Fee
+
+    association :order, Supplier::Order
+    association :rate, Supplier::Rate
+    association :coupon, Supplier::Coupon
+    association :product, Supplier::Product
+    association :variant, Supplier::Variant
+
+    attribute :amount, type: :money
+    attribute :tax, type: :money
+    attribute :total, type: :money
+
+    attribute :currency, type: :currency
+    attribute :valid_from, type: :datetime
+    attribute :expires_at, type: :datetime
+    attribute :timeout_at, type: :datetime
+    attribute :created_at, type: :datetime
+    attribute :updated_at, type: :datetime
+    attribute :cancelled_at, type: :datetime
+  end
+end

data/lib/tickethub/supplier/card.rb

@@ -0,0 +1,11 @@
+require_relative '../resource'
+
+module Tickethub
+  class Supplier::Card < Resource
+    path '/supplier/cards'
+
+    require_relative 'payment'
+
+    collection :payments, Supplier::Payment
+  end
+end

data/lib/tickethub/supplier/coupon.rb

@@ -0,0 +1,14 @@
+require_relative '../resource'
+
+module Tickethub
+  class Supplier::Coupon < Resource
+    path '/supplier/coupons'
+
+    require_relative 'booking'
+    require_relative 'product'
+
+    collection :bookings, Supplier::Booking
+
+    association :product, Supplier::Product
+  end
+end