teamsnap_rb 0.0.8 → 1.0.0.beta1

data/lib/teamsnap_rb/collection.rb

@@ -1,179 +0,0 @@
-module TeamsnapRb
-  class Collection
-    include Enumerable
-
-    attr_reader :errors
-
-    TYPE_TO_CLASS = {
-      "Event" => Event
-    }
-
-    def initialize(url, query_parameters, config, options = {})
-      request = options.fetch(:request, nil)
-
-      self.config = config
-      data = request || get(url, query_parameters)
-      self.errors = []
-      self.url = data.env["url"]
-      body = data.body
-
-      if data.success?
-        deserializer = Conglomerate::TreeDeserializer.new(JSON.parse(body))
-        self.collection_json = deserializer.deserialize
-        self.items = collection_json.items.map do |item|
-          type_name = item.data.find do |datum|
-            datum.name == "type"
-          end.value
-
-          klass = TYPE_TO_CLASS[type_name] || Item
-          klass.new(item, config)
-        end
-
-        if collection_json.error
-          errors << collection_json.error.message
-        end
-      else
-        errors << data.status.to_s
-      end
-
-      handle_error(errors)
-    end
-
-    def [](index)
-      items[index]
-    end
-
-    def each
-      items.each do |item|
-        yield item
-      end
-    end
-
-    def where(attribute_hash)
-      CollectionWhereProxy.new(items).where(attribute_hash)
-    end
-
-    def href
-      collection_json.href
-    end
-
-    def method_missing(method, *args)
-      if links.respond_to?(method)
-        links.send(method)
-      elsif queries.respond_to?(method)
-        queries.send(method, *args)
-      else
-        super
-      end
-    end
-
-    def respond_to?(method)
-      links.respond_to?(method) || queries.respond_to?(method)
-    end
-
-    def links
-      @links ||= LinksProxy.new(collection_json.links, config)
-    end
-
-    def queries
-      @queries ||= QueriesProxy.new(collection_json.queries, config)
-    end
-
-    def template
-      @template ||= Template.new(collection_json.template, config, href)
-    end
-
-    def commands
-      @commands ||= CommandsProxy.new(collection_json.commands, config)
-    end
-
-    def error
-      errors
-    end
-
-    def error?
-      errors.count > 0
-    end
-
-    def size
-      items.size
-    end
-
-    def present?
-      items.size > 0
-    end
-
-    def blank?
-      items.size == 0
-    end
-
-    private
-
-    attr_accessor :collection_json, :config, :items, :url
-    attr_writer :errors
-
-    def get(url, query_parameters = {})
-      RequestBuilder.new(config, url).connection.get do |conn|
-        query_parameters.each do |key, value|
-          conn.params[key] = value
-        end
-      end
-    end
-
-    def this_href
-      collection_json.links.find { |l| l.rel == "self" }.href
-    end
-
-    def handle_error(errors)
-      if errors.include?("401")
-        raise HttpError, "401 Unauthorized for #{url}"
-      end
-    end
-
-    class CollectionWhereProxy
-      include Enumerable
-
-      def initialize(items)
-        self.items = items
-      end
-
-      def [](index)
-        items[index]
-      end
-
-      def each
-        items.each do |item|
-          yield item
-        end
-      end
-
-      def size
-        items.size
-      end
-
-      def present?
-        items.size > 0
-      end
-
-      def blank?
-        items.size == 0
-      end
-
-      def where(attribute_hash)
-        CollectionWhereProxy.new(find_all do |item|
-          attribute_hash.keys.all? do |key|
-            if item.respond_to?(key)
-              attribute_hash[key] == item.send(key)
-            else
-              false
-            end
-          end
-        end)
-      end
-
-      private
-
-      attr_accessor :items
-    end
-  end
-end

data/lib/teamsnap_rb/command.rb

@@ -1,39 +0,0 @@
-module TeamsnapRb
-  class Command
-    def initialize(command, config)
-      self.command = command
-      self.config = config
-    end
-
-    def execute(attrs = {})
-      post(attrs.flatten.first)
-    end
-
-    def rel
-      command.rel
-    end
-
-    def href
-      command.href
-    end
-
-    def prompt
-      command.prompt
-    end
-
-    def data
-      command.data.map(&:name)
-    end
-
-    private
-
-    def post(attrs = {})
-      RequestBuilder.new(config, href).connection.post do |conn|
-        conn.body = attrs.to_json
-        conn.headers['Content-Type'] = 'application/json'
-      end
-    end
-
-    attr_accessor :command, :config
-  end
-end

data/lib/teamsnap_rb/commands.rb

@@ -1,40 +0,0 @@
-module TeamsnapRb
-  class CommandsProxy
-    include Enumerable
-
-    def initialize(commands, config)
-      self.config = config
-      self.commands = commands.inject({}) do |h, command|
-        h.tap do |hash|
-          hash[command.rel.to_sym] = Command.new(command, config)
-        end
-      end
-    end
-
-    def method_missing(method, *args)
-      if command = commands[method.to_sym]
-        command.execute(args)
-      else
-        super
-      end
-    end
-
-    def respond_to?(method)
-      commands.include?(method.to_sym) || super
-    end
-
-    def each
-      commands.values.each do |command|
-        yield command
-      end
-    end
-
-    def rels
-      commands.keys
-    end
-
-    private
-
-    attr_accessor :commands, :config
-  end
-end

data/lib/teamsnap_rb/config.rb

@@ -1,14 +0,0 @@
-module TeamsnapRb
-  class Config
-    attr_accessor :access_token, :client_id, :client_secret, :request_middleware, :response_middleware, :authorization
-
-    def initialize(options = {})
-      self.authorization = options.fetch(:authorization, nil)
-      self.access_token = options.fetch(:access_token, nil)
-      self.client_secret = options.fetch(:client_secret, nil)
-      self.client_id = options.fetch(:client_id, nil)
-      self.response_middleware = []
-      self.request_middleware = []
-    end
-  end
-end

data/lib/teamsnap_rb/exceptions.rb

@@ -1,3 +0,0 @@
-module TeamsnapRb
-  class HttpError < StandardError; end
-end

data/lib/teamsnap_rb/item.rb

@@ -1,136 +0,0 @@
-module TeamsnapRb
-  class Item
-    class << self
-      attr_accessor :templates
-    end
-    @templates = {}
-
-    def initialize(item, config)
-      self.config = config
-      self.item = item
-    end
-
-    def href
-      item.href
-    end
-
-    def data
-      item.data
-    end
-
-    def template
-      self.class.templates[type] ||= fetch_template
-    end
-
-    def this
-      @this ||= Collection.new(href, {}, config)
-    end
-
-    def links
-      @links ||= LinksProxy.new(item.links, config)
-    end
-
-    def commands
-      @commands ||= CommandsProxy.new(this.commands, config)
-    end
-
-    def delete
-      response = delete_href(href)
-      if response.status == 204
-        true
-      else
-        raise FailedToDelete
-      end
-    end
-
-    def with(attrs)
-      attrs = Hash[attrs.map{ |k, v| [k.to_s, v] }]
-      dirtied_attrs = attrs.keys
-      attrs = attributes.merge(attrs)
-
-      new_data = attrs.inject([]) do |arr, (key, value)|
-        arr << Conglomerate::Datum.new(:name => key, :value => value)
-      end
-
-      item = Conglomerate::Item.new(
-        :href => href,
-        :data => new_data
-      )
-
-      Item.new(item, config).tap do |it|
-        it.send(:dirty, dirtied_attrs)
-      end
-    end
-
-    def save
-      attrs_to_update = dirty_attributes.inject({}) do |h, attr|
-        h.tap do |hash|
-          hash[attr] = attributes[attr]
-        end
-      end
-
-      request = RequestBuilder.new(config, href).connection.patch do |conn|
-        conn.body = template.build(attrs_to_update).to_json
-        conn.headers["Content-Type"] = "application/json"
-      end
-
-      Collection.new(nil, nil, config, :request => request)
-    end
-
-    def method_missing(method, *args)
-      if datum = data.find { |d| d.name == method.to_s }
-        unless instance_variable_get("@#{method}_datum")
-          instance_variable_set("@#{method}_datum", datum.value)
-        end
-
-        instance_variable_get("@#{method}_datum")
-      elsif links.respond_to?(method)
-        links.send(method)
-      elsif commands.respond_to?(method)
-        commands.send(method, args)
-      else
-        super
-      end
-    end
-
-    def respond_to?(method)
-      if data.find { |d| d.name == method.to_s }
-        true
-      elsif
-        links.respond_to?(method)
-      elsif
-        commands.respond_to?(method)
-      end
-    end
-
-    private
-
-    def attributes
-      @attributes ||= data.inject({}) do |h, datum|
-        h.tap do |hash|
-          hash[datum.name] = datum.value
-        end
-      end
-    end
-
-    def delete_href(href)
-      RequestBuilder.new(config, href).connection.delete
-    end
-
-    def dirty(attrs)
-      self.dirty_attributes = attrs
-    end
-
-    def fetch_template
-      this.template
-    end
-
-    def fetch_commands
-      this.commands
-    end
-
-    attr_accessor :item, :config, :dirty_attributes
-  end
-
-  class FailedToDelete < StandardError;end;
-end

data/lib/teamsnap_rb/link.rb

@@ -1,24 +0,0 @@
-module TeamsnapRb
-  class Link
-    def initialize(link, config)
-      self.config = config
-      self.link = link
-    end
-
-    def follow
-      @collection ||= Collection.new(href, {}, config)
-    end
-
-    def rel
-      link.rel
-    end
-
-    def href
-      link.href
-    end
-
-    private
-
-    attr_accessor :config, :link
-  end
-end

data/lib/teamsnap_rb/links_proxy.rb

@@ -1,40 +0,0 @@
-module TeamsnapRb
-  class LinksProxy
-    include Enumerable
-
-    def initialize(links, config)
-      self.config = config
-      self.links = links.inject({}) do |h, link|
-        h.tap do |hash|
-          hash[link.rel.to_sym] = Link.new(link, config)
-        end
-      end
-    end
-
-    def method_missing(method, *args)
-      if link = links[method.to_sym]
-        link.follow
-      else
-        super
-      end
-    end
-
-    def respond_to?(method)
-      links.include?(method.to_sym) || super
-    end
-
-    def each
-      links.values.each do |link|
-        yield link
-      end
-    end
-
-    def rels
-      links.keys
-    end
-
-    private
-
-    attr_accessor :links, :config
-  end
-end

data/lib/teamsnap_rb/models/event.rb

@@ -1,4 +0,0 @@
-module TeamsnapRb
-  class Event < Item
-  end
-end

data/lib/teamsnap_rb/models/user.rb

@@ -1,4 +0,0 @@
-module TeamsnapRb
-  class User
-  end
-end

data/lib/teamsnap_rb/queries_proxy.rb

@@ -1,68 +0,0 @@
-module TeamsnapRb
-  class QueriesProxy
-    include Enumerable
-
-    def initialize(queries, config)
-      self.config = config
-      self.queries = queries.inject({}) do |h, query|
-        h.tap do |hash|
-          hash[query.rel.to_sym] = Query.new(query.href, query.data, config)
-        end
-      end
-    end
-
-    def method_missing(method, *args)
-      if query = queries[method.to_sym]
-        query.get(*args)
-      else
-        super
-      end
-    end
-
-    def respond_to?(method)
-      queries.include?(method.to_sym) || super
-    end
-
-    def each
-      queries.values.each do |query|
-        yield query
-      end
-    end
-
-    def rels
-      queries.keys
-    end
-
-    private
-
-    attr_accessor :queries, :config
-  end
-
-  class Query
-    MissingQueryParameter = Class.new(StandardError)
-
-    def initialize(url, data, config)
-      self.url = url
-      self.data = data
-      self.config = config
-    end
-
-    def get(query_parameters={})
-      possible_params = data.map(&:name).map(&:to_sym)
-      query_parameters.reject! { |key, value| !possible_params.include?(key) }
-
-      if query_parameters.empty?
-        raise(
-          MissingQueryParameter,
-          "You must provide at least one of the following parameters: #{possible_params}"
-        )
-      end
-
-      Collection.new(url, query_parameters, config)
-    end
-
-    private
-
-    attr_accessor :url, :data, :config
-  end
-end

data/lib/teamsnap_rb/request_builder.rb

@@ -1,67 +0,0 @@
-require "openssl"
-
-module TeamsnapRb
-  class RequestBuilder
-    attr_reader :connection
-
-    def initialize(config, url)
-      self.config = config
-      self.connection = Faraday::Connection.new(:url => url) do |faraday|
-        config.request_middleware.each do |m|
-          faraday.request(m)
-        end
-
-        config.response_middleware.each do |m|
-          faraday.response(m)
-        end
-
-        faraday.request :teamsnap_config_middleware, config
-        faraday.adapter Faraday.default_adapter
-      end
-    end
-
-    private
-
-    attr_accessor :config
-    attr_writer :connection
-  end
-
-  class TeamsnapAuthMiddleware < Faraday::Middleware
-    def initialize(app, *args, &block)
-      self.config = args[0]
-      super(app)
-    end
-
-    def call(env)
-      if config.access_token
-        env.request_headers["X-Teamsnap-Access-Token"] = config.access_token
-      elsif config.authorization
-        env.request_headers["Authorization"] = "Bearer #{config.authorization}"
-      elsif config.client_id && config.client_secret
-        query_params = Hash[URI.decode_www_form(env.url.query || "")]
-        query_params.merge!({
-          hmac_client_id: config.client_id,
-          hmac_nonce: SecureRandom.uuid,
-          hmac_timestamp: Time.now.to_i
-        })
-        env.url.query = URI.encode_www_form(query_params)
-
-        message = "/?" + env.url.query.to_s + (env.body || "")
-        digest = OpenSSL::Digest.new('sha256')
-        message_hash = digest.hexdigest(message)
-
-        env.request_headers["X-Teamsnap-Hmac"] = OpenSSL::HMAC.hexdigest(digest, config.client_secret, message_hash)
-      end
-
-      @app.call(env)
-    end
-
-    private
-
-    attr_accessor :config
-  end
-
-  Faraday::Request.register_middleware(
-    :teamsnap_config_middleware => lambda { TeamsnapAuthMiddleware }
-  )
-end

data/lib/teamsnap_rb/template.rb

@@ -1,37 +0,0 @@
-module TeamsnapRb
-  class Template
-    def initialize(template, config, url)
-      self.config = config
-      self.template = template
-      self.url = url
-    end
-
-    def build(attrs={})
-      @data = template.build(attrs)
-    end
-
-    def push(attrs={})
-      build(attrs)
-      publish
-    end
-
-    def data
-      template.data
-    end
-
-    def publish
-      post(url, @data) if @data
-    end
-
-    private
-
-    attr_accessor :template, :config, :url
-
-    def post(url, query_parameters = {})
-      RequestBuilder.new(config, url).connection.post do |conn|
-        conn.body = @data.to_json
-        conn.headers['Content-Type'] = 'application/json'
-      end
-    end
-  end
-end

data/lib/teamsnap_rb/version.rb

@@ -1,3 +0,0 @@
-module TeamsnapRb
-  VERSION = "0.0.8"
-end

data/lib/teamsnap_rb.rb

@@ -1,22 +0,0 @@
-require "conglomerate"
-require "json"
-require "faraday"
-require "securerandom"
-
-require_relative "teamsnap_rb/version"
-require_relative "teamsnap_rb/exceptions"
-require_relative "teamsnap_rb/config"
-require_relative "teamsnap_rb/request_builder"
-require_relative "teamsnap_rb/link"
-require_relative "teamsnap_rb/links_proxy"
-require_relative "teamsnap_rb/queries_proxy"
-require_relative "teamsnap_rb/item"
-require_relative "teamsnap_rb/template"
-require_relative "teamsnap_rb/command"
-require_relative "teamsnap_rb/commands"
-require_relative "teamsnap_rb/models/event"
-require_relative "teamsnap_rb/collection"
-require_relative "teamsnap_rb/client"
-
-module TeamsnapRb
-end