nike_v2_neura 0.3.7

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.rbenv-version
+.rspec
+.ruby-version
+.rvmrc
+Gemfile.lock
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,100 @@
+NikeV2
+====================
+
+![Build Status](https://travis-ci.org/fuelxc/nike_v2.png)
+
+Learn more about the Nike+ API at [https://developer.nike.com/](https://developer.nike.com/).
+
+## Installation
+``` bash
+gem install nike_v2
+```
+
+### Comming Soon
+Once Nike releases the OAuth api this gem will include the ability to fetch the access token too
+
+## Examples
+
+In order to utilize the Nike+ API in its current state, you'll need to do the following:
+* Sign up for a Nike+ account at [http://nikeplus.nike.com/plus/](http://nikeplus.nike.com/plus/)
+* Log into the developer portal and generate an access token at [https://developer.nike.com/](https://developer.nike.com/)
+
+``` ruby
+require 'nike_v2'
+
+# Initialize a person
+person = NikeV2::Person.new(access_token: 'a1b2c3d4')
+# Fetch persons summary
+person.summary
+# Fetch a persons activities
+person.activities
+# Load more data for an activity
+activity = person.activities.first
+activity.fetch_data
+# Fetch GPS Data for an activity
+activity.gps_data
+```
+
+The activities api allows you to directly pass arguements to the Nike+ api.  It also allows you to prefetch the metrics for each activity returned
+``` ruby
+#fetch 99 activities
+person.activities(:count => 99)
+#prefetch the metrics for activities
+person.activities(:build_metrics => true)
+```
+
+We also smart load the metrics for activities now so you don't have to explicity load them
+``` ruby
+person.activities.total_fuel #fetches the metrics if they aren't already loaded
+ => 394
+```
+
+As of version 0.3.0 you can cache calls to the Nike+ V2 api.  We use the ApiCache (https://github.com/mloughran/api_cache) gem for this and all options in cache directive are passed to the api_cache config.  Setting config.cache false disables the cache
+``` ruby
+# config/initializers/nike_v2.rb
+NikeV2.configure do |config|
+  config.cache = {
+    :cache => 3600
+  }
+end
+```
+
+Possible options:
+```
+{
+  :cache => 600,    # 10 minutes  After this time fetch new data
+  :valid => 86400,  # 1 day       Maximum time to use old data
+                    #             :forever is a valid option
+  :period => 60,    # 1 minute    Maximum frequency to call API
+  :timeout => 5     # 5 seconds   API response timeout
+  :fail =>          # Value returned instead of exception on failure
+}
+```
+## Making it Better
+ 
+* Fork the project.
+* Make your feature addition or bug fix in a new topic branch within your repo.
+* Add specs for any new or modified functionality.
+* Commit and push your changes to Github
+* Send a pull request
+
+## Inspiration
+I used Kevin Thompson's NikeApi gem as inspiration.  Find it here: https://github.com/kevinthompson/nike_api
+
+
+## Copyright
+
+Copyright (c) 2013 SmashTank Apps, LLC.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "nike_v2 #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/ext/core_ext.rb

@@ -0,0 +1,18 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+
+class Range
+  def intersection(other)
+    raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
+    return nil if (self.max < other.begin or other.max < self.begin) 
+    [self.begin, other.begin].max..[self.max, other.max].min
+  end
+  alias_method :&, :intersection
+end

data/lib/nike_v2.rb

@@ -0,0 +1,33 @@
+require 'alchemist'
+require 'forwardable'
+require 'ext/core_ext'
+require 'tzinfo'
+
+module NikeV2
+  def self.configuration
+    @configuration ||=  Configuration.new
+  end
+
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
+  class Configuration
+    attr_accessor :cache
+
+    def initialize
+      @cache = false
+    end
+  end
+end
+
+require 'nike_v2/base'
+require 'nike_v2/metric'
+require 'nike_v2/metrics'
+require 'nike_v2/experience_type'
+require 'nike_v2/resource'
+require 'nike_v2/person'
+require 'nike_v2/activity'
+require 'nike_v2/activities'
+require 'nike_v2/summary'
+require 'nike_v2/gps_data'

data/lib/nike_v2/activities.rb

@@ -0,0 +1,102 @@
+require 'enumerator'
+module NikeV2
+  class Activities < Resource
+    include Enumerable
+    extend Forwardable
+
+    API_ARGS = [:offset, :count, :start_date, :end_date]
+
+    def_delegators :@activities_array, :[]=, :<<, :[], :count, :length, :each, :first, :last, :collect
+    def_delegator :@person, :access_token
+    
+    API_URL = '/me/sport/activities'
+
+    Metrics::METRIC_TYPES.each do |type|
+      self.class_eval do 
+
+        method_var_name = 'total_' + type.downcase
+        instance_variable_set('@' + method_var_name, 0.00)
+        define_method(method_var_name){ ivar = instance_variable_get('@' + method_var_name); ivar ||= sum_of(method_var_name)}
+
+
+        define_method("total_#{type.downcase}_during") do |start_date, end_date, convert = false|
+          @activities_array.reject{|a| ((a.started_at..a.ended_at) & (start_date..end_date)).nil?}.collect{|a| a.send("total_#{type.downcase}_during", start_date, end_date, convert)}.inject(:+)
+        end
+      end
+    end
+
+    def initialize(attributes = {})
+      raise "#{self.class} requires a person." unless attributes.keys.include?(:person)
+      @build_metrics = attributes.delete(:build_metrics) || false
+      api_args = extract_api_args(attributes)
+      set_attributes(attributes)
+      @activities_array = []
+
+
+      #TODO: make it pass blocks
+      activities = fetch_data(api_args)
+      if !activities.nil? && !activities['data'].nil?
+        build_activities(activities.delete('data'))
+        super(activities)
+      end
+    end
+
+    def fetch_more
+      unless self.paging['next'].nil? || self.paging['next'] == ''
+        fetch_and_build_activities 
+      end
+      self
+    end
+
+    def fetch_all
+      until (self.paging['next'].nil? || self.paging['next'] == '') do
+        fetch_and_build_activities 
+      end
+      self
+    end
+
+    def paging
+      @paging ||= ''
+    end
+
+    private
+
+
+    def sum_of(method_var_name)
+      self.collect(&:"#{method_var_name}").inject(:+) || 0.00
+    end
+
+    def build_activities(data)
+      if data
+        data.each do |activity|
+          self << NikeV2::Activity.new({:person => self}.merge(activity))
+        end
+      end
+      if @build_metrics
+        self.collect(&:load_data)
+      end
+
+    end
+
+    def extract_api_args(args)
+      args.inject({}){|h,a| h[camelize_word(a.first)] = a.last if API_ARGS.include?(a.first); h}
+    end
+
+    def camelize_word(word, first_letter_in_uppercase = false)
+      if !!first_letter_in_uppercase
+        word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        (word[0].to_s.downcase + camelize_word(word, true)[1..-1]).to_sym
+      end
+    end
+
+    def fetch_and_build_activities
+      url, query = self.paging['next'].match(/^(.*?)\?(.*)$/)[1,2]
+      query = query.split(/&/).inject({}){|h,item| k, v = item.split(/\=/); h[k] = v;h}
+      activities = fetch_data(query)
+      build_activities(activities.delete('data'))
+
+      @paging = activities.delete('paging')
+    end
+  end
+end

data/lib/nike_v2/activity.rb

@@ -0,0 +1,73 @@
+require 'nike_v2/metrics'
+module NikeV2
+  class Activity < Resource
+    extend Forwardable
+    def_delegator :@person, :access_token
+
+    Metrics::METRIC_TYPES.each do |type|
+      self.class_eval do 
+        def_delegator :metrics, "total_#{type.downcase}"
+        def_delegator :metrics, type.downcase
+        def_delegator :metrics, "total_#{type.downcase}_during"
+      end
+    end
+
+    API_URL = '/me/sport/activities'
+
+    def initialize(attributes = {})
+      raise "#{self.class} requires s person." unless attributes.keys.include?(:person)
+      raise "#{self.class} requires an activityId." unless attributes.keys.include?('activityId')
+
+      build_metrics(attributes)
+      super(attributes)
+    end
+
+    def tz
+      TZInfo::Timezone.get(self.activity_time_zone)
+    end
+
+    def gps_data
+      @gps_data ||= NikeV2::GpsData.new(:activity => self)
+    end
+
+    def metrics
+      load_data unless @metrics.is_a?(NikeV2::Metrics)
+      @metrics
+    end
+
+    def load_data
+      data = fetch_data
+      build_metrics(data)
+      set_attributes(data)   
+
+      true
+    end
+
+    def started_at
+      @started_at ||= Time.parse(self.start_time.gsub('Z', '-') + '00:00')
+    end
+
+    # some reason activities aren't always complete so we need metrics to figure out how long they are
+    def ended_at
+      @ended_at ||= self.respond_to?(:end_time) ? Time.parse(self.end_time.gsub('Z', '-') + '00:00') : started_at + (metrics.durations.to.seconds).to_f 
+    end
+
+    def to_tz(time)
+      if time.respond_to?(:strftime)
+        return Time.parse(time.strftime('%Y-%m-%d %H:%M:%S ' + self.tz.to_s))
+      else
+        return Time.parse(time + ' ' + self.tz.to_s)
+      end
+    end
+
+    private 
+    def api_url
+      API_URL + "/#{self.activity_id}"
+    end
+
+    def build_metrics(data)
+      metrics = data.delete('metrics') || []
+      @metrics = metrics.empty? ? nil : NikeV2::Metrics.new(self, metrics)
+    end
+  end
+end

data/lib/nike_v2/base.rb

@@ -0,0 +1,17 @@
+module NikeV2
+  class Base
+    def initialize(attributes={})
+      @created_at = attributes.delete('created_at')
+      set_attributes(attributes)
+    end
+
+    private
+    def set_attributes(attributes)
+      attributes.each do |(attr, val)|
+        attr = attr.to_s.underscore
+        instance_variable_set("@#{attr}", val)
+        instance_eval "def #{attr}() @#{attr} end"
+      end
+    end
+  end
+end

data/lib/nike_v2/experience_type.rb

@@ -0,0 +1,27 @@
+module NikeV2
+  class ExperienceType
+    TO_S_MAP = {
+      'fuelband' => 'Fuel Band',
+      'npluskinecttrg' => 'Nike+ Kinect',
+      'running' => 'Running'
+    }
+
+    TO_KEY_MAP = TO_S_MAP.invert
+
+    def initialize(code)
+      @code = code
+    end
+
+    def code
+      @code
+    end
+
+    def to_s
+      TO_S_MAP[code.downcase]
+    end
+
+    def self.code_from_string(string)
+      TO_KEY_MAP[string]
+    end
+  end
+end

data/lib/nike_v2/gps_data.rb

@@ -0,0 +1,17 @@
+module NikeV2
+  class GpsData < Resource
+    extend Forwardable
+    def_delegator :@activity, :access_token
+
+    def initialize(attributes = {})
+      raise "#{self.class} requires an activity." unless attributes.keys.include?(:activity)
+      set_attributes(attributes)
+      super(fetch_data)
+    end
+
+    private
+    def api_url
+      self.activity.send(:api_url) + '/gps'
+    end
+  end
+end

data/lib/nike_v2/metric.rb

@@ -0,0 +1,48 @@
+module NikeV2
+  class Metric
+
+    def initialize(activity, data)
+      @activity = activity
+      @unit = data['intervalUnit']
+      @type = data ['metricType']
+      @values = data['values'].collect(&:to_f)
+      self
+    end
+
+    def type
+      @type
+    end
+
+    def values
+      @values
+    end
+
+    def total
+      @total ||= values.inject(:+)
+    end
+
+    def total_during(start, stop, convert_to_local = false)
+      if convert_to_local
+        start = @activity.to_tz(start)
+        stop = @activity.to_tz(stop)
+      end
+      during(start, stop).collect(&:to_f).inject(:+) rescue 0
+    end
+
+    def during(start, stop)
+      start_point = time_to_index(start)
+      duration = time_to_index(stop) - start_point
+      @values[start_point, duration]
+    end
+
+    def duration
+      @values.length.send(@unit.downcase)
+    end
+
+    private
+    def time_to_index(time)
+      difference = time.to_i - @activity.started_at.to_i
+      difference.s.to.send(@unit.downcase).to_s.to_i
+    end
+  end
+end