medic 0.0.1 → 0.0.2

data/lib/medic/hk_constants.rb

@@ -0,0 +1,76 @@
+module Medic
+  module HKConstants
+
+    ERROR_CODES = {
+      no_error: HKNoError,
+      health_data_unavailable: HKErrorHealthDataUnavailable,
+      health_data_restricted: HKErrorHealthDataRestricted,
+      invalid_argument: HKErrorInvalidArgument,
+      authorization_denied: HKErrorAuthorizationDenied,
+      authorization_not_determined: HKErrorAuthorizationNotDetermined,
+      database_inaccessible: HKErrorDatabaseInaccessible,
+      user_canceled: HKErrorUserCanceled
+    }
+
+    UPDATE_FREQUENCIES = {
+      immediate: HKUpdateFrequencyImmediate,
+      hourly: HKUpdateFrequencyHourly,
+      daily: HKUpdateFrequencyDaily,
+      weekly: HKUpdateFrequencyWeekly
+    }
+
+    AUTHORIZATION_STATUSES = {
+      not_determined: HKAuthorizationStatusNotDetermined,
+      sharing_denied: HKAuthorizationStatusSharingDenied,
+      sharing_authorized: HKAuthorizationStatusSharingAuthorized
+    }
+
+    BIOLOGICAL_SEXES = {
+      not_set: HKBiologicalSexNotSet,
+      female: HKBiologicalSexFemale,
+      male: HKBiologicalSexMale
+    }
+
+    BLOOD_TYPES = {
+      not_set: HKBloodTypeNotSet,
+      a_positive: HKBloodTypeAPositive,
+      a_negative: HKBloodTypeANegative,
+      b_positive: HKBloodTypeBPositive,
+      b_negative: HKBloodTypeBNegative,
+      a_b_positive: HKBloodTypeABPositive,
+      a_b_negative: HKBloodTypeABNegative,
+      o_positive: HKBloodTypeOPositive,
+      o_negative: HKBloodTypeONegative
+    }
+
+    SLEEP_ANALYSES = {
+      in_bed: HKCategoryValueSleepAnalysisInBed,
+      asleep: HKCategoryValueSleepAnalysisAsleep
+    }
+
+    def error_code(error)
+      error.is_a?(Symbol) ? ERROR_CODES[error] : error
+    end
+
+    def update_frequency(freq)
+      freq.is_a?(Symbol) ? UPDATE_FREQUENCIES[freq] : freq
+    end
+
+    def authorization_status(auth_status)
+      auth_status.is_a?(Symbol) ? AUTHORIZATION_STATUSES[auth_status] : auth_status
+    end
+
+    def biological_sex(sex)
+      sex.is_a?(Symbol) ? BIOLOGICAL_SEXES[sex] : sex
+    end
+
+    def blood_type(blood)
+      blood.is_a?(Symbol) ? BLOOD_TYPES[blood] : blood
+    end
+
+    def sleep_analysis(sleep)
+      sleep.is_a?(Symbol) ? SLEEP_ANALYSES[sleep] : sleep
+    end
+
+  end
+end

data/lib/medic/interval.rb

@@ -0,0 +1,29 @@
+module Medic
+  module Interval
+
+    NUMBER_WORDS = {
+      'zero' => 0, 'one' => 1, 'two' => 2, 'three' => 3, 'four' => 4, 'five' => 5,
+      'six' => 6, 'seven' => 7, 'eight' => 8, 'nine' => 9, 'ten' => 10, 'eleven' => 11,
+      'twelve' => 12, 'thirteen' => 13, 'fourteen' => 14, 'fifteen' => 15, 'sixteen' => 16,
+      'seventeen' => 17, 'eighteen' => 18, 'nineteen' => 19, 'twenty' => 20, 'thirty' => 30,
+      'fourty' => 40, 'fifty' => 50, 'sixty' => 60, 'seventy' => 70, 'eighty' => 80,
+      'ninety' => 90, 'hundred' => 100
+    }
+
+    def interval(sym)
+      return sym if sym.is_a? NSDateComponents
+      parts = sym.to_s.gsub('_', ' ').split
+      component = parts.pop.chomp('s')
+      n = parts.map{|p| NUMBER_WORDS[p] || p.to_i}.reduce do |sum, p|
+        if p == 100 && sum > 0
+          sum * p
+        else
+          sum + p
+        end
+      end
+      n ||= 1
+      NSDateComponents.new.send("#{component}=", n)
+    end
+
+  end
+end

data/lib/medic/medic.rb

@@ -1,4 +1,71 @@
-class Medic
+module Medic
+  class << self
 
+    include Medic::Finders
+
+    def available?
+      Medic::Store.available?
+    end
+    alias_method :is_available?, :available?
+
+    def authorize(types, block=Proc.new)
+      Medic::Store.shared.authorize(types, block)
+    end
+
+    def authorized?(sym)
+      Medic::Store.shared.authorized?(sym)
+    end
+    alias_method :authorized_for?, :authorized?
+    alias_method :is_authorized?, :authorized?
+    alias_method :is_authorized_for?, :authorized?
+
+    def biological_sex
+      Medic::Store.shared.biological_sex
+    end
+
+    def blood_type
+      Medic::Store.shared.blood_type
+    end
+
+    def date_of_birth
+      Medic::Store.shared.date_of_birth
+    end
+
+    def delete(hk_object, block=Proc.new)
+      Medic::Store.shared.delete(hk_object, block)
+    end
+    alias_method :delete_object, :delete
+
+    def save(hk_objects, block=Proc.new)
+      Medic::Store.shared.save(hk_objects, block)
+    end
+    alias_method :save_object, :save
+    alias_method :save_objects, :save
+
+    def execute(query)
+      Medic::Store.shared.execute(query)
+    end
+    alias_method :execute_query, :execute
+
+    def stop(query)
+      Medic::Store.shared.stop(query)
+    end
+    alias_method :stop_query, :stop
+
+    def enable_background_delivery(type, frequency, block=Proc.new)
+      Medic::Store.shared.enable_background_delivery(type, frequency, block)
+    end
+    alias_method :enable_background_delivery_for, :enable_background_delivery
+
+    def disable_background_delivery(type, block=Proc.new)
+      Medic::Store.shared.disable_background_delivery(type, block)
+    end
+    alias_method :disable_background_delivery_for, :disable_background_delivery
+
+    def disable_all_background_delivery(block=Proc.new)
+      Medic::Store.shared.disable_all_background_delivery(block)
+    end
+
+  end
 end
 

data/lib/medic/observer_query.rb

@@ -0,0 +1,15 @@
+module Medic
+  class ObserverQuery < HKObserverQuery
+
+    include Medic::Types
+    include Medic::Predicate
+
+    def initialize(args={}, block=Proc.new)
+      self.initWithSampleType(object_type(args[:type]),
+        predicate: predicate(args),
+        updateHandler: block
+      )
+    end
+
+  end
+end

data/lib/medic/predicate.rb

@@ -0,0 +1,39 @@
+module Medic
+  module Predicate
+
+    include Medic::QueryOptions
+
+    def predicate(args={})
+      return args if args.is_a? NSPredicate
+      if args[:where]
+        args[:where]
+      elsif args[:predicate]
+        args[:predicate]
+      elsif args[:sample_predicate]
+        args[:sample_predicate]
+      elsif args[:uuid] || args[:uuids]
+        uuids = Array(args[:uuid] || args[:uuids]).map{ |s| NSUUID.alloc.initWithUUIDString(s.to_s) }
+        HKQuery.predicateForObjectsWithUUIDs(uuids)
+      elsif args[:source] || args[:sources]
+        HKQuery.predicateForObjectsFromSources(Array(args[:source] || args[:sources]))
+      elsif args[:meta_data] && (args[:allowed_value] || args[:allowed_values])
+        HKQuery.predicateForObjectsWithMetadataKey(args[:meta_data].to_s, allowedValues: Array(args[:allowed_value] || args[:allowed_values]))
+      elsif args[:meta_data]
+        HKQuery.predicateForObjectsWithMetadataKey(args[:meta_data].to_s)
+      elsif args[:no_correlation]
+        HKQuery.predicateForObjectsWithNoCorrelation
+      elsif args[:start_date] && args[:end_date]
+        options = query_options(args[:options]) || HKQueryOptionNone
+        HKQuery.predicateForSamplesWithStartDate(args[:start_date], endDate: args[:end_date], options: options)
+      elsif args[:workout]
+        HKQuery.predicateForObjectsFromWorkout(args[:workout])
+      elsif args[:workout_activity_type] || args[:activity_type]
+        activity_type = args[:workout_activity_type] || args[:activity_type]
+        HKQuery.predicateForWorkoutsWithWorkoutActivityType(activity_type)
+      else
+        nil
+      end
+    end
+
+  end
+end

data/lib/medic/query_options.rb

@@ -0,0 +1,23 @@
+module Medic
+  module QueryOptions
+
+    QUERY_OPTIONS = {
+      none: HKQueryOptionNone,
+      strict_start_date: HKQueryOptionStrictStartDate,
+      strict_end_date: HKQueryOptionStrictEndDate
+    }
+
+    def query_options(symbols)
+      options = 0
+      Array(symbols).each do |option|
+        options = options | query_option(option)
+      end
+      options
+    end
+
+    def query_option(option)
+      option.is_a?(Symbol) ? QUERY_OPTIONS[option] : option
+    end
+
+  end
+end

data/lib/medic/sample_query.rb

@@ -0,0 +1,22 @@
+module Medic
+  class SampleQuery < HKSampleQuery
+
+    include Medic::Types
+    include Medic::Predicate
+    include Medic::Sort
+
+    def initialize(args={}, block=Proc.new)
+      sort = args[:sort_descriptors] || args[:sort_by] || args[:sort_asc] || args[:sort]
+      sort = sort_descriptors(sort) if sort
+      sort ||= sort_descriptors(args[:sort_desc], false) if args[:sort_desc]
+
+      self.initWithSampleType(object_type(args[:type]),
+        predicate: predicate(args),
+        limit: args[:limit] || HKObjectQueryNoLimit,
+        sortDescriptors: sort,
+        resultsHandler: block
+      )
+    end
+
+  end
+end

data/lib/medic/sort.rb

@@ -0,0 +1,24 @@
+module Medic
+  module Sort
+
+    SORT_IDENTIFIERS = {
+      start_date: HKSampleSortIdentifierStartDate,
+      end_date: HKSampleSortIdentifierEndDate
+    }
+
+    def sort_descriptors(symbols, ascending=true)
+      Array(symbols).map do |sym|
+        if sym.is_a? NSSortDescriptor
+          sym
+        else
+          NSSortDescriptor.alloc.initWithKey(sort_identifier(sym), ascending: ascending)
+        end
+      end
+    end
+
+    def sort_identifier(sort_id)
+      sort_id.is_a?(Symbol) ? SORT_IDENTIFIERS[sort_id] : sort_id
+    end
+
+  end
+end

data/lib/medic/source_query.rb

@@ -0,0 +1,15 @@
+module Medic
+  class SourceQuery < HKSourceQuery
+
+    include Medic::Types
+    include Medic::Predicate
+
+    def initialize(args={}, block=Proc.new)
+      self.initWithSampleType(object_type(args[:type]),
+        samplePredicate: predicate(args),
+        completionHandler: block
+      )
+    end
+
+  end
+end

data/lib/medic/statistics_collection_query.rb

@@ -0,0 +1,39 @@
+module Medic
+  class StatisticsCollectionQuery < HKStatisticsCollectionQuery
+
+    include Medic::Types
+    include Medic::Predicate
+    include Medic::StatisticsOptions
+    include Medic::Anchor
+    include Medic::Interval
+
+    def initialize(args={})
+      self.initWithQuantityType(object_type(args[:type]),
+        quantitySamplePredicate: predicate(args),
+        options: options_for_stat_query(args[:options]),
+        anchorDate: anchor_for_symbol(args[:anchor_date] || args[:anchor] || args[:date] || NSDate.date),
+        intervalComponents: interval(args[:interval_components] || args[:interval])
+      )
+      self.initialResultsHandler = Proc.new if block_given?
+      self
+    end
+
+    alias_method :initial_results_handler, :initialResultsHandler
+
+    def initial_results_handler=(callback=Proc.new)
+      self.initialResultsHandler = callback
+    end
+
+    alias_method :statistics_update_handler, :statisticsUpdateHandler
+
+    def statistics_update_handler=(callback=Proc.new)
+      self.statisticsUpdateHandler = callback
+    end
+
+    alias_method :anchor, :anchorDate
+    alias_method :anchor_date, :anchorDate
+    alias_method :interval, :intervalComponents
+    alias_method :interval_components, :intervalComponents
+
+  end
+end

data/lib/medic/statistics_options.rb

@@ -0,0 +1,31 @@
+module Medic
+  module StatisticsOptions
+
+    STATISTICS_OPTIONS = {
+      none: HKStatisticsOptionNone,
+      by_source: HKStatisticsOptionSeparateBySource,
+      separate_by_source: HKStatisticsOptionSeparateBySource,
+      average: HKStatisticsOptionDiscreteAverage,
+      discrete_average: HKStatisticsOptionDiscreteAverage,
+      min: HKStatisticsOptionDiscreteMin,
+      discrete_min: HKStatisticsOptionDiscreteMin,
+      max: HKStatisticsOptionDiscreteMax,
+      discrete_max: HKStatisticsOptionDiscreteMax,
+      sum: HKStatisticsOptionCumulativeSum,
+      cumulative_sum: HKStatisticsOptionCumulativeSum
+    }
+
+    def options_for_stat_query(symbols)
+      options = 0
+      Array(symbols).each do |option|
+        options = options | statistics_option(option)
+      end
+      options
+    end
+
+    def statistics_option(option)
+      option.is_a?(Symbol) ? STATISTICS_OPTIONS[option] : option
+    end
+
+  end
+end

data/lib/medic/statistics_query.rb

@@ -0,0 +1,17 @@
+module Medic
+  class StatisticsQuery < HKStatisticsQuery
+
+    include Medic::Types
+    include Medic::Predicate
+    include Medic::StatisticsOptions
+
+    def initialize(args={}, block=Proc.new)
+      self.initWithQuantityType(object_type(args[:type]),
+        quantitySamplePredicate: predicate(args),
+        options: options_for_stat_query(args[:options]),
+        completionHandler: block
+      )
+    end
+
+  end
+end

data/lib/medic/store.rb

@@ -0,0 +1,117 @@
+module Medic
+  class Store < HKHealthStore
+
+    include Medic::Types
+    include Medic::HKConstants
+
+    def self.shared
+      Dispatch.once { @store ||= new }
+      @store
+    end
+
+    def self.unload
+      @store = nil
+    end
+
+    def self.available?
+      isHealthDataAvailable
+    end
+    singleton_class.send(:alias_method, :is_available?, :available?)
+
+    def authorize(types, block=Proc.new)
+      share = Array(types[:share] || types[:write]).map{ |sym| object_type(sym) }
+      read  = Array(types[:read]).map{ |sym| object_type(sym) }
+
+      requestAuthorizationToShareTypes(NSSet.setWithArray(share), readTypes: NSSet.setWithArray(read), completion: ->(success, error){
+        block.call(success, error)
+      })
+    end
+
+    def authorized?(sym)
+      authorizationStatusForType(object_type(sym)) == HKAuthorizationStatusSharingAuthorized
+    end
+    alias_method :authorized_for?, :authorized?
+    alias_method :is_authorized?, :authorized?
+    alias_method :is_authorized_for?, :authorized?
+
+    def biological_sex
+      error = Pointer.new(:object)
+      sex = biologicalSexWithError error
+      if block_given?
+        yield BIOLOGICAL_SEXES.invert[sex.biologicalSex], error[0]
+      else
+        BIOLOGICAL_SEXES.invert[sex.biologicalSex]
+      end
+    end
+
+    def blood_type
+      error = Pointer.new(:object)
+      blood = bloodTypeWithError error
+      if block_given?
+        yield BLOOD_TYPES.invert[blood.bloodType], error[0]
+      else
+        BLOOD_TYPES.invert[blood.bloodType]
+      end
+    end
+
+    def date_of_birth
+      error = Pointer.new(:object)
+      birthday = dateOfBirthWithError error
+      if block_given?
+        yield birthday, error[0]
+      else
+        birthday
+      end
+    end
+
+    def delete(hk_object, block=Proc.new)
+      deleteObject(hk_object, withCompletion: ->(success, error){
+        block.call(success, error)
+      })
+    end
+    alias_method :delete_object, :delete
+
+    def save(hk_objects, block=Proc.new)
+      saveObjects(Array(hk_objects), withCompletion: ->(success, error){
+        block.call(success, error)
+      })
+    end
+    alias_method :save_object, :save
+    alias_method :save_objects, :save
+
+    # TODO: workout support
+    # addSamples:toWorkout:completion:
+
+    def execute(query)
+      executeQuery(query)
+    end
+    alias_method :execute_query, :execute
+
+    def stop(query)
+      stopQuery(query)
+    end
+    alias_method :stop_query, :stop
+
+    def enable_background_delivery(type, frequency, block=Proc.new)
+      enableBackgroundDeliveryForType(object_type(type), frequency: update_frequency(frequency), withCompletion: ->(success, error){
+        block.call(success, error)
+      })
+    end
+    alias_method :enable_background_delivery_for, :enable_background_delivery
+
+    def disable_background_delivery(type, block=Proc.new)
+      return disable_all_background_delivery(block) if type == :all
+      disableBackgroundDeliveryForType(object_type(type), withCompletion: ->(success, error){
+        block.call(success, error)
+      })
+    end
+    alias_method :disable_background_delivery_for, :disable_background_delivery
+
+    def disable_all_background_delivery(block=Proc.new)
+      disableAllBackgroundDeliveryWithCompletion(->(success, error){
+        block.call(success, error)
+      })
+    end
+
+  end
+end