strava 0.1.0

data/lib/strava/activity.rb

@@ -0,0 +1,224 @@
+module Strava
+  # Class to represent Strava Activity
+  # @see https://strava.github.io/api/v3/activities/ Strava Activity API Docs
+  class Activity < Base
+     ATTRIBUTES = [:external_id, :upload_id, :athlete, :name, :description, :distance, :moving_time, :elapsed_time, :total_elevation_gain, :elev_high, :elev_low, :type, :start_date, :start_date_local, :timezone, :start_latlng, :end_latlng, :location_city, :location_state, :location_country, :achievement_count, :kudos_count, :comment_count, :athlete_count, :photo_count, :total_photo_count, :map, :trainer, :commute, :manual, :private, :device_name, :embed_token, :flagged, :workout_type, :gear_id, :average_speed, :max_speed, :average_cadence, :average_temp, :average_watts, :max_watts, :weighted_average_watts, :kilojoules, :device_watts, :has_heartrate, :average_heartrate, :max_heartrate, :calories, :suffer_score, :has_kudoed, :splits_metric, :splits_standard, :best_efforts] # activity attributes, all have getter method
+     attr_reader *ATTRIBUTES
+     attr_reader :photos_info, :gear
+
+    # Set up instance variables upon instantiation.
+    #
+    # @abstract
+    # @return [void]
+    private def set_ivars
+      @kudos            = {}
+      @comments         = {}
+      @photos           = {}
+      @laps             = {}
+      @segment_efforts  = {}
+      @related          = {}
+      @streams          = StreamSet.new
+    end
+
+    # Updates activity with passed data attributes.
+    # 
+    # @param data [Hash] data hash containing activity data
+    # @return [self]
+    private def update(data, **opts)
+      @response       = data
+      @id             = data["id"]
+      @resource_state = data['resource_state']
+      @photos_info    = data['photos']
+      @laps_info      = data['laps']
+      @gear           = Gear.new(data['gear'], client: client) if data['gear']
+      ATTRIBUTES.each do |attr|
+        instance_variable_set("@#{attr}", data[attr.to_s])
+      end
+
+      parse_data(@segment_efforts, data["segment_efforts"], klass: SegmentEffort, client: @client) if data["segment_efforts"]
+      self
+    end
+
+    def segment_efforts
+      @segment_efforts.values
+    end
+
+    def kudos(per_page: nil, page: nil)
+      if page || per_page
+        get_kudos(per_page: per_page, page: page)
+      else
+        get_kudos if @kudos.empty?
+        @kudos.values
+      end
+    end
+
+    def comments(per_page: nil, page: nil)
+      if page || per_page
+        get_comments(per_page: per_page, page: page)
+      else
+        get_comments if @comments.empty?
+        @comments.values
+      end
+    end
+
+    def photos(per_page: nil, page: nil)
+      if page || per_page
+        get_photos(per_page: per_page, page: page)
+      else
+        get_photos if @photos.empty?
+        @photos.values
+      end
+    end
+
+    # Activities that were matched as “with this group”. The number equals activity.athlete_count-1. Pagination is supported.
+    # @return [Strava::Activity] Related activities
+    def related(per_page: nil, page: nil)
+      if page || per_page
+        get_related(per_page: per_page, page: page)
+      else
+        get_related if @related.empty?
+        @related.values
+      end
+    end
+
+    def streams(types = [:time, :distance, :latlng], **params)
+      get_streams(types, **params) if @streams.empty?
+      @streams
+    end
+
+    def zones
+      get_zones unless @zones
+      @zones
+    end
+
+    def laps
+      get_laps if @laps.empty?
+      @laps.values
+    end
+
+    def comment(message)
+      res = client.post(path_comments, text: message).to_h
+    end
+
+    def kudo
+      res = client.post(path_kudos).to_h
+    end
+
+
+    def get_details
+      return self if detailed?
+      res = client.get(path_base).to_h
+      update(res)
+    end
+    def get_kudos(per_page: nil, page: nil)
+      res = client.get(path_kudos, per_page: per_page, page: page).to_a
+      parse_data(@kudos, res, klass: Athlete, client: @client)
+    end
+    def get_comments(per_page: nil, page: nil)
+      res = client.get(path_comments, per_page: per_page, page: page).to_a
+      parse_data(@comments, res, klass: Comment, client: @client)
+    end
+    def get_photos(per_page: nil, page: nil)
+      res = client.get(path_photos, per_page: per_page, page: page).to_a
+      parse_data(@photos, res, klass: Photo, client: @client)
+    end
+    def get_related(per_page: nil, page: nil)
+      res = client.get(path_related, per_page: per_page, page: page).to_a
+      parse_data(@related, res, klass: Activity, client: @client)
+    end
+    def get_streams(types = '', **params)
+      res = client.get(path_streams + types.join(','), **params).to_a
+      @streams.update(res)
+    end
+    def get_zones
+      res = client.get(path_zones).to_a
+      @zones = res
+    end
+    def get_laps
+      res = client.get(path_laps).to_a
+      parse_data(@laps, res, klass: Lap, client: @client)
+    end
+
+
+    def path_base
+      "activities/#{id}"
+    end
+    def path_kudos
+      "#{path_base}/kudos"
+    end
+    def path_comments
+      "#{path_base}/comments"
+    end
+    def path_photos
+      "#{path_base}/photos?photo_sources=true"
+    end
+    def path_related
+      "#{path_base}/related"
+    end
+    def path_streams
+      "#{path_base}/streams/"
+    end
+    def path_zones
+      "#{path_base}/zones"
+    end
+    def path_laps
+      "#{path_base}/laps"
+    end
+  end
+end
+
+activity_types = [
+  'Ride',
+  'Kitesurf',
+  'Run',
+  'NordicSki',
+  'Swim',
+  'RockClimbing',
+  'Hike',
+  'RollerSki',
+  'Walk',
+  'Rowing',
+  'AlpineSki',
+  'Snowboard',
+  'BackcountrySki',
+  'Snowshoe',
+  'Canoeing',
+  'StairStepper',
+  'Crossfit',
+  'StandUpPaddling',
+  'EBikeRide',
+  'Surfing',
+  'Elliptical',
+  'VirtualRide',
+  'IceSkate',
+  'WeightTraining',
+  'InlineSkate',
+  'Windsurf',
+  'Kayaking',
+  'Workout',
+  'Yoga',
+]
+
+__END__
+
+ca = Strava::Athlete.current_athlete;
+act = ca.activities.first;
+act.get_details
+act.comments
+
+
+ca = Strava::Athlete.current_athlete;
+act = ca.activities.detect{|a| a.response['kudos_count'] > 0 }
+act.get_kudos
+ca = Strava::Athlete.current_athlete;
+ca.activities;
+ca.activities(page: 2);
+ca.activities(page: 3);
+ca.activities(page: 4);
+act = ca.activities.detect{|a| a.response['comment_count'] > 0 && a.response['kudos_count'] > 0 }
+act.kudos
+act.photos
+act.comments
+act = ca.activities.detect{|a| a.response['comment_count'] > 0 }
+act.get_comments
+

data/lib/strava/adapters/httparty_adapter.rb

@@ -0,0 +1,9 @@
+require 'httparty'
+
+module Strava
+  module Adapters
+    module HTTPartyAdapter
+      #
+    end
+  end
+end

data/lib/strava/athlete.rb

@@ -0,0 +1,378 @@
+module Strava
+  # Strava Athlete class. For the most part, API interaction deals with the currently authenticated athlete.
+  # 
+  # There are mixins available to provide convenient ways to instantiate an athlete, see {Strava.model} for more information.
+  # 
+  # Usage:
+  # 
+  #     ca = Strava::Athlete.current_athlete(access_token)
+  #     ca.firstname    # => 'John'
+  #     ca.lastname     # => 'Applestrava'
+  #     ca.profile      # => 'http://pics.com/227615/large.jpg'
+  # 
+  # @see https://strava.github.io/api/v3/athlete/ Strava Docs - Athlete
+  class Athlete < Base
+
+    attr_reader :firstname, :lastname, :profile_medium, :profile, :city, :state, :country, :sex, :friend, :follower, :premium, :created_at, :updated_at, :follower_count, :friend_count, :mutual_friend_count, :athlete_type, :date_preference, :measurement_preference, :email, :ftp, :weight, :bikes, :shoes
+
+    # Set up instance variables upon instantiation.
+    #
+    # @abstract
+    # @return [void]
+    private def set_ivars
+      @activities         = {}
+      @friends_activities = {}
+      @routes             = {}
+      @connections        = {}
+      @both_following     = {}
+      @koms               = {}
+      @gear               = {}
+      @clubs              = {}
+      @heatmaps           = {}
+      @starred_segments   = {}
+
+      @friends            = []
+      @followers          = []
+    end
+
+    def initialize(data, client: nil, token: nil, **opts)
+      @current  = !!opts[:current]
+      super
+    end
+
+    # Update an existing athlete. 
+    # Used by other methods in the gem.
+    # Should not be used directly.
+    # 
+    # @private
+    # @param data [Hash] data to update the athlete with
+    # @return [self]
+    def update(data, **opts)
+      @id                     = data["id"]
+      @username               = data["username"]
+      @resource_state         = data["resource_state"]
+      @firstname              = data["firstname"]
+      @lastname               = data["lastname"]
+      @city                   = data["city"]
+      @state                  = data["state"]
+      @country                = data["country"]
+      @sex                    = data["sex"]
+      @premium                = data["premium"]
+      @created_at             = data["created_at"]
+      @updated_at             = data["updated_at"]
+      @badge_type_id          = data["badge_type_id"]
+      @profile_medium         = data["profile_medium"]
+      @profile                = data["profile"]
+      @friend                 = data["friend"]
+      @follower               = data["follower"]
+      @follower_count         = data["follower_count"]
+      @friend_count           = data["friend_count"]
+      @mutual_friend_count    = data["mutual_friend_count"]
+      @athlete_type           = data["athlete_type"]
+      @date_preference        = data["date_preference"]
+      @measurement_preference = data["measurement_preference"]
+      @email                  = data["email"]
+      @ftp                    = data["ftp"]
+      @weight                 = data["weight"]
+      @bikes                  = parse_data(@gear, data['bikes'], klass: Gear, client: @client)
+      @shoes                  = parse_data(@gear, data['shoes'], klass: Gear, client: @client)
+
+      parse_data(@clubs, data['clubs'], klass: Club, client: @client)
+
+      self
+    end
+
+    # Whether this is the currently authenticated athlete.
+    # Strava's API has reduced access for athletes other than the currently authenticated one.
+    # 
+    # @return [Boolean]
+    def current?
+      @current
+    end
+
+    ## Non athlete specific methods
+
+    # Retrieve running races.
+    # This is not related to the current athlete, but does require an access token. 
+    # 
+    # Also available via {RunningRace.list_races}
+    # 
+    # @param year [Integer] Year to retrieve races for
+    def list_races(year = Time.now.year)
+      client.list_races(year)
+    end
+
+    # Segment Explorer will find popular segments within a given area.
+    # Requires a comma separated list of bounding box corners.
+    # 
+    # Also available via {Segment.explorer}
+    # 
+    # @param bounds [String] ‘sw.lat,sw.lng,ne.lat,ne.lng’ or alternatively, ‘south,west,north,east’
+    def segment_explorer(bounds = '37.821362,-122.505373,37.842038,-122.465977')
+      client.segment_explorer(bounds)
+    end
+
+    # Gear list. Includes shoes and bikes.
+    # 
+    # @return [Array<Gear>] Athlete's gear
+    def gear
+      @gear.values
+    end
+
+    # Activities belonging to this user.
+    # If no activities have been retrieved, an API call will be made. 
+    # If activities exist, they will be returned.
+    # Pagination is supported, and will always trigger an API call.
+    # Paged requests will return the activities from that page.
+    # Non-paged calls will return all downloaded activities.
+
+    def activities(per_page: nil, page: nil)
+      if page || per_page
+        get_activities(per_page: per_page, page: page)
+      else
+        get_activities if @activities.empty?
+        @activities.values
+      end
+    end
+
+    # not working, not listed in docs
+    # def heatmaps(per_page: nil, page: nil)
+    #   if page || per_page
+    #     get_heatmaps(per_page: per_page, page: page)
+    #   else
+    #     get_heatmaps if @heatmaps.empty?
+    #     @heatmaps.values
+    #   end
+    # end
+
+    def friends_activities(per_page: nil, page: nil, before: nil)
+      if page || per_page
+        get_friends_activities(per_page: per_page, page: page)
+      else
+        get_friends_activities if @friends_activities.empty?
+        @friends_activities.values
+      end
+    end
+
+    def stats
+      @stats || get_stats
+    end
+    alias :totals :stats
+
+    def zones
+      @zones || get_zones
+    end
+
+    def koms(per_page: nil, page: nil)
+      if page || per_page
+        get_koms(per_page: per_page, page: page)
+      else
+        get_koms if @koms.empty?
+        @koms.values
+      end
+    end
+
+    def clubs
+      get_clubs if @clubs.empty?
+      @clubs.values
+    end
+
+    def routes(per_page: nil, page: nil)
+      if page || per_page
+        get_routes(per_page: per_page, page: page)
+      else
+        get_routes if @routes.empty?
+        @routes.values
+      end
+    end
+
+    def starred_segments(per_page: nil, page: nil)
+      if page || per_page
+        get_starred_segments(per_page: per_page, page: page)
+      else
+        get_starred_segments if @starred_segments.empty?
+        @starred_segments.values
+      end
+    end
+
+    def friends(per_page: nil, page: nil)
+      # paginate('friends', struct: Array, per_page: per_page, page: page)
+      if page || per_page
+        get_friends(per_page: per_page, page: page)
+      else
+        get_friends if @friends.empty?
+        @friends.uniq(&:id)
+      end
+    end
+
+    def followers(per_page: nil, page: nil)
+      # paginate('followers', struct: Array, per_page: per_page, page: page)
+      if page || per_page
+        get_followers(per_page: per_page, page: page)
+      else
+        get_followers if @followers.empty?
+        @followers.uniq(&:id)
+      end
+    end
+
+    def both_following(other_athlete, per_page: nil, page: nil)
+      other_id = other_athlete.is_a?(Athlete) ? other_athlete.id : other_athlete
+      if page || per_page
+        get_both_following(other_id, per_page: per_page, page: page)
+      else
+        get_both_following(other_id) if @both_following[other_id].nil?
+        @both_following[other_id]
+      end
+    end
+
+    ## retrieval methods
+    def get_details
+      return self if detailed?
+      res = client.get(path_base).to_h
+      update(res)
+    end
+
+    private def get_activities(per_page: nil, page: nil)
+      res = client.get(path_activities, per_page: per_page, page: page).to_a
+      parse_data(@activities, res, klass: Activity, client: @client)
+    end
+
+    # not working, not listed in docs
+    # private def get_heatmaps(per_page: nil, page: nil)
+    #   res = client.get(path_heatmaps, per_page: per_page, page: page).to_a
+    #   parse_data(@heatmaps, res, klass: Base, client: @client)
+    # end
+
+    private def get_friends_activities(per_page: nil, page: nil, before: nil)
+      res = client.get(path_friends_activities, per_page: per_page, page: page, before: before).to_a
+      parse_data(@friends_activities, res, klass: Activity, client: @client)
+    end
+
+    private def get_stats
+      @stats = client.get(path_stats).to_h
+    end
+
+    private def get_zones
+      @zones = client.get(path_zones).to_h
+    end
+
+    private def get_koms(per_page: nil, page: nil)
+      res = client.get(path_koms, per_page: per_page, page: page).to_a
+      parse_data(@koms, res, klass: SegmentEffort, client: @client)
+    end
+
+    private def get_clubs(per_page: nil, page: nil)
+      res = client.get(path_clubs, per_page: per_page, page: page).to_a
+      parse_data(@clubs, res, klass: Club, client: @client)
+    end
+
+    private def get_routes(per_page: nil, page: nil)
+      res = client.get(path_routes, per_page: per_page, page: page).to_a
+      parse_data(@routes, res, klass: Route, client: @client)
+    end
+
+    private def get_starred_segments(per_page: nil, page: nil)
+      res = client.get(path_starred_segments, per_page: per_page, page: page).to_a
+      parse_data(@starred_segments, res, klass: Segment, client: @client)
+    end
+
+    private def get_friends(per_page: nil, page: nil)
+      res = client.get(path_friends, per_page: per_page, page: page).to_a
+      data = parse_data(@connections, res, klass: self.class, client: @client)
+      @friends.concat(data)
+      data
+    end
+
+    private def get_followers(per_page: nil, page: nil)
+      res = client.get(path_followers, per_page: per_page, page: page).to_a
+      data = parse_data(@connections, res, klass: self.class, client: @client)
+      @followers.concat(data)
+      data
+    end
+
+    private def get_both_following(other_id, per_page: nil, page: nil)
+      res = client.get(path_both_following(other_id), per_page: per_page, page: page).to_a
+      @both_following[other_id] = parse_data(@connections, res, klass: self.class, client: @client)
+    end
+
+    def path_base
+      current? ? 'athlete' : "athletes/#{id}"
+    end
+
+    private def path_activities
+      current? ? "athlete/activities" : raise('Need to be current athlete')
+    end
+
+    # not working, not listed in docs
+    # http://strava.github.io/api/v3/heatmaps/
+    # private def path_heatmaps
+    #   current? ? "athlete/heatmaps" : raise('Need to be current athlete')
+    # end
+
+    private def path_friends_activities
+      current? ? "activities/following" : raise('Need to be current athlete')
+    end
+
+    private def path_stats
+      current? ? "athletes/#{id}/stats" : raise('Need to be current athlete')
+    end
+
+    private def path_zones
+      current? ? "athlete/zones" : raise('Need to be current athlete')
+    end
+
+    private def path_koms
+      "athletes/#{id}/koms"
+    end
+
+    private def path_clubs
+      current? ? "athlete/clubs" : raise('Need to be current athlete')
+    end
+
+    private def path_routes
+      "athletes/#{id}/routes"
+    end
+
+    private def path_starred_segments
+      current? ? "segments/starred" : "athletes/#{id}/segments/starred"
+    end
+
+    private def path_followers
+      current? ? "athlete/followers" : "athletes/#{id}/followers"
+    end
+    private def path_friends
+      current? ? "athlete/friends" : "athletes/#{id}/friends"
+    end
+    private def path_both_following(other_id)
+      current? ? "athletes/#{other_id}/friends" : raise('Need to be current athlete')
+    end
+
+    private
+
+    class << self
+      # Retrieve the currently authenticated athlete. 
+      # Will make request to Strava API.
+      # 
+      # @param token [String] access token for athlete
+      # @return [Athlete] currently authenticated athlete
+      def current_athlete(token = "ca16caf5b4cb8b57016541f470ae6b3a8aea2252")
+        client = Client.new(token)
+        res = client.get('athlete').to_h
+        new(res, client: client, current: true)
+      end
+
+      # def path(endpoint)
+      #   paths[endpoint]
+      # end
+      # def paths
+      #   @paths ||= {
+      #     current: 'athlete',
+      #   }.freeze
+      # end
+    end
+  end
+end
+
+__END__
+
+ca = Strava::Athlete.current_athlete