strava-api-v2 0.1

data/lib/strava/v1/segments_request.rb

@@ -0,0 +1,31 @@
+require 'strava/v1/models/segment'
+
+module Strava
+  module V1
+    module SegmentRequest
+      SEGMENT_PARAMS_MAP = {
+          :club_id => :clubId,
+          :athlete_id => :athleteId,
+          :athlete_name => :athleteName,
+          :start_date => :startDate,
+          :end_date => :endDate,
+          :start_id => :startId,
+          :best => :best
+      }
+
+      def efforts_for_segment_path(id)
+        "segments/#{id}/efforts"
+      end
+
+      def segment_with_efforts(id, params = {})
+        final_params = {}
+        params.each_pair do |key, value|
+          raise RequestError.new if SEGMENT_PARAMS_MAP[key].nil?
+          final_params[SEGMENT_PARAMS_MAP[key]] = value
+        end
+        all_json = self.fetch(efforts_for_segment_path(id), final_params)
+        Segment.new(all_json["segment"], all_json["efforts"])
+      end
+    end
+  end
+end

data/lib/strava/v1/streams_request.rb

@@ -0,0 +1,15 @@
+require 'strava/v1/models/stream'
+
+module Strava
+  module V1
+    module StreamRequest
+      def streams_path(id)
+        "streams/#{id}"
+      end
+
+      def stream(id)
+        Stream.new(self.fetch(streams_path(id), nil))
+      end
+    end
+  end
+end

data/lib/strava/v2/auth_request.rb

@@ -0,0 +1,17 @@
+require 'strava/v2/models/auth'
+
+module Strava
+  module V2
+    module AuthRequest
+      def login_path
+        'authentication/login'
+      end
+
+      def login(email, password)
+        auth = Auth.new(self.fetch(login_path(), {:email => email, :password => password}))
+        self.set_authorized_user(auth.athlete.id, auth.token)
+        return auth
+      end
+    end
+  end
+end

data/lib/strava/v2/connection.rb

@@ -0,0 +1,27 @@
+require 'httparty'
+require 'strava/base_connection'
+require 'strava/exceptions'
+require 'strava/v2/auth_request'
+require 'strava/v2/efforts_request'
+require 'strava/v2/segments_request'
+
+module Strava
+  module V2
+    class Connection
+      include HTTParty
+      include Strava::BaseConnection
+      include Strava::V2::AuthRequest
+      include Strava::V2::EffortsRequest
+      include Strava::V2::SegmentsRequest
+
+      attr_reader :user_id, :token
+      base_uri 'http://www.strava.com/api/v2'
+      format :json
+
+      def set_authorized_user(user_id, token)
+        @user_id = user_id
+        @token = token
+      end
+    end
+  end
+end

data/lib/strava/v2/efforts_request.rb

@@ -0,0 +1,21 @@
+require 'strava/v2/models/effort'
+
+module Strava
+  module V2
+    module EffortsRequest
+      def efforts_path(id)
+        "rides/#{id}/efforts"
+      end
+
+      def segments_for_ride(ride_id)
+        all_json = self.fetch(efforts_path(ride_id), {})
+
+        all_segments = []
+        all_json["efforts"].each { |effort_json|
+          all_segments.push(Segment.new(effort_json["segment"], [effort_json["effort"]]))
+        }
+        all_segments
+      end
+    end
+  end
+end

data/lib/strava/v2/models/athlete.rb

@@ -0,0 +1,15 @@
+require 'strava/strava_response'
+
+module Strava
+  module V2
+    class Athlete < StravaResponse
+      attr_reader :id, :name, :agreed_to_terms
+
+      def initialize(json_blob)
+        @id = json_blob["id"]
+        @name = json_blob["name"]
+        @agreed_to_terms = json_blob["agreed_to_terms"]
+      end
+    end
+  end
+end

data/lib/strava/v2/models/auth.rb

@@ -0,0 +1,15 @@
+require 'strava/strava_response'
+require 'strava/v2/models/athlete'
+
+module Strava
+  module V2
+    class Auth < StravaResponse
+      attr_reader :token, :athlete
+
+      def initialize(json_blob)
+        @token = json_blob["token"]
+        @athlete = Athlete.new(json_blob["athlete"])
+      end
+    end
+  end
+end

data/lib/strava/v2/models/effort.rb

@@ -0,0 +1,19 @@
+require 'strava/strava_response'
+require 'strava/v2/models/segment'
+
+module Strava
+  module V2
+    class Effort < StravaResponse
+      attr_reader :id, :elapsed_time, :moving_time, :distance
+
+      # Initialize the Effort
+      # ejs - the effort JSON
+      def initialize(ejs)
+        @id = ejs["id"]
+        @elapsed_time = ejs["elapsed_time"]
+        @moving_time = ejs["moving_time"]
+        @distance = ejs["distance"]
+      end
+    end
+  end
+end

data/lib/strava/v2/models/segment.rb

@@ -0,0 +1,26 @@
+require 'strava/strava_response'
+require 'strava/v2/models/effort'
+
+module Strava
+  module V2
+    class Segment < StravaResponse
+      attr_reader :id, :efforts, :name, :climb_category, :start_latlng, :end_latlng, :average_grade
+
+      # include the efforts in the segment, if applicable
+      # jb - the json for the segment
+      # ejb - the json for the efforts, in a list
+      def initialize(jb, ejb)
+        @id = jb["id"]
+        @name = jb["name"]
+        @climb_category = jb["climb_category"]
+        @start_latlng = jb["start_latlng"]
+        @end_latlng = jb["end_latlng"]
+        @average_grade = jb["avg_grade"]
+        @efforts = []
+        ejb.each { |effort_json|
+          @efforts.push(Effort.new(effort_json))
+        }
+      end
+    end
+  end
+end

data/lib/strava/v2/segments_request.rb

@@ -0,0 +1,21 @@
+require 'strava/v2/models/segment'
+
+module Strava
+  module V2
+    module SegmentsRequest
+      def segments_and_efforts_for_ride_path(ride_id)
+        "rides/#{ride_id}/efforts"
+      end
+
+      def segments_and_efforts_for_ride(ride_id)
+        all_json = self.fetch(segments_and_efforts_for_ride_path(ride_id), {})
+        all_segments = []
+        all_json["efforts"].each { |effort_json|
+          all_segments.push(Segment.new(effort_json["segment"], [effort_json["effort"]]))
+        }
+        all_segments
+      end
+    end
+  end
+end
+

data/lib/strava/version.rb

@@ -0,0 +1,3 @@
+module Strava
+  VERSION = "0.1"
+end

data/strava-api-v2.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'strava/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "strava-api-v2"
+  spec.version       = Strava::VERSION
+  spec.authors       = ["Luke StClair"]
+  spec.email         = ["secureboot@gmail.com"]
+  spec.description   = %q{API to access strava API, v2}
+  spec.summary       = %q{Provides access to the strava v1 and v2 apis, which are soon to be deprecated}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+  spec.add_development_dependency "httparty"
+  spec.add_development_dependency "mocha"
+end

data/test/auth_test.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require 'mocha/setup'
+require 'strava/v2/connection'
+require 'strava/exceptions'
+require 'strava/v2/models/athlete'
+require 'json'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'test'))
+require 'test_data'
+
+class AuthTest < Test::Unit::TestCase
+
+  def setup
+    @s = Strava::V2::Connection.new
+  end
+
+  def test_successful_auth
+    email = 'secureboot@gmail.com'
+    password = 'notatallreal'
+
+    Strava::V2::Connection.stubs(:get)
+      .with("/#{@s.login_path}", {:query => {:email => email, :password => password}})
+      .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_login)))
+    result = @s.login(email, password)
+    assert_equal("thetoken", result.token)
+    # make sure the athlete parses out okay.
+    assert result.athlete.is_a?(Strava::V2::Athlete)
+
+    # be sure the auth for the connection gets set
+    assert_equal(7976, @s.user_id)
+    assert_equal("thetoken", @s.token)
+  end
+end

data/test/clubs_test.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'mocha/setup'
+require 'strava/v1/connection'
+require 'strava/exceptions'
+require 'strava/v1/models/club'
+require 'json'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'test'))
+require 'test_data'
+
+class ClubsTest < Test::Unit::TestCase
+
+  def setup
+    @s = Strava::V1::Connection.new
+  end
+
+  def test_clubs
+    club_name = "mission"
+
+    Strava::V1::Connection.stubs(:get)
+    .with("/clubs", {:query => {:name => club_name}})
+    .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_clubs)))
+
+    clubs = @s.clubs(club_name)
+
+    assert clubs[0].is_a?(Strava::V1::Club)
+    assert_equal(11, clubs.length)
+    first = clubs[0]
+    assert_equal("Mission Cycling", first.name)
+    assert_equal(15, first.id)
+  end
+end

data/test/efforts_v2_test.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'mocha/setup'
+require 'strava/v2/connection'
+require 'strava/exceptions'
+require 'strava/v2/models/athlete'
+require 'json'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'test'))
+require 'test_data'
+
+class EffortsV2Test < Test::Unit::TestCase
+
+  def setup
+    @s = Strava::V2::Connection.new
+  end
+
+  def test_get_efforts_for_ride
+    ride_id = 448459
+    Strava::V2::Connection.stubs(:get)
+    .with("/rides/#{ride_id}/efforts", {:query => {}})
+    .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_v2_efforts)))
+    segments = @s.segments_for_ride(ride_id)
+    effort = segments[0].efforts[0]
+    assert effort.is_a?(Strava::V2::Effort)
+    assert_equal(45665444, effort.id)
+    assert_equal(12, segments.length)
+    assert_equal(634, effort.elapsed_time)
+    assert_equal(634, effort.moving_time)
+    assert_equal(5342.8, effort.distance)
+    assert_equal(852034, segments[0].id)
+    assert_equal(1, segments[0].climb_category)
+    assert_equal([37.771132132038474,-122.45532101020217], segments[0].start_latlng)
+    assert_equal(-0.997671, segments[0].average_grade)
+  end
+end

data/test/rides_v1_test.rb

@@ -0,0 +1,62 @@
+require 'test/unit'
+require 'mocha/setup'
+require 'strava/v1/connection'
+require 'strava/exceptions'
+require 'strava/v1/models/athlete'
+require 'json'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'test'))
+require 'test_data'
+
+class RidesV1Test < Test::Unit::TestCase
+
+  def setup
+    @s = Strava::V1::Connection.new
+  end
+
+  def test_rides_with_no_params
+    Strava::V1::Connection.stubs(:get)
+    .with("/#{@s.rides_path}", {:query => {}})
+    .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_rides_no_params)))
+    result = @s.rides()
+    assert_equal(50, result.length)
+  end
+
+  def test_rides_with_invalid_param
+    assert_raise Strava::RequestError do
+      @s.rides({:made_up => "whatever"})
+    end
+  end
+
+  def test_rides_with_two_valid_params
+    Strava::V1::Connection.stubs(:get)
+    .with("/#{@s.rides_path}", {:query => {:startId => 77563, :offset => 50}})
+    .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_ride_start_id_and_offset)))
+    rides = @s.rides({:start_id => 77563, :offset => 50})
+
+    assert_equal(52127040, rides[0].id)
+  end
+
+  def test_getting_efforts_for_a_ride
+    ride_id = 77563
+    Strava::V1::Connection.stubs(:get)
+    .with("/rides/#{ride_id}/efforts", {:query => {}})
+    .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_efforts)))
+    ride = @s.ride_with_efforts(ride_id)
+    assert_equal(ride_id, ride.id)
+    assert_equal(5819602, ride.segments[0].efforts[0].id)
+    assert_equal(640366, ride.segments[0].id)
+  end
+
+  def test_show_ride_details
+    ride_id = 77563
+    Strava::V1::Connection.stubs(:get)
+    .with("/rides/#{ride_id}", {:query => {}})
+    .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_show_ride_deets)))
+    ride = @s.ride(ride_id)
+    assert_equal(82369.1, ride.distance)
+    assert_equal(1441.02, ride.elevation_gain)
+    assert_equal("02/28/10 San Francisco, CA", ride.name)
+    assert_equal("julianbill", ride.athlete.username)
+    assert_equal(1139, ride.athlete.id)
+  end
+end

data/test/segments_v1_request_test.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'mocha/setup'
+require 'strava/v1/connection'
+require 'strava/v1/segments_request'
+require 'strava/exceptions'
+require 'json'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'test'))
+require 'test_data'
+
+class SegmentsV1RequestTest < Test::Unit::TestCase
+
+  def setup
+    @s = Strava::V1::Connection.new
+  end
+
+  def test_get_efforts_for_segment
+    segment_id = 229781
+
+    Strava::V1::Connection.stubs(:get)
+    .with("/segments/#{segment_id}/efforts", {:query => {:best => true}})
+    .returns(stub(:code => 200, :parsed_response => (JSON.parse TestData.test_v1_segment_efforts)))
+    segment = @s.segment_with_efforts(segment_id, {:best => true})
+    assert segment.is_a?(Strava::V1::Segment)
+    assert segment.efforts[0].is_a?(Strava::V1::Effort)
+    assert_equal(segment_id, segment.id)
+    assert_equal(50, segment.efforts.length)
+    first = segment.efforts[0]
+    assert_equal(801006623, first.id)
+    assert_equal(123529, first.athlete.id)
+    assert_equal("jimwhimpey", first.athlete.username)
+    assert_equal("Jim Whimpey", first.athlete.name)
+  end
+
+  def test_segment_with_bad_param
+    assert_raise Strava::RequestError do
+      @s.segment_with_efforts(12345, {:made_up => "whatever"})
+    end
+  end
+end