teamsnap_rb 0.0.8 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7d2fa31f938ab3823bb36c4c6d1717afe5f88a1
-  data.tar.gz: d2573216d36f51ed5d9c791fbafaac27729e7f5e
+  metadata.gz: 2ec7ccaac56d2dbb9377c7d191c93f1e95f72787
+  data.tar.gz: 3e99f2b6972f7a893678697b4f7e140040f39860
 SHA512:
-  metadata.gz: 37202379f9ec80a10cc4e351c419962b3db2094077a33cfc7ecbd29aa0cc6d8473afeed3640b68453b1004439a48e5582864b32f20d8c817474d48a4b277fcd0
-  data.tar.gz: 44c0684500659687b8e230ebbd844b941970e42a86cd506b7ab46b149a87cf0df2c81191fa18775358d2f9e1ce84e428a3a0c9bdcf4d50fdec57e23a1a67711d
+  metadata.gz: c6e8e9529786679bc1b332e8cc652156bb4455260c9236fdbcc6190a1f7bc5a9596ca5d829121ad6274b7778ac539a5b6c7ebc55b14470c883067f75654de711
+  data.tar.gz: c3d57d806335350eb1cd2d98bf3e491cdb2a6dd8b298fe0f3b8de48f1fb91689ccadc08d281e1b0c9a2682e3412ae5ffb29df284bb5dace4a8d6a444d90cf7ad

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.0
+  - rbx-2
+  - ruby-head
+notifications:
+  email:
+    recipients:
+      - shane@teamsnap.com
+      - kyle.ries@teamsnap.com

data/Gemfile

@@ -1,5 +1,6 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
+gem "simplecov", :require => false
 gem "coveralls", :require => false
 gem "pry", :require => false
 

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 TeamSnap
+Copyright (c) 20l5 TeamSnap, Shane Emmons, Kyle Ries
 
 MIT License
 

data/README.md

@@ -1,88 +1,40 @@
-# TeamSnapRb
+# teamsnap_rb
 
-[ ![Codeship Status for teamsnap/teamsnap_rb](https://codeship.com/projects/535cff20-4bf3-0132-5b73-3612ac61d213/status)](https://codeship.com/projects/46910)
-
-[![Code Climate](https://codeclimate.com/github/teamsnap/teamsnap_rb/badges/gpa.svg)](https://codeclimate.com/github/teamsnap/teamsnap_rb)
-[![Coverage Status](https://coveralls.io/repos/teamsnap/teamsnap_rb/badge.png)](https://coveralls.io/r/teamsnap/teamsnap_rb)
-
-# EARLY ACCESS
-
-Please be aware there may be bugs, gremlins, and horrible issues; and you could be eaten by a grue. We are not responsible for any loss of life or limb (especially if you are eaten by a grue).
-
-# TeamsnapRb
-
-TeamsnapRb is a convenient wrapper around the faraday and the conglomerate gem that helps you talk to TeamSnap's APIv3.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'teamsnap_rb'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install teamsnap_rb
+[![Dependencies](http://img.shields.io/gemnasium/teamsnap/teamsnap_rb.svg)](https://gemnasium.com/teamsnap/teamsnap_rb)  
+[![Quality](http://img.shields.io/codeclimate/github/teamsnap/teamsnap_rb.svg)](https://codeclimate.com/github/teamsnap/teamsnap_rb)  
+[![Coverage](http://img.shields.io/coveralls/teamsnap/teamsnap_rb.svg)](https://https://coveralls.io/r/teamsnap/teamsnap_rb)  
+[![Build](http://img.shields.io/travis-ci/teamsnap/teamsnap_rb.svg)](https://travis-ci.org/teamsnap/teamsnap_rb)  
+[![Version](http://img.shields.io/gem/v/teamsnap_rb.svg)](https://rubygems.org/gems/teamsnap_rb)  
+[![License](http://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)  
 
 ## Usage
 
-Needs to be updated; coming soon.
-
-## Contributing
-
-### Git Workflow
-
-1. Fork it ( http://github.com/teamsnap/teamsnap_rb/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-### Testing teamsnap_rb
+_Note: You'll need an OAuth2 Token from TeamSnap. Checkout our API docs
+[here](http://developer.teamsnap.com/documentation/apiv3/)_
 
-`./bin/rspec` will run the test suite.
-
-### teamsnap_rb in IRB
-
-```ruby
-$ irb
-> require 'teamsnap_rb'
-=> true
-> client_config = TeamsnapRb::Config.new(
->   client_id: "your_client_id_here",
->   client_secret: "ssshhhhhh!"
-> )
-> client = TeamsnapRb::Client.new("http://apiv3.teamsnap.com/", config: client_config)
-=> # client object
-> team = client.teams.search(:id => "your_team_id_here").first
-=> # team object
 ```
-
-You can also access the API via OAuth2, which is handled outside of this gem.
-Simply pass the authorization token to access:
-
-```ruby
-$ irb
-> require 'teamsnap_rb'
-=> true
-> client_config = TeamsnapRb::Config.new(
->   authorization: "authorization key here",
-> )
-> client = TeamsnapRb::Client.new("http://apiv3.teamsnap.com/", config: client_config)
-=> # client object
-> client.me.first.teams.inject({}){|a, t| a[t.name] = t.href; a }
-=> {"Authorized User Team"=>"https://apiv3.teamsnap.com/teams/82308"}
+λ bundle install
+Fetching gem metadata from https://rubygems.org/..........
+...
+Your bundle is complete!
+Use `bundle show [gemname]` to see where a bundled gem is installed.
+λ bundle exec rake console
+[1] pry(main)> TeamSnap.init("abc123...", :url => "https://apiv3.teamsnap.com")
+[2] pry(main)> t = TeamSnap::Team.find(1)
+=> #<TeamSnap::Team::...>
+[3] pry(main)> t.name
+=> "TeamSnap"
+[4] pry(main)> rs = client.bulk_load(:team_id => 1, :types => "team,member")
+=> [#<TeamSnap::Team:...>,
+ #<TeamSnap::Member:...>,
+ # ...
+ #<TeamSnap::Member:...>]
+[5] pry(main)> rs[1].first_name
+=> "Andrew"
 ```
 
+## Todo
 
-In order to work on teamsnap_rb most effectively and efficiently, it'll he helpful
-to have a TeamSnap account and teams so you can work with that data. You can
-create a TeamSnap account [here](https://go.teamsnap.com) and you can then
-authorize a client application using our [Cogsworth
-service](https://auth.teamsnap.com).
-
-With a client ID and secret in hand, you can begin interacting with the gem
-using real data.
+- Literate style docs?
+- Cache items with threadsafe Hash (https://github.com/headius/thread_safe).
+- Implement create, update and delete.

data/Rakefile

@@ -1,4 +1,22 @@
+require "rubygems"
 require "bundler/gem_tasks"
-require 'coveralls/rake/task'
+require "rake/clean"
+require "rspec/core/rake_task"
+require "coveralls/rake/task"
+
+CLOBBER.include("coverage")
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.fail_on_error = false
+end
+task :default => :spec
 
 Coveralls::RakeTask.new
+
+desc "start an IRB session with teamsnap loaded"
+task :console do
+  require "pry"
+  require "./lib/teamsnap"
+  ARGV.clear
+  Pry.start
+end

data/lib/teamsnap/version.rb

@@ -0,0 +1,3 @@
+module TeamSnap
+  VERSION = "1.0.0.beta1"
+end

data/lib/teamsnap.rb

@@ -0,0 +1,270 @@
+require "faraday"
+require "typhoeus"
+require "typhoeus/adapters/faraday"
+require "oj"
+require "inflecto"
+require "virtus"
+require "date"
+
+require_relative "teamsnap/version"
+
+Oj.default_options = {
+  :mode => :compat,
+  :symbol_keys => true,
+  :class_cache => true
+}
+
+Faraday::Request.register_middleware(
+  :teamsnap_auth_middleware => -> { TeamSnap::AuthMiddleware }
+)
+
+Inflecto.inflections do |inflect|
+  inflect.irregular "member_preferences", "members_preferences"
+  inflect.irregular "opponent_results", "opponents_results"
+  inflect.irregular "team_preferences", "teams_preferences"
+  inflect.irregular "team_results", "teams_results"
+end
+
+module TeamSnap
+  EXCLUDED_RELS = ["me", "apiv2_root", "root", "self"]
+  DEFAULT_URL = "http://localhost:3000"
+  Error = Class.new(StandardError)
+  NotFound = Class.new(TeamSnap::Error)
+
+  class AuthMiddleware < Faraday::Middleware
+    def initialize(app, options)
+      super(app)
+      @options = options
+    end
+
+    def call(env)
+      token = @options.fetch(:token)
+      env[:request_headers].merge!({"Authorization" => "Bearer #{token}"})
+
+      @app.call(env)
+    end
+  end
+
+  class << self
+    def collection(href, resp)
+      Module.new do
+        define_singleton_method(:included) do |descendant|
+          descendant.send(:include, TeamSnap::Item)
+          descendant.extend(TeamSnap::Collection)
+          descendant.instance_variable_set(:@href, href)
+          descendant.instance_variable_set(:@resp, resp)
+        end
+      end
+    end
+
+    def hashify(arr)
+      arr.to_h
+    rescue NoMethodError
+      arr.inject({}) { |hash, (key, value)| hash[key] = value; hash }
+    end
+
+    def init(opts = {})
+      opts[:url] ||= DEFAULT_URL
+      opts.fetch(:token) {
+        raise ArgumentError.new("You must provide a :token to '.init'")
+      }
+
+      self.client = Faraday.new(
+        :url => opts.fetch(:url),
+        :parallel_manager => Typhoeus::Hydra.new
+      ) do |c|
+        c.request :teamsnap_auth_middleware, {:token => opts[:token]}
+        c.adapter :typhoeus
+      end
+
+      collection = TeamSnap.run(:get, "/")
+
+      classes = []
+      client.in_parallel do
+        classes = collection
+          .fetch(:links)
+          .map { |link| classify_rel(link) }
+          .compact
+      end
+
+      classes.each { |cls| cls.parse_collection }
+
+      apply_endpoints(self, collection) && true
+    end
+
+    def run(via, href, args = {})
+      resp = client.send(via, href, args)
+
+      if resp.status == 200
+        Oj.load(resp.body)
+          .fetch(:collection)
+      else
+        error_message = parse_error(resp)
+        raise TeamSnap::Error.new(error_message)
+      end
+    end
+
+    def parse_error(resp)
+      Oj.load(resp.body)
+        .fetch(:collection)
+        .fetch(:error)
+        .fetch(:message)
+    end
+
+    def load_items(collection)
+      collection
+        .fetch(:items) { [] }
+        .map { |item|
+          data = parse_data(item)
+          type = type_of(item)
+          cls = load_class(type, data)
+
+          cls.new(data).tap { |obj|
+            obj.send(:load_links, item.fetch(:links))
+          }
+        }
+    end
+
+    def apply_endpoints(obj, collection)
+      collection
+        .fetch(:queries) { [] }
+        .each { |endpoint| register_endpoint(obj, endpoint, :via => :get) }
+
+      collection
+        .fetch(:commands) { [] }
+        .each { |endpoint| register_endpoint(obj, endpoint, :via => :post) }
+    end
+
+    private
+
+    attr_accessor :client
+
+    def classify_rel(link)
+      return if EXCLUDED_RELS.include?(link.fetch(:rel))
+
+      rel = link.fetch(:rel)
+      href = link.fetch(:href)
+      name = Inflecto.classify(rel)
+      resp = client.get(href)
+
+      TeamSnap.const_set(
+        name, Class.new { include TeamSnap.collection(href, resp) }
+      ) unless TeamSnap.const_defined?(name)
+    end
+
+    def register_endpoint(obj, endpoint, opts)
+      rel = endpoint.fetch(:rel)
+      href = endpoint.fetch(:href)
+      valid_args = endpoint.fetch(:data) { [] }
+        .map { |datum| datum.fetch(:name).to_sym }
+      via = opts.fetch(:via)
+
+      obj.define_singleton_method(rel) do |*args|
+        args = Hash[*args]
+
+        unless args.all? { |arg, _| valid_args.include?(arg) }
+          raise ArgumentError.new(
+            "Invalid argument(s). Valid argument(s) are #{valid_args.inspect}"
+          )
+        end
+
+        TeamSnap.load_items(
+          TeamSnap.run(via, href, args)
+        )
+      end
+    end
+
+    def parse_data(item)
+      data = item
+        .fetch(:data)
+        .map { |datum|
+          name = datum.fetch(:name)
+          value = datum.fetch(:value)
+          type = datum.fetch(:type) { :default }
+
+          value = DateTime.parse(value) if value && type == "DateTime"
+
+          [name, value]
+        }
+      TeamSnap.hashify(data)
+    end
+
+    def type_of(item)
+      item
+        .fetch(:data)
+        .find { |datum| datum.fetch(:name) == "type" }
+        .fetch(:value)
+    end
+
+    def load_class(type, data)
+      TeamSnap.const_get(Inflecto.classify(type)).tap { |cls|
+        unless cls.include?(Virtus::Model::Core)
+          cls.class_eval do
+            include Virtus.value_object
+
+            values do
+              attribute :href, String
+              data.each { |name, value| attribute name, value.class }
+            end
+          end
+        end
+      }
+    end
+  end
+
+  module Item
+    private
+
+    def load_links(links)
+      links.each do |link|
+        next if EXCLUDED_RELS.include?(link.fetch(:rel))
+
+        rel = link.fetch(:rel)
+        href = link.fetch(:href)
+        is_singular = rel == Inflecto.singularize(rel)
+
+        define_singleton_method(rel) {
+          coll = TeamSnap.load_items(
+            TeamSnap.run(:get, href)
+          )
+          coll.size == 1 && is_singular ? coll.first : coll
+        }
+      end
+    end
+  end
+
+  module Collection
+    def href
+      self.instance_variable_get(:@href)
+    end
+
+    def resp
+      self.instance_variable_get(:@resp)
+    end
+
+    def parse_collection
+      if resp.status == 200
+        collection = Oj.load(resp.body)
+          .fetch(:collection)
+
+        TeamSnap.apply_endpoints(self, collection)
+        enable_find if respond_to?(:search)
+      else
+        error_message = TeamSnap.parse_error(resp)
+        raise TeamSnap::Error.new(error_message)
+      end
+    end
+
+    private
+
+    def enable_find
+      define_singleton_method(:find) do |id|
+        search(:id => id).first.tap do |object|
+          raise TeamSnap::NotFound.new(
+            "Could not find a #{self} with an id of '#{id}'."
+          ) unless object
+        end
+      end
+    end
+  end
+end