TokiCLI 0.0.9 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f61d327814465ef395578a24ed1ef8d33bc7d8e
-  data.tar.gz: 41eb44558c632f0e011aca8c2f7b7999cf7471f9
+  metadata.gz: db9fe2bb7c5986f94a5990b01813fa6daf6aa17e
+  data.tar.gz: bcb36afe15205c5b6cb58a7ac356634ac00d85ed
 SHA512:
-  metadata.gz: 4a8462d3658bff7c5403da21f6dadacb9268b6619164197d31ddaa06e06d4a4209caa6cceebc154a624ffaa1907fc54c99591eae5a3ebf6d611c12535e6cc35a
-  data.tar.gz: 951b0f88dbe1a956f06f0c0778f6fe1050b741a8337f94145f05c5173aa7ae82a77f374c78d7ac06b47032847db0051668bd80000d6cec0bb20f053c76530798
+  metadata.gz: a6f27e0aab7776aea2e9778a34ec32e5f01a06f8f36a47c1c16fcea66faccdb5d894d277d607c7eaba35b188064558fde4e7ac22d61ac2f5ccc10afb0637fa68
+  data.tar.gz: 96366f7ca1a02727c778895514d5300ba45ff1a738dcac2a4a7a7284f4c265e68fc84002fe12ae4fdd0e6c0b7951f4c326ee5471da0dfff5009c0f5c89cd90fa

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 0.1.1
+
+- Fixed a dependency in the now yanked 0.1.0
+
+# 0.1.0
+
+- Introducing the API
+- The CLI client uses the API
+- New commands
+
 # 0.0.9
 
 - Skip invalid scanned apps

data/README.md

@@ -9,7 +9,7 @@ Access your Toki data from the local database or from the App.net backup channel
 
 ## Installation
 
-    gem install TokiCLI
+`gem install TokiCLI`
 
 ## Usage
 
@@ -39,25 +39,80 @@ The date you type has to be formatted like this: year-month-day
 
 `toki day 2014-04-19`
 
+### Since
+
+The **since** command shows your top used apps since a specific day.
+
+`toki since 2014-04-19`
+
+### Before
+
+The **before** command shows your top used apps before a specific day.
+
+`toki before 2014-04-19`
+
 ### Range
 
 The **range** command shows your top used apps between two specific days.
 
-The dates you type have to be formatted like this: year-month-day and separated by a single space.
-
 `toki range 2014-04-17 2014-04-19`
 
+### App
+
+Total tracked time for an app
+
+`toki app iterm`
+
+You don't have to specify the exact name of the identifier: for example, typing 'iterm' will find 'com.googlecode.iterm2'.
+
+However, you can specify a bundle identifier if you need it.
+
+`toki app --bundle 'com.googlecode.iterm2'`
+
+### App before
+
+Total tracked time for an app before a specific day
+
+`toki app_before iterm 2014-04-19`
+
+`toki app_before --bundle 'com.googlecode.iterm2' 2014-04-19`
+
+
+### App since
+
+Total tracked time for an app since a specific day
+
+`toki app_since iterm 2014-04-19`
+
+`toki app_since --bundle 'com.googlecode.iterm2' 2014-04-19`
+
+
+### App day
+
+Total tracked time for an app on a specific day
+
+`toki app_day iterm 2014-04-19`
+
+`toki app_day --bundle 'com.googlecode.iterm2' 2014-04-19`
+
+### App range
+
+Total tracked time for an app between two specific days
+
+`toki app_range iterm 2014-04-19 2014-04-23`
+
+`toki app_range --bundle 'com.googlecode.iterm2' 2014-04-19 2014-04-23`
+
+
 ### Log
 
 The **log** command shows the entire log (history) for one app.
 
-You don't have to specify the exact name of the identifier: for example, typing 'iterm' will find 'com.googlecod.iterm2'.
-
 `toki log iterm`
 
-The results are sorted by ascending date and time.
+`toki log --bundle 'com.googlecode.iterm2'`
 
-When pulling the data from ADN instead of the local database, the results are sorted by ascending synced message.
+The results are sorted by ascending date and time.
 
 ### Scan
 
@@ -73,18 +128,6 @@ In order to be able to access your ADN channel (optional), TokiCLI has to obtain
 
 Just do `toki auth` and follow the steps, this is fast and easy.  
 
-### Global option: ADN
-
-TokiCLI accesses the local Toki database by default.
-
-If you want to access the App.net backup channel instead, you have to specify the `-a` option:
-
-`toki total -a`
-
-`toki log vlc -a`
-
-`toki top -n 10 -a` 
-
 ### Global option: JSON
 
 Export the Toki results as a JSON file with the `-j` option:
@@ -105,8 +148,111 @@ Export the Toki results as a CSV file with the `-c` option:
 
 `toki top -n 10 -c` 
 
+## Restore database from App.net
+
+Toki.app backs up your Toki tracked apps data 'in the cloud' via an App.net channel.
+
+TokiCLI is able to download this data and *rebuild the Toki database* if you lost your local install or you're simply moving toki.app to a new machine.
+
+`toki auth`
+
+`toki restore`  
+
+# API
+
+There's a special API if you want to use TokiCLI as a module in another app.
+
+```
+require 'TokiCLI/API/dbapi'
+```  
+
+First of all, create a TokiCLI/API instance:
+
+`toki = TokiCLI::DBAPI.new`
+
+## Endpoints
+
+Get the total time for an app, in seconds, given its exact bundle identifier:
+
+`time = toki.bundle_total 'com.sublimetext.3'`
+
+With a (partial) name:
+
+`time = toki.name_total 'sublime'`
+
+Get the total time for an app, in seconds, given its exact bundle identifier, since a specific day:
+
+`time = toki.bundle_total_since 'com.sublimetext.3', '2014-05-15'`
+
+With a (partial) name:
+
+`time = toki.name_total_since 'sublime', '2014-05-15'`
+
+Get the total time for an app, in seconds, given its exact bundle identifier, before a specific day:
+
+`time = toki.bundle_total_before 'com.sublimetext.3', '2014-05-15'`
+
+With a (partial) name:
+
+`time = toki.name_total_before 'sublime', '2014-05-15'`
+
+Get the total time for an app, in seconds, given its exact bundle identifier, before and since a specific day:
+
+`time = toki.bundle_total_split 'com.sublimetext.3', '2014-05-15'`
+
+With a (partial) name:
+
+`time = toki.name_total_split 'sublime', '2014-05-15'`
+
+Get the total time for an app, in seconds, given its exact bundle identifier, between two specific days:
+
+`time = toki.bundle_total_range 'com.sublimetext.3', '2014-05-15', '2014-05-17'`
+
+With a (partial) name:
+
+`time = toki.name_total_range 'sublime', '2014-05-15', '2014-05-17'`
+
+Get the total time of all apps used between day 1 and day 2:
+
+`apps = toki.apps_range '2014-05-15', '2014-05-17'`
+
+Get the total time of all apps used on a specific day:
+
+`apps = toki.apps_day '2014-05-15'`
+
+Get the total time of all tracked apps:
+
+`apps = toki.apps_total`
+
+Get the top x tracked apps (5 by default):
+
+`apps = toki.apps_top 10`
+
+Get the complete log for an app:
+
+`log = toki.bundle_log 'com.sublimetext.3'`
+
+With a (partial) name:
+
+`log = toki.name_log 'sublime text'`
+
+
+## Tools
+
+Scan disk for installed apps, get their names from their bundle identifiers and save the file (ignores unresolved identifiers):
+
+`app_names = toki.scan_apps`
+
+Get apps names and bundle identifiers (without re-scanning, and including unresolved identifiers):
+
+`app_names = toki.tracked_apps`
+
+Get bundle_id from app name or partial app name:
+
+`bundle_id = toki.get_bundle_from_name 'sublime'`  
+
 
-## Toki
+# Toki
 
 [Toki](https://itunes.apple.com/fr/app/toki/id861749202?mt=12) is a Mac OS X app written by [Keitaroh Kobayashi](http://app.net/keita).
 

data/TokiCLI.gemspec

@@ -18,13 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 1.9.3'
+  spec.required_ruby_version = '>= 2.0.0'
 
   spec.add_dependency "thor", "~> 0.18"
   spec.add_dependency "rest-client", "~> 1.6"
   spec.add_dependency "amalgalite", "~> 1.3"
   spec.add_dependency "terminal-table", "~> 1.4"
-  spec.add_dependency "CFPropertyList", "~> 2.2.8"
+  spec.add_dependency "CFPropertyList", "~> 2.2"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"

data/lib/API/dbapi.rb

@@ -0,0 +1,451 @@
+# encoding: utf-8
+module TokiCLI
+  class DBAPI
+
+    require 'ostruct'
+    require 'amalgalite'
+    require 'CFPropertyList'
+    require 'terminal-table/import'
+    require 'json'
+    require 'fileutils'
+    require_relative "../TokiCLI/version"
+    require_relative "helpers"
+
+    attr_accessor :helpers, :db, :table
+
+    def initialize
+      @helpers = Helpers.new
+      @db = @helpers.db
+      @table = @helpers.table
+    end
+
+    ## ENDPOINTS
+
+    # Get the total time for an app given its exact bundle identifier
+    def bundle_total bundle_id, orig = nil
+      sec = (@db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}'").flatten)[0]
+      args = if orig.nil?
+        [bundle_id]
+      else
+        [bundle_id, orig]
+      end
+      { meta: {
+          code: 200,
+          request: {command: 'bundle_total', args: args, processed_at: Time.now}
+        },
+        data: {
+          bundle: bundle_id,
+          name: @helpers.find_app_name(bundle_id),
+          total: {
+            seconds: sec,
+            time: @helpers.sec_to_time(sec)
+          }
+        }
+      }.to_json
+    end
+
+    # Get the total time for an app given a (partial) name
+    def name_total name
+      bun = JSON.parse(get_bundle_from_name(name))
+      if bun['meta']['code'] == 200
+        bundle_total bun['data']['bundle'], name
+      else
+        @helpers.json_nodata
+      end
+    end
+
+    # Get the total time for an app given its exact bundle identifier, since a specific day
+    def bundle_total_since bundle_id, day, orig = nil
+      since = (@db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom >= #{Time.parse(day).to_i}").flatten)[0]
+      args = if orig.nil?
+        [bundle_id, day]
+      else
+        [bundle_id, day, orig]
+      end
+      { meta: {
+          code: 200,
+          request: {command: 'bundle_total_since', args: args, processed_at: Time.now}
+        },
+        data: {
+          bundle: bundle_id,
+          name: @helpers.find_app_name(bundle_id),
+          since: day,
+          total: {
+            seconds: since,
+            time: @helpers.sec_to_time(since)
+          }
+        }
+      }.to_json
+    end
+
+    # Get the total time for an app given a (partial) name, since a specific day
+    def name_total_since name, day
+      bun = JSON.parse(get_bundle_from_name(name))
+      if bun['meta']['code'] == 200
+        bundle_total_since bun['data']['bundle'], day, name
+      else
+        @helpers.json_nodata
+      end
+    end
+
+    # Get the total time for an app given its exact bundle identifier, before a specific day
+    def bundle_total_before bundle_id, day, orig = nil
+      before = (@db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom < #{Time.parse(day).to_i}").flatten)[0]
+      args = if orig.nil?
+        [bundle_id, day]
+      else
+        [bundle_id, day, orig]
+      end
+      { meta: {
+          code: 200,
+          request: {command: 'bundle_total_before', args: args, processed_at: Time.now}
+        },
+        data: {
+          bundle: bundle_id,
+          name: @helpers.find_app_name(bundle_id),
+          before: day,
+          total: {
+            seconds: before,
+            time: @helpers.sec_to_time(before)
+          }
+        }
+      }.to_json
+    end
+
+    # Get the total time for an app given a (partial) name, before a specific day
+    def name_total_before name, day
+      bun = JSON.parse(get_bundle_from_name(name))
+      if bun['meta']['code'] == 200
+        bundle_total_before bun['data']['bundle'], day, name
+      else
+        @helpers.json_nodata
+      end
+    end
+
+    # Get the total time for an app given its exact bundle identifier, before and since a specific day
+    def bundle_total_split bundle_id, day, orig = nil
+      before = (@db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom < #{Time.parse(day).to_i}").flatten)[0]
+      since = (@db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom >= #{Time.parse(day).to_i}").flatten)[0]
+      args = if orig.nil?
+        [bundle_id, day]
+      else
+        [bundle_id, day, orig]
+      end
+      { meta: {
+          code: 200,
+          request: {command: 'bundle_total_split', args: args, processed_at: Time.now}
+        },
+        data: {
+          bundle: bundle_id,
+          name: @helpers.find_app_name(bundle_id),
+          split: day,
+          total: {
+            seconds: {
+              before: before,
+              since: since
+            },
+            time: {
+              before: @helpers.sec_to_time(before),
+              since: @helpers.sec_to_time(since)
+            }
+          }
+        }
+      }.to_json
+    end
+
+    # Get the total time for an app given a (partial) name, before and since a specific day
+    def name_total_split name, day
+      bun = JSON.parse(get_bundle_from_name(name))
+      if bun['meta']['code'] == 200
+        bundle_total_split bun['data']['bundle'], day, name
+      else
+        @helpers.json_nodata
+      end
+    end
+
+    # Get the total time for an app given its exact bundle identifier, between two specific days
+    def bundle_total_range bundle_id, day1, day2, orig = nil
+      total = (@db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom >= #{Time.parse(day1).to_i} AND activeFrom < #{Time.parse(day2).to_i}").flatten)[0]
+      args = if orig.nil?
+        [bundle_id, day1, day2]
+      else
+        [bundle_id, day1, day2, orig]
+      end
+      if total.nil?
+        @helpers.json_nodata
+      else
+        { meta: {
+            code: 200,
+            request: {command: 'bundle_total_range', args: args, processed_at: Time.now}
+          },
+          data: {
+            bundle: bundle_id,
+            name: @helpers.find_app_name(bundle_id),
+            from: day1,
+            to: day2,
+            total: {
+              seconds: total,
+              time: @helpers.sec_to_time(total)
+            }
+          }
+        }.to_json
+      end
+    end
+
+    # Get the total time for an app given a (partial) name, between two specific days
+    def name_total_range name, day1, day2
+      bun = JSON.parse(get_bundle_from_name(name))
+      if bun['meta']['code'] == 200
+        bundle_total_range bun['data']['bundle'], day1, day2, name
+      else
+        @helpers.json_nodata
+      end
+    end
+
+    # Get all apps used between day 1 and day 2
+    def apps_range day1, day2
+      result = []
+      range = @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} WHERE activeFrom >= #{Time.parse(day1).to_i} AND activeFrom < #{Time.parse(day2).to_i} GROUP BY bundleIdentifier")
+      range.each {|id,sec| result << {
+        bundle: id,
+        name: @helpers.find_app_name(id),
+        total: {
+          seconds: sec,
+          time: @helpers.sec_to_time(sec)
+        }}
+      }
+      result.sort_by! {|obj| obj[:total][:seconds]}
+      {
+        meta: {
+          code: 200,
+          request: {command: 'apps_range', args: [day1, day2], processed_at: Time.now}
+        },
+        data: {
+          from: day1,
+          to: day2,
+          apps: result
+        }
+      }.to_json
+    end
+
+    # Get all apps used on a specific day
+    def apps_day day
+      date = DateTime.strptime(day, '%Y-%m-%d')
+      response = @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} WHERE activeFrom >= #{date.to_time.to_i} AND activeFrom < #{date.next_day.to_time.to_i} GROUP BY bundleIdentifier")
+      result = make_apps response
+      {
+        meta: {
+          code: 200,
+          request: {command: 'apps_day', args: [day], processed_at: Time.now}
+        },
+        data: {
+          date: day,
+          apps: result
+        }
+      }.to_json
+    end
+
+    def apps_since day
+      date = DateTime.strptime(day, '%Y-%m-%d')
+      response = @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} WHERE activeFrom >= #{date.to_time.to_i} GROUP BY bundleIdentifier")
+      result = make_apps response
+      {
+        meta: {
+          code: 200,
+          request: {command: 'apps_since', args: [day], processed_at: Time.now}
+        },
+        data: {
+          since: day,
+          apps: result
+        }
+      }.to_json
+    end
+
+    def apps_before day
+      date = DateTime.strptime(day, '%Y-%m-%d')
+      response = @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} WHERE activeFrom < #{date.to_time.to_i} GROUP BY bundleIdentifier")
+      result = make_apps response
+      {
+        meta: {
+          code: 200,
+          request: {command: 'apps_before', args: [day], processed_at: Time.now}
+        },
+        data: {
+          before: day,
+          apps: result
+        }
+      }.to_json
+    end
+
+    # Get totals of all tracked apps
+    def apps_total
+      result = make_total
+      {
+        meta: {
+          code: 200,
+          request: {command: 'apps_total', args: [], processed_at: Time.now}
+        },
+        data: {
+          apps: result
+        }
+      }.to_json
+    end
+
+    # Get totals of top tracked apps
+    def apps_top number = 5
+      result = make_total
+      index = -number
+      {
+        meta: {
+          code: 200,
+          request: {command: 'apps_top', args: [number], processed_at: Time.now}
+        },
+        data: {
+          apps: result[index..-1]
+        }
+      }.to_json
+    end
+
+    # Get the complete log for an app
+    def bundle_log bundle_id, orig = nil
+      log = @db.execute("SELECT * FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}'")
+      # id (INTEGER) 0, bundleIdentifier (VARCHAR) 1, activeFrom (INTEGER) 2, activeTo (INTEGER) 3, totalSeconds (INTEGER) 4, UUID (VARCHAR) 5, synced (INTEGER) 6, availableToSync (INTEGER) 7
+      result = {}
+      log.each do |arr|
+        result[arr[0]] = {
+          start: @helpers.epoch_to_date(arr[2]),
+          duration: {
+            seconds: arr[4],
+            time: @helpers.seconds_to_time(arr[4])
+          }
+        }
+      end
+      args = if orig.nil?
+        [bundle_id]
+      else
+        [bundle_id, orig]
+      end
+      { meta: {
+          code: 200,
+          request: {command: 'bundle_total', args: args, processed_at: Time.now}
+        },
+        data: {
+          bundle: bundle_id,
+          name: @helpers.find_app_name(bundle_id),
+          log: result
+        }
+      }.to_json
+    end
+
+    # Get the complete log for an app, given a (partial) name
+    def name_log name
+      bun = JSON.parse(get_bundle_from_name(name))
+      if bun['meta']['code'] == 200
+        bundle_log bun['data']['bundle'], name
+      else
+        @helpers.json_nodata
+      end
+    end
+
+
+    ## TOOLS
+
+    # Get all data from database
+    def get_all_data
+      (@helpers.get_all_data).to_json
+    end
+
+    # Scan disk for installed apps
+    def scan_apps
+      apps = []
+      (@helpers.scan).each do |id,name|
+        apps << {bundle: id, name: name}
+      end
+      {
+        meta: {
+          code: 200,
+          request: {
+            command: 'scan_apps',
+            processed_at: Time.now
+          }
+        },
+        data: {
+          apps: apps
+        }
+      }.to_json
+    end
+
+    # List of tracked apps
+    # (Run scan_apps before if necessary)
+    def tracked_apps
+      apps, ids = [], (@db.execute("SELECT bundleIdentifier FROM #{@table}")).flatten.uniq!
+      ids.each do |id|
+        @helpers.bundles.has_key?(id) ? apps << {bundle: id, name: @helpers.bundles[id]} : apps << {bundle: id, name: id}
+      end
+      {
+        meta: {
+          code: 200,
+          request: {
+            command: 'tracked_apps',
+            processed_at: Time.now
+          }
+        },
+        data: {
+          apps: apps
+        }
+      }.to_json
+    end
+
+    # Get bundle_id from app name or partial app name
+    # (Run scan_apps before if necessary)
+    def get_bundle_from_name name
+      resp = @helpers.get_bundle_from_name name
+      meta = {
+        request: {
+          command: 'get_bundle_from_name',
+          args: [name],
+          processed_at: Time.now
+          }
+      }
+      resp.empty? ?
+        {
+          meta: meta.merge!({
+            code: 404,
+            error: { message: "Unable to find an app containing '#{name}'" }
+          }),
+          data: {}
+        }.to_json :
+        {
+        meta: meta.merge!({code: 200}),
+        data: {
+          request: name,
+          bundle: resp[1],
+          name: resp[0]
+        }
+      }.to_json
+    end
+
+    private
+
+    def make_total
+      response = @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} GROUP BY bundleIdentifier")
+      make_apps response
+    end
+
+    def make_apps response
+      result = []
+      response.each {|id,sec| result << {
+        bundle: id,
+        name: @helpers.find_app_name(id),
+        total: {
+          seconds: sec,
+          time: @helpers.sec_to_time(sec)
+          }
+        }
+      }
+      result.sort_by! {|obj| obj[:total][:seconds]}
+      result
+    end
+
+  end
+end