gsquire 0.0.3

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+.yardoc
+doc
+tmp

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --charset utf-8 --main README.md

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gsquire.gemspec
+gemspec

data/README.md

@@ -0,0 +1,54 @@
+# GSquire
+
+Back in the Age of Heroes, GSquire would carry thy armor and sword, would get
+thy lordship dressed and accompany in battle. He would fight side by side with
+those who stood brave against the toughest of the foes. These were good times
+to be alive.
+
+Then a swift, strange, wind blew upon this land and everything we knew was
+washed away and replaced by something new. All we used to know about living,
+eating, singing and smiling was made anew. Not everyone could handle that, many
+were forced into this. Those who were born during this time, never knew how was
+the world before.
+
+Some received this wind as a blessing from gods, others deemed it cursed. The
+only agreement was in calling it Web 2.0.
+
+## Really, WTF is this?
+
+GSquire is a Google Tasks squire. More explicitly, it is one more fucking tool
+to handle all the fucking data. Its main purpose is to export/import tasks
+across accounts and as a side effect it has powers to create, read, update and
+delete those tasks too.
+
+A commandline interface is provided and can be used to dump tasklists to files
+also to import them on another account. It also has commands to create, read,
+update and delete tasks and tasklists, so you feel a real hacker reading and
+writing stuff on a black screen.
+
+Lastly, and of course, it can be used as a library.
+
+Now you should be aware that you could come up with very creative ways to write
+and manage a shitload more of data, and everyone is expected to do it, right?
+
+_Remember kids: data, like [Ubik](http://en.wikipedia.org/wiki/Ubik), is
+everywhere. Take as directed and do not exceed recommended dosage._
+
+## I want to deal with a shitload more of data
+
+* Instantiate an {GSquire::Application#initialize Application} and access its
+  `accounts` (instance attribute)
+* Access the {GSquire::Accounts#authorize_url authorization url} and
+  {GSquire::Accounts#authorize! add} an account
+* Embrace and {GSquire::Accounts#[] hold} that account
+* Keep pushing the {GSquire::Client#create_task bright},
+  {GSquire::Client#create_tasklist shiny}, {GSquire::Client#delete_tasklist
+  colorful}, {GSquire::Client#task tasty}, {GSquire::Client#tasklist nice},
+  {GSquire::Client#tasklists chuncky bacon}, {GSquire::Client#tasks pretty} and
+  {GSquire::Client#update_tasklist amazing} buttons!
+
+## I want to deal with a shitload more of data from a black screen
+
+* Turn off the lights (enhances special effects)
+* Take the **red** pill (special effects begin)
+* As fast as you can, type `gsquire help`

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/gsquire

@@ -0,0 +1,334 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'thor'
+require 'gsquire'
+
+class App < Thor
+  include Thor::Actions
+
+  EXPORT_FORMATS = %w(json).freeze
+  INPUT_FORMATS = %w(json).freeze
+
+  attr_reader :app
+
+  def initialize(*)
+    super
+    app_opts = { :log => options.debug? ? :debug : nil }
+    app_opts[:path] = ENV['GSQUIRE_PATH'] if ENV['GSQUIRE_PATH']
+    @app = GSquire::Application.new app_opts
+  end
+
+  %w(add list rm default).each do |task|
+    map "account:#{task}" => "account_#{task}"
+  end
+  map "account" => "account_list"
+
+  desc "export ACCOUNTS [options]", "Export task lists and tasks for ACCOUNTS"
+  method_option :format, :aliases => '-f', :type => :string, :default => 'json', :desc => "Output file format (valid: #{EXPORT_FORMATS.map(&:to_s).join(', ')})"
+  method_option :output, :aliases => '-o', :type => :string, :default => "{account}", :desc => "Output file name (use `{account}` to be replaced by account name. Format will be appended as file extension)"
+  def export(*accounts)
+    if not EXPORT_FORMATS.include? options.format
+      say_status "export", "invalid format #{options.format}", :red
+      exit 1
+    end
+
+    if accounts.empty?
+      say_status "export", "need an account name", :red
+      exit 1
+    end
+
+    accounts.each do |account|
+      result = []
+      client = app.accounts[account]
+      begin
+        client.tasklists.each do |tasklist|
+          tasklist[:tasks] = client.tasks tasklist[:id]
+          result << tasklist
+          say_status "tasklist", tasklist['title']
+        end
+      rescue GSquire::Accounts::NotAuthorized
+        authorize account
+        retry
+      rescue GSquire::Accounts::NotFound
+        say_status "export", "account #{account} not found, skipping", :yellow
+        next
+      rescue
+        say_status "export", "error exporting #{account}", :red
+        next
+      end
+
+      output = options.output.gsub /{account}/, account
+      output << ".#{options.format}"
+      
+      case fmt = options.format.to_sym
+      when :json
+        File.open(output, 'w') {|f| f.write JSON.pretty_generate result }
+=begin Yeah, I'm committing commented code, I feel bad.
+      when :dot, :png
+        graph = GraphViz.new 'Tasks', :type => :digraph
+        result.each do |tasklist|
+          list_node = graph.add_nodes tasklist['id'], :label => "#{tasklist['name']} (#{tasklist['id']})"
+          tasklist['tasks'].each do |task|
+            task_node = graph.add_nodes task['id'], :label => "#{task['name']} (#{task['id']})"
+            graph.add_edges task_node, list_node
+          end
+        end
+        graph.output(fmt => output)
+=end
+      end
+
+      task_count = result.inject(0) {|sum, h| sum += h[:tasks].size }
+      say_status "export:#{options.format}",
+        format("%s [%s tasklists, %s tasks]", cyan(output, :bold), blue(result.size.to_s, :bold), magenta(task_count.to_s, :bold))
+    end
+  end
+
+  desc "import ACCOUNT INPUT [options]", "Import task lists and tasks from INPUT file into ACCOUNT"
+  method_option :format, :aliases => '-f', :type => :string, :default => 'json', :desc => "Input file format (valid: #{INPUT_FORMATS.join(', ')})"
+  method_option :pretend, :aliases => '-p', :type => :boolean, :default => false, :desc => "Run but do not make any changes"
+  method_option :debug, :aliases => '-d', :type => :boolean, :default => false, :desc => "Turn on debugging"
+  #method_option :graph, :aliases => '-g', :type => :boolean, :default => false, :desc => "Generates a graph image of both the import and result sets"
+  def import(account, input)
+    if not INPUT_FORMATS.include? options.format
+      say_status "export", "invalid format #{options.format}", :red
+      exit 1
+    end
+
+=begin I'm doing it again, fuck me.
+    if options.graph?
+      begin
+        require 'graphviz'
+      rescue LoadError
+        raise Thor::Error, "'ruby-graphviz' gem is required to generate a graph visualization"
+      end
+
+      graph_src = GraphViz.new 'Import', :type => :digraph
+      graph_dest = GraphViz.new 'Result', :type => :digraph
+    end
+=end
+
+    tasklists = case options.format.to_sym
+      when :json
+        JSON.parse(File.read input)
+      end
+
+    parents, orphans = prepare_tasklists!(tasklists)
+
+    if options.pretend?
+      client = nil
+      tasklist_id_seq = id_seq
+    else
+      begin
+        client = app.accounts[account]
+      rescue GSquire::Accounts::NotAuthorized
+        authorize account
+        retry
+      end
+    end
+
+    total_tasks = 0
+    tasklists.each do |tasklist|
+      task_count = 0
+
+      if options.pretend?
+        new_tasklist = { 'title' => tasklist['title'], 'id' => "tasklist-#{tasklist_id_seq.next}" }
+        task_id_seq = id_seq
+      else
+        new_tasklist = client.create_tasklist(tasklist)
+      end
+
+=begin When you do it twice, you stop caring.
+      if options.graph?
+        graph_src.add_node(tasklist['id'])
+        graph_dest.add_node(new_tasklist['id'])
+      end
+=end
+
+      debug "tasklist:create '#{new_tasklist['title']}' (#{new_tasklist['id']})"
+
+      tasklist['tasks'].each do |task|
+        if orphans.include? task['id']
+          debug "skip: orphaned task #{task['title']} (#{task['id']})"
+          next
+        end
+
+        if task.has_key? 'parent'
+          if parents.fetch(task['parent'], :placeholder) == :placeholder
+            parent = tasklist['tasks'].find {|t| t['id'] == task['parent']}
+            tasks = [task, parent].map {|t| "#{t['id'].rjust(35)} #{t['position'].to_s.rjust(20)}" }.join("\n")
+            debug "skip: child called not yet initialized parent:\n#{tasks}"
+            next
+          end
+
+          debug "parent:rename #{task['parent']} #{parents[task['parent']]}"
+          task['parent'] = parents[task['parent']]
+        end
+
+        task['title'].strip!
+
+        if options.pretend?
+          new_task = task.dup.update 'id' => "task-#{task_id_seq.next}"
+        else
+          new_task = client.create_task(task, new_tasklist['id'])
+        end
+
+        debug "task:create '#{new_task['title']}' (#{new_task['id']}, #{task['id']})#{new_task['parent'] ? " [child of #{new_task['parent']}]" : ""}"
+
+        task_count += 1
+
+        if parents.include? task['id']
+          debug "trying to set parent id #{task['id']} twice" if parents[task['id']] != :placeholder
+          parents[task['id']] = new_task['id']
+        end
+      end
+
+      total_tasks += task_count
+
+      say_status "tasklist",
+        format("%s [%s %s]",
+               blue(tasklist['title'], :bold),
+               magenta(task_count, :bold),
+               pluralize(task_count, "task"))
+    end
+
+    say_status "import:#{options.format}",
+      format("%s [%s %s, %s %s]",
+             cyan(account, :bold),
+             blue(tasklists.size, :bold),
+             pluralize(tasklists.size, "tasklist"),
+             magenta(total_tasks, :bold),
+             pluralize(total_tasks, "task"))
+  end
+
+  desc "account:add NAME", "Adds an account with NAME"
+  def account_add(name)
+    if app.accounts.include? name
+      say_status "skip", "account already exists", :yellow
+      return
+    end
+
+    begin
+      authorize name
+      say_status "account:add", name
+    rescue
+      say_status "account:add", "Something went wrong authorizing this account. Did you wait too much to enter the authorization code provided Google? Please try again", :red
+    end
+  end
+
+  desc 'account:list', 'List accounts (default is marked with `*`)'
+  def account_list
+    accounts = app.accounts.map do |acc|
+      acc == app.accounts.default ? "* #{green(acc)}" : acc
+    end
+    say accounts.join("\n")
+  end
+
+  desc 'account:default [ACCOUNT]', 'If given, set default account to ACCOUNT, otherwise show current default account'
+  def account_default(account = nil)
+    if account
+      begin
+        app.accounts.default = account
+        say_status 'account:default', account
+      rescue GSquire::Accounts::NotFound
+        say_status 'account:default', 'account not found', :red
+      end
+    else
+      say app.accounts.default
+    end
+  end
+
+  desc 'account:rm ACCOUNT', 'Removes ACCOUNT'
+  def account_rm(account)
+    if app.accounts.delete account
+      say_status 'account:rm', account
+    else
+      say_status 'account:rm', 'account not found', :red
+    end
+  end
+
+  protected
+
+  def authorize(name)
+    msg = <<-EOM
+GSquire needs your seal of approval to manage tasks on #{name} account.
+Point your browser to
+
+#{app.accounts.authorize_url}
+
+to get one and bring it here to him!
+
+    EOM
+
+    say msg
+    code = ask "Enter code:"
+
+    app.accounts[name] = code
+  end
+
+  colors = %w(bold clear) +
+    %w(black red green yellow blue magenta cyan white).map do |color|
+        [color, "on_#{color}"]
+    end.flatten
+
+  colors.each do |color|
+    class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      no_tasks do
+        def #{color}(s, bold = false)
+          paint s, #{color.to_sym.inspect}, bold
+        end
+      end
+    EOF
+  end
+
+  def paint(s, color, bold = false)
+    color_shell.set_color(s, color.to_sym, bold == :bold)
+  end
+
+  def color_shell
+    @color_shell ||= begin
+      shell.is_a?(Thor::Shell::Color) ? shell : \
+        Object.new.instance_eval {|me| def set_color(s, *); s; end; me }
+    end
+  end
+
+  def pluralize(count, singular, plural = nil)
+    (count == 1 || count =~ /^1(\.0+)?$/) ? singular : (plural || "#{singular}s")
+  end
+
+  def debug(msg)
+    say_status "debug", msg, :white if options.debug?
+  end
+
+  # Handle parent-child relationships
+  def prepare_tasklists!(tasklists)
+    parents = {}
+    orphans = []
+    tasklist_ids = tasklists.map {|list| list['id'] }
+    tasklists.each do |tasklist|
+      task_ids = tasklist['tasks'].map {|task| task['id'] }
+      tasklist['tasks'].each do |task|
+        next unless task.has_key? 'parent'
+        if not task_ids.include?(task['parent'])
+          if tasklist_ids.include?(task['parent'])
+            task.delete 'parent'
+          else
+            orphans << task['id']
+          end
+        else
+          parents[task['parent']] ||= :placeholder
+        end
+      end
+
+      tasklist['tasks'].sort_by! {|t| t.include?('parent') ? 1 : 0 }
+    end
+
+    [parents, orphans]
+  end
+
+  def id_seq
+    Enumerator.new {|e| i = -1; loop { e << (i += 1) } }
+  end
+end
+
+App.start

data/gsquire.gemspec

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+$:.push File.expand_path("../lib", __FILE__)
+
+require "gsquire/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gsquire"
+  s.version     = GSquire::VERSION
+  s.authors     = ["Kiyoshi '13k' Murata"]
+  s.email       = ["13k@linhareta.net"]
+  s.homepage    = "http://commita.com/community"
+  s.summary     = %q{A commandline and library squire to look for thy lordly Google Tasks.}
+  s.description = %q{Back in the Age of Heroes, GSquire would carry thy armor
+    and sword, would get thy lordship dressed and accompany in battle. He would
+    fight side by side with those who stood brave against the toughest of the
+    foes. These were good times to be alive.
+
+    Then a swift, strange, wind blew upon this land and everything we knew was
+    washed away and replaced by something new. All we used to know about
+    living, eating, singing and smiling was made anew. Not everyone could
+    handle that, many were forced into this. Those who were born during this
+    time, never knew how was the world before.
+
+    Some received this wind as a blessing from gods, others deemed it cursed.
+    The only agreement was in calling it Web 2.0.}
+
+  s.add_dependency 'oauth2', '~> 0.5.0'
+  s.add_dependency 'thor', '~> 0.14.6'
+  s.add_dependency 'hashie', '~> 1.1.0'
+
+  s.add_development_dependency 'rdoc'
+  s.add_development_dependency 'rdiscount'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'awesome_print'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/gsquire/accounts/tasks_api_middleware.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'hashie'
+
+module GSquire
+  class Accounts
+    class TasksApiMiddleware < Faraday::Response::Middleware
+      def on_complete(env)
+        if (env[:status] == 200) && json?(env)
+          env[:tasks_api_result] = api_result env
+        end
+      end
+
+      protected
+
+      def api_result(env)
+        result = JSON.parse env[:body]
+        if result.include? 'items'
+          result['items'].map {|h| mash h }
+        else
+          mash result
+        end
+      end
+
+      def mash(hash)
+        Hashie::Mash.new hash
+      end
+
+      def content_type(env)
+        k, v = env[:response_headers].find {|k, v| k =~ /content-type/i} || ["", ""]
+        v.split(';').first.to_s.downcase
+      end
+
+      def json?(env)
+        %w(application/json text/javascript).include? content_type(env)
+      end
+    end
+  end
+end

data/lib/gsquire/accounts/tokens.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+require 'json'
+require 'oauth2'
+
+module GSquire
+  class Accounts
+    class Tokens < Hash
+      attr_reader :options, :client, :path
+
+      TOKENS_FILE = 'tokens.json'
+
+      # @option opts [String] :path Path to GSquire database. Required and must exist.
+      # @option opts [Client] :client {GSquire::Client} instance. Required.
+      def initialize(opts = {})
+        [:path, :client].each do |o|
+          raise ArgumentError, "Option #{o.inspect} is required" unless opts.include?(o)
+        end
+
+        @options = opts
+        @path = File.join options[:path], TOKENS_FILE
+        @client = options[:client]
+        
+        super
+        
+        self.load!
+      end
+
+      def save
+        if dirty?
+          File.open(path, 'w') do |f|
+            f.write self.to_json
+          end
+          clean!
+        end
+        self
+      end
+
+      def load!
+        hash = begin
+            from_json(File.read path)
+          rescue JSON::ParserError, Errno::ENOENT
+            {}
+          end
+        replace hash
+        clean!
+        self
+      end
+
+      def dirty?
+        @dirty
+      end
+
+      def clean?
+        !dirty?
+      end
+
+      def to_json
+        inject({}) do |hash, key_value|
+          hash.store key_value[0], token_hash(key_value[1])
+          hash
+        end.to_json
+      end
+
+      def []=(name, token)
+        token.params[:name] = name if token.respond_to? :params
+        r = super
+        dirty!
+        save
+        r
+      end
+      alias :store :[]=
+
+      def delete(name)
+        r = super
+        dirty!
+        save
+        r
+      end
+
+      protected
+
+      def clean!
+        @dirty = false
+      end
+
+      def dirty!
+        @dirty = true
+      end
+
+      def token_hash(token)
+        return token if not token.is_a? OAuth2::AccessToken
+
+        {
+          :access_token => token.token,
+          :refresh_token => token.refresh_token,
+          :expires_at => token.expires_at,
+          :expires_in => token.expires_in
+        }
+      end
+
+      def from_json(json)
+        hash = JSON.parse(json)
+        hash.update(hash) do |k, v, *|
+          t = OAuth2::AccessToken.from_hash client, v
+          t.params[:name] = k
+          t
+        end
+      end
+    end
+  end
+end

data/lib/gsquire/accounts.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+require 'json'
+require 'oauth2'
+require 'gsquire/client'
+require 'gsquire/logging'
+require 'gsquire/accounts/tokens'
+require 'gsquire/accounts/tasks_api_middleware'
+
+module GSquire
+  
+  #
+  # Main class for GSquire.
+  #
+  # It handles multiple accounts and maintains a list
+  # of {Client} instances, each one associated with one Google account.
+  # Each client can then perform actions on tasklists and tasks (read, create,
+  # update, delete).
+  #
+  
+  class Accounts
+    include Enumerable
+
+    CLIENT_ID = '365482102803.apps.googleusercontent.com'
+    CLIENT_SECRET = 'Y3UeEPOUEc60d_DbJOzFsr2Y'
+    OAUTH_OUTOFBAND = 'urn:ietf:wg:oauth:2.0:oob'
+    GOOGLE_TASKS_SCOPE = 'https://www.googleapis.com/auth/tasks'
+    GOOGLE_OAUTH2_AUTH = 'https://accounts.google.com/o/oauth2/auth'
+    GOOGLE_OAUTH2_TOKEN = 'https://accounts.google.com/o/oauth2/token'
+    DEFAULT_FILE = 'default'
+
+    class NotAuthorized < Exception; end
+    class NotFound < Exception; end
+
+    attr_reader :tokens, :logger, :options
+
+    # @option opts [String] :path Path to GSquire database. Required and must exist.
+    # @option opts [Logger] :logger Logger instance to be used for logging.
+    def initialize(opts = {})
+      if opts[:path].nil? || !File.exist?(opts[:path])
+        raise ArgumentError, ":path option is required and must exist"
+      end
+      
+      @options = opts
+      @logger = options[:logger] || DummyLogger.new
+      @tokens = Tokens.new :path => options[:path], :client => oauth_client
+      @clients = {}
+    end
+
+    def each
+      tokens.keys.each {|key| yield key }
+    end
+
+    # Returns an account client
+    # @param [String] name Account name
+    # @return [Client] account client
+    def [](name)
+      raise NotFound, "Account #{name} not found" unless tokens.include? name
+
+      token = tokens[name]
+
+      if token.expired? and token.refresh_token.to_s.strip.empty?
+        @clients.delete name
+        raise NotAuthorized, "Token for account #{name} is expired and cannot be renewed"
+      end
+
+      if token.expired?
+        logger.debug "Token for account #{name} expired, renewing"
+        token = tokens.store name, token.refresh!
+        @clients[name] = nil
+      end
+
+      @clients[name] ||= Client.new token
+    end
+
+    # Authorizes GSquire with the token Google gave to user
+    # @param [String] name Account name
+    # @param [String] code Authorization code provided by Google
+    # @return [String] OAuth token string
+    def authorize!(name, code)
+      token = oauth_client.auth_code.get_token code, redirect_uri: OAUTH_OUTOFBAND
+      tokens[name] = token
+    end
+    alias :[]= :authorize!
+
+    # Removes account
+    # @param [String] name Account name
+    # @return [OAuth2::AccessToken] Access token associated to that account
+    def delete(name)
+      tokens.delete name
+    end
+
+    # Returns default account name
+    # @return [String] default account name
+    def default
+      @default ||= begin
+        name = begin
+          File.read(default_path).strip
+        rescue Errno::ENOENT
+          ""
+        end
+        if name.empty?
+          if tokens.size == 1
+            self.default = tokens.first.first
+          else
+            nil
+          end
+        else
+          if tokens.include?(name)
+            name
+          else
+            self.default = nil
+            self.default
+          end
+        end
+      end
+    end
+
+    # Sets default account
+    # @param [String] name Account name
+    def default=(name)
+      if name.nil?
+        File.truncate default_path, 0
+        nil
+      else
+        raise NotFound, "Account #{name} not found" unless tokens.include?(name)
+        File.open(default_path, 'w') {|f| f.write(name) }
+        name
+      end
+    end
+
+    # Use this method to get the URL to show user to authorize GSquire
+    # @return [String] authorization URL
+    def authorize_url
+      oauth_client.auth_code.authorize_url \
+        redirect_uri: OAUTH_OUTOFBAND,
+        scope: GOOGLE_TASKS_SCOPE
+    end
+
+    def inspect
+      tokens.keys.inspect
+    end
+
+    def to_s
+      tokens.keys.to_s
+    end
+
+    protected
+
+    def oauth_client
+      @oauth_client ||= begin
+        OAuth2::Client.new(CLIENT_ID, CLIENT_SECRET,
+          authorize_url: GOOGLE_OAUTH2_AUTH,
+          token_url: GOOGLE_OAUTH2_TOKEN) do |builder|
+            builder.request :url_encoded
+            builder.response :logger, logger
+            builder.response :raise_error
+            builder.use GSquire::Accounts::TasksApiMiddleware
+            builder.adapter :net_http
+        end
+      end
+    end
+
+    def default_path
+      File.join options[:path], DEFAULT_FILE
+    end
+  end
+end

data/lib/gsquire/application.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'logger'
+require 'fileutils'
+require 'gsquire/accounts'
+require 'gsquire/logging'
+
+module GSquire
+  
+  #
+  # This is the entry-point class for GSquire. Clients should use it to implement applications that use GSquire.
+  #
+  # As of now it is only a simple container used to setup logging and the database directory.
+  #
+  # Since GSquire supports multiple accounts by default, this class simply wraps an {Accounts} instance that is available through the `accounts` instance attribute.
+  #
+  class Application
+    # {Accounts} instance that holds all authorized Google accounts in the GSquire database stored at `options[:path]`.
+    attr_reader :accounts
+    # Parsed options.
+    attr_reader :options
+
+    # @option opts [String] :path ("~/.gsquire") Where to store GSquire database
+    # @option opts [Logger,String,Symbol] :log (nil) Enables logging. Pass a configured Logger object to be used directly; or a String to change the filename and use the default level (must be absolute path); or a Symbol to change log level and use the default filename. If not present (`nil`), logging is disabled.
+    def initialize(opts = {})
+      @options = {
+        :path => File.join(ENV['HOME'], '.gsquire')
+      }.merge(opts)
+
+      begin
+        FileUtils.mkdir_p options[:path]
+      rescue
+        abort "Error creating GSquire database directory: #{$!}"
+      end
+
+      @accounts = Accounts.new :path => options[:path], :logger => logger
+    end
+
+    protected
+
+    def logger
+      @logger ||= begin
+        case options[:log]
+        when Logger
+          options[:log]
+        when Symbol, String
+          file, level = case options[:log]
+            when Symbol
+              [File.join(options[:path], 'gsquire.log'), Logger.const_get(options[:log].to_s.upcase)]
+            when String
+              [options[:log], Logger::INFO]
+            end
+          log = Logger.new file
+          log.progname = 'GSquire'
+          log.formatter = Logger::Formatter.new
+          log.formatter.datetime_format = "%Y-%m-%d %H:%M:%S "
+          log.level = level
+          log
+        else
+          DummyLogger.new
+        end
+      end
+    end
+  end
+end

data/lib/gsquire/client.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+require 'json'
+require 'uri'
+
+module GSquire
+  # Very simple Google Tasks API wrapper. It won't perform authentication.
+  # Instead, it requires an already authenticated and authorized
+  # OAuth2::AccessToken token.
+  class Client
+    GOOGLE_TASKS_API = URI.parse 'https://www.googleapis.com/tasks/v1'
+
+    attr_accessor :oauth_token
+
+    def initialize(token)
+      @oauth_token = token
+    end
+
+    # Pulls all task lists for authorized user
+    # @return [Array] Array of task list hashes
+    def tasklists
+      get gtasks_tasklists_url
+    end
+
+    # Pulls a task list
+    # @param [String] tasklist_id ('@default') Task list ID
+    # @return [Hash] task list
+    def tasklist(tasklist_id = '@default')
+      get gtasks_tasklist_url(tasklist_id)
+    end
+
+    def create_tasklist(tasklist)
+      post gtasks_tasklists_url, strip(:tasklist, :create, tasklist)
+    end
+
+    def update_tasklist(tasklist)
+      put gtasks_tasklist_url(tasklist[:id]), strip(:tasklist, :update, tasklist)
+    end
+
+    def delete_tasklist(tasklist_id)
+      delete gtasks_tasklist_url(tasklist_id)
+    end
+
+    # Pulls all tasks of a task list
+    # @param [String] tasklist_id ('@default') Task list ID
+    # @return [Array] Array of task hashes
+    def tasks(tasklist_id = '@default')
+      get gtasks_tasks_url(tasklist_id)
+    end
+
+    # Pulls a task of a task list
+    # @param [String] task_id Task ID
+    # @param [String] tasklist_id ('@default') Task list ID
+    # @return [Hash] Task hash
+    def task(task_id, tasklist_id = '@default')
+      get gtasks_task_url(task_id, tasklist_id)
+    end
+
+    def create_task(task, tasklist_id = '@default')
+      post gtasks_tasks_url(tasklist_id), strip(:task, :create, task)
+    end
+
+    protected
+
+    def get(url)
+      _ oauth_token.get(url)
+    end
+
+    def post(url, content)
+      _ oauth_token.post(url, body: content.to_json, headers: {'Content-Type' => 'application/json'})
+    end
+
+    def put(url, content)
+      _ oauth_token.put(url, body: content.to_json, headers: {'Content-Type' => 'application/json'})
+    end
+
+    def delete(url)
+      oauth_token.delete(url) and true
+    end
+
+    def gtasks_tasklists_url
+      gtasks_urls(:tasklists, '@me')
+    end
+
+    def gtasks_tasklist_url(tasklist_id = '@default')
+      gtasks_urls(:tasklist, '@me', tasklist_id)
+    end
+
+    def gtasks_tasks_url(tasklist_id = '@default')
+      gtasks_urls(:tasks, tasklist_id)
+    end
+
+    def gtasks_task_url(task_id, tasklist_id = '@default')
+      gtasks_urls(:task, tasklist_id, task_id)
+    end
+
+    def gtasks_urls(resource, *params)
+      segments = case resource
+        when :tasklists
+          "/users/$/lists"
+        when :tasklist
+          "/users/$/lists/$"
+        when :tasks
+          "/lists/$/tasks"
+        when :task
+          "/lists/$/tasks/$"
+      end.split('/')
+      subpath = segments.map {|seg| seg == '$' ? params.shift : seg }.join('/')
+      GOOGLE_TASKS_API.merge(GOOGLE_TASKS_API.path + subpath)
+    end
+
+    def strip(entity, method, data)
+      meta = %w(id kind selfLink)
+      valid = case entity
+        when :tasklist
+          %w(title)
+        when :task
+          %w(title notes due status parent previous)
+        end
+      valid += meta if method == :update
+      data.select {|k, *| valid.include? k.to_s }
+    end
+
+    def _(result)
+      result.response.env[:tasks_api_result]
+    end
+  end
+end

data/lib/gsquire/logging.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module GSquire
+  # Fake logger, does nothing when its methods are called
+  class DummyLogger
+    FAKE_METHODS = %w[<< add log debug error fatal info unknown warn]
+
+    FAKE_METHODS.each do |method|
+      define_method(method) {|*| }
+    end
+  end
+end

data/lib/gsquire/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module GSquire
+  VERSION = "0.0.3"
+end

data/lib/gsquire.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require 'gsquire/version'
+require 'gsquire/application'

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: gsquire
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Kiyoshi '13k' Murata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: &16757400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *16757400
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &16756920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *16756920
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: &16756460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *16756460
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &16756080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16756080
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: &16755620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16755620
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &16755200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16755200
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: &16754780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16754780
+description: ! "Back in the Age of Heroes, GSquire would carry thy armor\n    and
+  sword, would get thy lordship dressed and accompany in battle. He would\n    fight
+  side by side with those who stood brave against the toughest of the\n    foes. These
+  were good times to be alive.\n\n    Then a swift, strange, wind blew upon this land
+  and everything we knew was\n    washed away and replaced by something new. All we
+  used to know about\n    living, eating, singing and smiling was made anew. Not everyone
+  could\n    handle that, many were forced into this. Those who were born during this\n
+  \   time, never knew how was the world before.\n\n    Some received this wind as
+  a blessing from gods, others deemed it cursed.\n    The only agreement was in calling
+  it Web 2.0."
+email:
+- 13k@linhareta.net
+executables:
+- gsquire
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- README.md
+- Rakefile
+- bin/gsquire
+- gsquire.gemspec
+- lib/gsquire.rb
+- lib/gsquire/accounts.rb
+- lib/gsquire/accounts/tasks_api_middleware.rb
+- lib/gsquire/accounts/tokens.rb
+- lib/gsquire/application.rb
+- lib/gsquire/client.rb
+- lib/gsquire/logging.rb
+- lib/gsquire/version.rb
+homepage: http://commita.com/community
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A commandline and library squire to look for thy lordly Google Tasks.
+test_files: []
+has_rdoc: