hcl 0.4.9 → 0.4.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ea82cda49c0d4f4aa43038029ae70b5e22b9e18
-  data.tar.gz: 3bf6719883563294afd3545ce02213abe468e7a5
+  metadata.gz: 0e94f259c4106d6c9fd541aea356ad7bcc14c8b9
+  data.tar.gz: 6c62d7d40bd19500585b8bfd8f2c1ef70a6861c7
 SHA512:
-  metadata.gz: f0994f4ee68ce6b5adabb2de5cec31a8db29091fc02eba53929461015e639b152805ba5b42707c693a1bcf1efb200e0918f07c3b6e4522e33beb46187cda9aa8
-  data.tar.gz: 1749a65a4eaaaa8c580573e5dab944ae026fb057bdaa33a3ae225569f1033d9cccada2c5efd77a7c0d1e5785d38fb154ef23d8943e70db48728c3ef0ad54b41f
+  metadata.gz: 1fbad2e2f47d19d6c4bed45cfc0ee74be7abbdfbaca0289891ed5bcc04a5ac55b51f2ea612575fc43b9006cb494303d21ac29252b427073b5b9a7470cd4c40b7
+  data.tar.gz: 0f98b72e9ec279307e13ee2edf6093725ea1ebd8d788201dab4f17bc00df3ff9da97a2a1ab9fff8909b9ecae287ee9ea1125cdf087b935028efa4df7247d2782

data/CHANGELOG

@@ -1,5 +1,10 @@
 = Recent Changes in HCl
 
+== next version
+
+* added `config` command to display current credentials
+* added `console` command for exploring the Harvest API
+
 == v0.4.9 2013-12-21
 
 * MacOS X: store password in default keychain

data/Gemfile

@@ -1,5 +1,6 @@
 source "https://rubygems.org"
 gemspec
+gem 'pry', group:['test','development']
 # XXX this is dumb but it's crazy hard to get platform specfic deps into a gemspec
 gem 'rubysl-abbrev', platform:'rbx'
 gem 'rubysl-singleton', platform:'rbx'

data/README.markdown

@@ -3,11 +3,14 @@
 HCl is a command-line tool for interacting with Harvest time sheets using the
 [Harvest time tracking API][htt].
 
-[htt]: http://www.getharvest.com/api/time_tracking
+[View this documentation online][rdoc].
 
 [![Build Status](https://travis-ci.org/zenhob/hcl.png?branch=master)](https://travis-ci.org/zenhob/hcl)
 [![Gem Version](https://badge.fury.io/rb/hcl.png)](http://badge.fury.io/rb/hcl)
 
+[htt]: http://www.getharvest.com/api/time_tracking
+[rdoc]: http://rdoc.info/github/zenhob/hcl/file/README.markdown
+
 ## Quick Start
 
 You can install hcl directly from rubygems.org:
@@ -30,6 +33,7 @@ or you can install from source:
     hcl alias <task_alias> <project_id> <task_id>
     hcl aliases
     hcl (cancel | nvm | oops)
+    hcl config
 
 ### Available Projects and Tasks
 
@@ -117,16 +121,42 @@ configuration:
 
 ### Configuration Profiles
 
-You can specify an alternate configuration directory in the environment as
-`HCL_DIR`. This can be used to easily interact with multiple harvest accounts.
+You can modify your credentials with the `--reauth` option, and review them
+with `hcl config`. If you'd rather store multiple configurations at
+once, specify an alternate configuration directory in the environment as
+`HCL_DIR`. This can be used to interact with multiple harvest accounts at
+once.
+
 Here is a shell alias `myhcl` with a separate configuration from the
-main `hcl` command, including alias completion:
+main `hcl` command, and another command to configure alias completion:
 
     alias myhcl="env HCL_DIR=~/.myhcl hcl"
     eval `myhcl completion myhcl`
 
-When using `myhcl` you can use different credentials and aliases, while
-`hcl` will continue to function with your original configuration.
+Adding something like the above to your bashrc will enable a new command,
+`myhcl`. When using `myhcl` you can use different credentials and aliases,
+while `hcl` will continue to function with your original configuration.
+
+### Interactive Console
+
+An interactive Ruby console is provided to allow you to use the fairly
+powerful Harvest API client built into HCl, since not all of its
+features are exposed via the command line. The current {HCl::App}
+instance is available as `hcl`.
+
+It's also possible to issue HCl commands directly (except `alias`, see
+below), or to query specific JSON end points and have the results
+pretty-printed:
+
+    hcl console
+    hcl> show "yesterday"
+    # => prints yesterday's timesheet, note the quotes!
+    hcl> hcl.http.get('daily')
+    # => displays a pretty-printed version of the JSON output
+
+Note that the HCl internals may change without notice.
+Also, commands (like `alias`) that are also reserved words in Ruby
+can't be issued directly (use `send :alias` instead).
 
 ### Date Formats
 

data/lib/hcl.rb

@@ -1,10 +1,13 @@
 module HCl
   autoload :VERSION, 'hcl/version'
   autoload :App, 'hcl/app'
+  autoload :Net, 'hcl/net'
   autoload :Commands, 'hcl/commands'
+  autoload :Console, 'hcl/console'
   autoload :TimesheetResource, 'hcl/timesheet_resource'
   autoload :Utility, 'hcl/utility'
   autoload :Project, 'hcl/project'
   autoload :Task, 'hcl/task'
   autoload :DayEntry, 'hcl/day_entry'
+  autoload :HarvestMiddleware, 'hcl/harvest_middleware'
 end

data/lib/hcl/app.rb

@@ -9,11 +9,11 @@ module HCl
     include HCl::Utility
     include HCl::Commands
 
-    HCL_DIR = ENV['HCL_DIR'] || "#{ENV['HOME']}/.hcl"
-    SETTINGS_FILE = "#{HCL_DIR}/settings.yml"
-    CONFIG_FILE = "#{HCL_DIR}/config.yml"
-    OLD_SETTINGS_FILE = "#{ENV['HOME']}/.hcl_settings"
-    OLD_CONFIG_FILE = "#{ENV['HOME']}/.hcl_config"
+    HCL_DIR = (ENV['HCL_DIR'] || "#{ENV['HOME']}/.hcl").freeze
+    SETTINGS_FILE = "#{HCL_DIR}/settings.yml".freeze
+    CONFIG_FILE = "#{HCL_DIR}/config.yml".freeze
+
+    attr_reader :http
 
     def initialize
       FileUtils.mkdir_p(HCL_DIR)
@@ -64,15 +64,15 @@ module HCl
       rescue SocketError => e
         $stderr.puts "Connection failed. (#{e.message})"
         exit 1
-      rescue TimesheetResource::ThrottleFailure => e
+      rescue HarvestMiddleware::ThrottleFailure => e
         $stderr.puts "Too many requests, retrying in #{e.retry_after+5} seconds..."
         sleep e.retry_after+5
         run
-      rescue TimesheetResource::AuthFailure => e
+      rescue HarvestMiddleware::AuthFailure => e
         $stderr.puts "Unable to authenticate: #{e}"
         request_config
         run
-      rescue TimesheetResource::Failure => e
+      rescue HarvestMiddleware::Failure => e
         $stderr.puts "API failure: #{e}"
         exit 1
       end
@@ -142,11 +142,7 @@ EOM
         if has_security_command?
           load_password config
         end
-        TimesheetResource.configure config
-      elsif File.exists? OLD_CONFIG_FILE
-        config = YAML::load File.read(OLD_CONFIG_FILE)
-        TimesheetResource.configure config
-        write_config config
+        @http = HCl::Net.new config
       else
         request_config
       end
@@ -158,8 +154,8 @@ EOM
       config['login'] = ask("Email Address: ").to_s
       config['password'] = ask("Password: ") { |q| q.echo = false }.to_s
       config['subdomain'] = ask("Subdomain: ").to_s
-      config['ssl'] = %w(y yes).include?(ask("Use SSL? (y/n): ").downcase)
-      TimesheetResource.configure config
+      config['ssl'] = /^y/.match(ask("Use SSL? (y/n): ").downcase)
+      @http = HCl::Net.new config
       write_config config
     end
 
@@ -177,9 +173,6 @@ EOM
     def read_settings
       if File.exists? SETTINGS_FILE
         @settings = YAML.load(File.read(SETTINGS_FILE))
-      elsif File.exists? OLD_SETTINGS_FILE
-        @settings = YAML.load(File.read(OLD_SETTINGS_FILE))
-        write_settings
       else
         @settings = {}
       end

data/lib/hcl/commands.rb

@@ -5,10 +5,20 @@ module HCl
   module Commands
     class Error < StandardError; end
 
+    # Display a sanitized view of your auth credentials.
+    def config
+      http.config_hash.merge(password:'***').map {|k,v| "#{k}: #{v}" }.join("\n")
+    end
+
+    def console
+      Console.new(self)
+      nil
+    end
+
     def tasks project_code=nil
       tasks = Task.all
       if tasks.empty? # cache tasks
-        DayEntry.all
+        DayEntry.today
         tasks = Task.all
       end
       tasks.select! {|t| t.project.code == project_code } if project_code
@@ -33,9 +43,9 @@ module HCl
     end
 
     def cancel
-      entry = DayEntry.with_timer || DayEntry.last
+      entry = DayEntry.with_timer(http) || DayEntry.last(http)
       if entry
-        if entry.cancel
+        if entry.cancel http
           "Deleted entry #{entry}."
         else
           fail "Failed to delete #{entry}!"
@@ -67,7 +77,8 @@ module HCl
       end
     end
 
-    def completion command=$PROGRAM_NAME
+    def completion command=nil
+      command ||= $PROGRAM_NAME.split('/').last
       %[complete -W "#{aliases.join ' '}" #{command}]
     end
 
@@ -81,23 +92,23 @@ module HCl
       if task.nil?
         fail "Unknown task alias, try one of the following: ", aliases.join(', ')
       end
-      timer = task.start \
+      timer = task.start http,
         :starting_time => starting_time,
         :note => args.join(' ')
       "Started timer for #{timer} (at #{current_time})"
     end
 
     def log *args
-      fail "There is already a timer running." if DayEntry.with_timer
+      fail "There is already a timer running." if DayEntry.with_timer(http)
       start *args
       stop
     end
 
     def stop *args
-      entry = DayEntry.with_timer || DayEntry.with_timer(DateTime.yesterday)
+      entry = DayEntry.with_timer(http) || DayEntry.with_timer(http, DateTime.yesterday)
       if entry
-        entry.append_note(args.join(' ')) if args.any?
-        entry.toggle
+        entry.append_note(http, args.join(' ')) if args.any?
+        entry.toggle http
         "Stopped #{entry} (at #{current_time})"
       else
         fail "No running timers found."
@@ -105,12 +116,12 @@ module HCl
     end
 
     def note *args
-      entry = DayEntry.with_timer
+      entry = DayEntry.with_timer http
       if entry
         if args.empty?
           return entry.notes
         else
-          entry.append_note args.join(' ')
+          entry.append_note http, args.join(' ')
           "Added note to #{entry}."
         end
       else
@@ -122,7 +133,7 @@ module HCl
       date = args.empty? ? nil : Chronic.parse(args.join(' '))
       total_hours = 0.0
       result = ''
-      DayEntry.all(date).each do |day|
+      DayEntry.daily(http, date).each do |day|
         running = day.running? ? '(running) ' : ''
         columns = HighLine::SystemExtensions.terminal_size[0] rescue 80
         result << "\t#{day.formatted_hours}\t#{running}#{day.project}: #{day.notes.lines.to_a.last}\n"[0..columns-1]
@@ -136,12 +147,12 @@ module HCl
       ident = get_ident args
       entry = if ident
           task_ids = get_task_ids ident, args
-          DayEntry.last_by_task *task_ids
+          DayEntry.last_by_task http, *task_ids
         else
-          DayEntry.last
+          DayEntry.last(http)
         end
       if entry
-        entry.toggle
+        entry.toggle http
       else
         fail "No matching timer found."
       end

data/lib/hcl/console.rb

@@ -0,0 +1,22 @@
+require 'pp'
+require 'pry'
+
+module HCl
+  class Console
+    attr_reader :hcl
+    def initialize app
+      @hcl = app
+      prompt = $PROGRAM_NAME.split('/').last + "> "
+      columns = HighLine::SystemExtensions.terminal_size[0] rescue 80
+      binding.pry quiet: true,
+        prompt:[->(a,b,c){ prompt }],
+        print:->(io, *p){ PP.pp p, io, columns }
+    end
+
+    Commands.instance_methods.each do |command|
+      define_method command do |*args|
+        puts @hcl.send(command, *args)
+      end
+    end
+  end
+end

data/lib/hcl/day_entry.rb

@@ -1,15 +1,11 @@
-require 'rexml/document'
-
 module HCl 
   class DayEntry < TimesheetResource
     include Utility
 
-    # Get the time sheet entries for a given day. If no date is provided
-    # defaults to today.
-    def self.all date = nil
-      url = date.nil? ? 'daily' : "daily/#{date.strftime '%j/%Y'}"
-      from_xml get(url)
-    end
+    collection_name :day_entries
+    resources :today, 'daily', load_cb:->(data) { Task.cache_tasks_hash data }
+    resources(:daily) {|date| date ? "daily/#{date.strftime '%j/%Y'}" : 'daily' }
+    resource(:project_info, class_name:'Project') { "projects/#{project_id}" }
 
     def to_s
       "#{client} - #{project} - #{task} (#{formatted_hours})"
@@ -19,19 +15,10 @@ module HCl
       @data[:task]
     end
 
-    def self.from_xml xml
-      doc = REXML::Document.new xml
-      raise Failure, "No root node in XML document: #{xml}" if doc.root.nil?
-      Task.cache_tasks doc
-      doc.root.elements.collect('//day_entry') do |day|
-        new xml_to_hash(day)
-      end
-    end
-
-    def cancel
+    def cancel http
       begin
-        DayEntry.delete("daily/delete/#{id}")
-      rescue TimesheetResource::Failure
+        http.delete("daily/delete/#{id}")
+      rescue HarvestMiddleware::Failure
         return false
       end
       true
@@ -42,38 +29,32 @@ module HCl
     end
 
     # Append a string to the notes for this task.
-    def append_note new_notes
+    def append_note http, new_notes
       # If I don't include hours it gets reset.
       # This doens't appear to be the case for task and project.
       (self.notes << "\n#{new_notes}").lstrip!
-      DayEntry.post "daily/update/#{id}",
-        %{<request><notes>#{notes}</notes><hours>#{hours}</hours></request>}
+      http.post "daily/update/#{id}", notes:notes, hours:hours
     end
 
-    def self.with_timer date=nil
-      all(date).detect {|t| t.running? }
+    def self.with_timer http, date=nil
+      daily(http, date).detect {|t| t.running? }
     end
 
-    def self.last_by_task project_id, task_id
-      all.sort {|a,b| b.updated_at<=>a.updated_at}.
+    def self.last_by_task http, project_id, task_id
+      today(http).sort {|a,b| b.updated_at<=>a.updated_at}.
         detect {|t| t.project_id == project_id && t.task_id == task_id }
     end
 
-    def self.last
-      all.sort {|a,b| a.updated_at<=>b.updated_at}[-1]
+    def self.last http
+      today(http).sort {|a,b| a.updated_at<=>b.updated_at}[-1]
     end
 
     def running?
       !@data[:timer_started_at].nil? && !@data[:timer_started_at].empty?
     end
 
-    def initialize *args
-      super
-      # TODO cache client/project names and ids
-    end
-
-    def toggle
-      DayEntry.get("daily/timer/#{id}")
+    def toggle http
+      http.get("daily/timer/#{id}")
       self
     end
 

data/lib/hcl/harvest_middleware.rb

@@ -0,0 +1,58 @@
+require 'faraday'
+
+class HCl::HarvestMiddleware < Faraday::Request::BasicAuthentication
+  Faraday.register_middleware harvest: ->{ self }
+  MIME_TYPE = 'application/json'.freeze
+
+  dependency do
+    require 'yajl'
+    require 'escape_utils'
+  end
+
+  def call(env)
+    # encode with and accept json
+    env[:request_headers]['Accept'] = MIME_TYPE
+    env[:request_headers]['Content-Type'] = MIME_TYPE
+    env[:body] = Yajl::Encoder.encode(env[:body])
+
+    # response processing
+    super(env).on_complete do |env|
+      case env[:status]
+      when 200..299
+        begin 
+          env[:body] = deep_html_unescape(Yajl::Parser.parse(env[:body], symbolize_keys:true))
+        rescue Yajl::ParseError
+          env[:body]
+        end
+      when 300..399
+        raise Failure, "Redirected! Perhaps your ssl configuration variable is set incorrectly?"
+      when 400..499
+        raise AuthFailure, "Login failed."
+      when 503
+       raise ThrottleFailure, env
+      else
+        raise Failure, "Unexpected response from the upstream API."
+      end
+    end
+  end
+
+  def deep_html_unescape obj
+    if obj.kind_of? Hash
+      obj.inject({}){|o,(k,v)| o.update(k => deep_html_unescape(v)) }
+    elsif obj.kind_of? Array
+      obj.inject([]){|o,v| o << deep_html_unescape(v) }
+    else
+      EscapeUtils.unescape_html(obj.to_s)
+    end
+  end
+
+  class Failure < StandardError; end
+  class AuthFailure < StandardError; end
+  class ThrottleFailure < StandardError
+    attr_reader :retry_after
+    def initialize env
+      @retry_after = env[:response_headers]['retry-after'].to_i
+      super "Too many requests! Try again in #{@retry_after} seconds."
+    end
+  end
+end

data/lib/hcl/net.rb

@@ -0,0 +1,39 @@
+require 'hcl/harvest_middleware'
+require 'faraday'
+
+module HCl
+  class Net
+    # configuration accessors
+    CONFIG_VARS = [ :login, :password, :subdomain, :ssl ].freeze.
+      each { |config_var| attr_reader config_var }
+
+    def config_hash
+      CONFIG_VARS.inject({}) {|c,k| c.update(k => send(k)) }
+    end
+
+    def initialize opts
+      @login = opts['login'].freeze
+      @password = opts['password'].freeze
+      @subdomain = opts['subdomain'].freeze
+      @ssl = !!opts['ssl']
+      @http = Faraday.new(
+        "http#{ssl ? 's' : '' }://#{subdomain}.harvestapp.com"
+      ) do |f|
+        f.use :harvest, login, password
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def get action
+      @http.get(action).body
+    end
+
+    def post action, data
+      @http.post(action, data).body
+    end
+
+    def delete action
+      @http.delete(action).body
+    end
+  end
+end

data/lib/hcl/project.rb

@@ -1,3 +1,4 @@
 class HCl::Project < HCl::TimesheetResource
+  collection_name :projects
 end
 

data/lib/hcl/task.rb

@@ -3,18 +3,13 @@ require 'fileutils'
 
 module HCl
   class Task < TimesheetResource
-    def self.cache_tasks doc
-      tasks = []
-      doc.root.elements.collect('projects/project') do |project_elem|
-        project = Project.new xml_to_hash(project_elem)
-        tasks.concat(project_elem.elements.collect('tasks/task') do |task|
-          new xml_to_hash(task).merge(:project => project)
-        end)
-      end
+    def self.cache_tasks_hash day_entry_hash
+      tasks = day_entry_hash[:projects].
+        map { |p| p[:tasks].map {|t| new t.merge(project:Project.new(p)) } }.flatten.uniq
       unless tasks.empty?
         FileUtils.mkdir_p(cache_dir)
         File.open(cache_file, 'w') do |f|
-          f.write tasks.uniq.to_yaml
+          f.write tasks.to_yaml
         end
       end
     end
@@ -52,27 +47,24 @@ module HCl
       end
     end
 
-    def add opts
+    def add http, opts
       notes = opts[:note]
       starting_time = opts[:starting_time] || 0
-      days = DayEntry.from_xml Task.post("daily/add", <<-EOT)
-      <request>
-        <notes>#{notes}</notes>
-        <hours>#{starting_time}</hours>
-        <project_id type="integer">#{project.id}</project_id>
-        <task_id type="integer">#{id}</task_id>
-        <spent_at type="date">#{Date.today}</spent_at>
-      </request>
-      EOT
-      days.first
+      DayEntry.new http.post("daily/add", {
+        notes: notes,
+        hours: starting_time,
+        project_id: project.id,
+        task_id: id,
+        spent_at: Date.today
+      })
     end
 
-    def start opts
-      day = add opts
+    def start http, opts
+      day = add http, opts
       if day.running?
         day
       else
-        DayEntry.from_xml(Task.get("daily/timer/#{day.id}")).first
+        DayEntry.new http.get("daily/timer/#{day.id}")
       end
     end
   end

data/lib/hcl/timesheet_resource.rb

@@ -1,84 +1,9 @@
-require 'net/http'
-require 'net/https'
-require 'cgi'
-
 module HCl
   class TimesheetResource
-    class Failure < StandardError; end
-    class AuthFailure < StandardError; end
-    class ThrottleFailure < StandardError
-      attr_reader :retry_after
-      def initialize response
-        @retry_after = response.headers['Retry-After'].to_i
-        super "Too many requests! Try again in #{@retry_after} seconds."
-      end
-    end
-
-    def self.configure opts = nil
-      if opts
-        self.login = opts['login']
-        self.password = opts['password']
-        self.subdomain = opts['subdomain']
-        self.ssl = opts['ssl']
-      end
-    end
-
-    # configuration accessors
-    %w[ login password subdomain ssl ].each do |config_var|
-      class_eval <<-EOC
-        def self.#{config_var}= arg
-          @@#{config_var} = arg
-        end
-        def self.#{config_var}
-          @@#{config_var}
-        end
-      EOC
-    end
-
     def initialize params
       @data = params
     end
 
-    def self.get action
-      http_do Net::HTTP::Get, action
-    end
-
-    def self.post action, data
-      http_do Net::HTTP::Post, action, data
-    end
-
-    def self.delete action
-      http_do Net::HTTP::Delete, action
-    end
-
-    def self.connect
-      Net::HTTP.new("#{subdomain}.harvestapp.com", (ssl ? 443 : 80)).tap do |https|
-        https.use_ssl = ssl
-        https.verify_mode = OpenSSL::SSL::VERIFY_NONE if ssl
-      end
-    end
-
-    def self.http_do method_class, action, data = nil
-      https = connect
-      request = method_class.new "/#{action}"
-      request.basic_auth login, password
-      request.content_type = 'application/xml'
-      request['Accept']    = 'application/xml'
-      response = https.request request, data
-      case response
-      when Net::HTTPSuccess
-        response.body
-      when Net::HTTPFound
-        raise Failure, "Redirected! Perhaps your ssl configuration variable is set incorrectly?"
-      when Net::HTTPServiceUnavailable
-        raise ThrottleFailure, response
-      when Net::HTTPUnauthorized
-        raise AuthFailure, "Login failed."
-      else
-        raise Failure, "Unexpected response from the upstream API."
-      end
-    end
-
     def id
       @data[:id]
     end
@@ -91,10 +16,52 @@ module HCl
       (@data && @data.key?(method.to_sym)) || super
     end
 
-    def self.xml_to_hash elem
-      elem.elements.map { |e| e.name }.inject({}) do |a, f|
-        a[f.to_sym] = CGI.unescape_html(elem.elements[f].text || '') if elem.elements[f]
-        a
+    class << self
+      def _prepare_resource name, *args, &url_cb
+        ((@resources ||= {})[name] = {}).tap do |res|
+          opt_or_cb = args.pop
+          res[:url_cb] = url_cb
+          res[:opts] = {}
+          case opt_or_cb
+          when String
+            res[:url_cb] = ->() { opt_or_cb }
+            res[:opts] = args.pop || {}
+          when Hash
+            res[:opts] = opt_or_cb
+            url = args.pop
+            res[:url_cb] = ->() { url } if url
+          end
+        end
+      end
+
+      def resources name, *args, &url_cb
+        res = _prepare_resource name, *args, &url_cb
+        cls = res[:opts][:class_name] ? HCl.const_get(res[:opts][:class_name]) : self
+        method = cls == self ? :define_singleton_method : :define_method
+        send(method, name) do |http, *args|
+          url = instance_exec *args, &res[:url_cb]
+          cb = res[:opts][:load_cb]
+          http.get(url).tap{|e| cb.call(e) if cb }[cls.collection_name].map{|e|new(e)}
+        end
+      end
+
+      def resource name, *args, &url_cb
+        res = _prepare_resource name, *args, &url_cb
+        cls = res[:opts][:class_name] ? HCl.const_get(res[:opts][:class_name]) : self
+        method = cls == self ? :define_singleton_method : :define_method
+        send(method, name) do |http, *args|
+          url = instance_exec *args, &res[:url_cb]
+          cb = res[:opts][:load_cb]
+          cls.new http.get(url).tap{|e| cb.call(e) if cb }[cls.underscore_name]
+        end
+      end
+
+      def underscore_name
+        @underscore_name ||= name.split('::').last.split(/(?=[A-Z])/).map(&:downcase).join('_').to_sym
+      end
+
+      def collection_name name=nil
+        name ? (@collection_name = name) : @collection_name
       end
     end
   end

data/lib/hcl/version.rb

@@ -1,3 +1,3 @@
 module HCl
-  VERSION = '0.4.9'
+  VERSION = '0.4.10'
 end

data/test/app_test.rb

@@ -2,6 +2,7 @@ require 'test_helper'
 class AppTest < HCl::TestCase
 
   def setup
+    super
     # touch config to avoid triggering manual config
     FileUtils.mkdir_p HCl::App::HCL_DIR
     FileUtils.touch File.join(HCl::App::HCL_DIR, "config.yml")
@@ -13,7 +14,7 @@ class AppTest < HCl::TestCase
   end
 
   def test_command_show
-    HCl::DayEntry.expects(:all).returns [HCl::DayEntry.new(
+    HCl::DayEntry.expects(:daily).returns [HCl::DayEntry.new(
       hours:'2.06', notes:'hi world', project:'App'
     )]
     HCl::App.command 'show'
@@ -23,7 +24,7 @@ class AppTest < HCl::TestCase
     app = HCl::App.new
     throttled = states('throttled').starts_as(false)
     app.expects(:show).
-      raises(HCl::TimesheetResource::ThrottleFailure, stub(headers:{'Retry-After' => 42})).
+      raises(HCl::HarvestMiddleware::ThrottleFailure, {response_headers:{'retry-after' => 42}}).
       then(throttled.is(true))
     app.expects(:sleep).with(47).when(throttled.is(true))
     app.expects(:show).when(throttled.is(true))
@@ -48,7 +49,7 @@ class AppTest < HCl::TestCase
   def test_configure_on_auth_failure
     app = HCl::App.new
     configured = states('configured').starts_as(false)
-    app.expects(:show).raises(HCl::TimesheetResource::AuthFailure).when(configured.is(false))
+    app.expects(:show).raises(HCl::HarvestMiddleware::AuthFailure).when(configured.is(false))
     app.expects(:ask).returns('xxx').times(4).when(configured.is(false))
     app.expects(:write_config).then(configured.is(true))
     app.expects(:show).when(configured.is(true))
@@ -58,7 +59,7 @@ class AppTest < HCl::TestCase
 
   def test_api_failure
     app = HCl::App.new
-    app.expects(:show).raises(HCl::TimesheetResource::Failure)
+    app.expects(:show).raises(HCl::HarvestMiddleware::Failure)
     app.expects(:exit).with(1)
     app.process_args('show').run
     assert_match /API failure/i, error_output

data/test/command_test.rb

@@ -4,6 +4,7 @@ class CommandTest < HCl::TestCase
   include HCl::Utility
 
   def setup
+    super
     @settings = {}
   end
 
@@ -34,7 +35,7 @@ class CommandTest < HCl::TestCase
   end
 
   def test_show
-    HCl::DayEntry.expects(:all).returns([HCl::DayEntry.new({
+    HCl::DayEntry.expects(:daily).returns([HCl::DayEntry.new({
       hours:'2.06',
       notes: 'hi world',
       project: 'App'
@@ -68,15 +69,15 @@ class CommandTest < HCl::TestCase
       project: HCl::Project.new(id:456, name:'App', client:'Bob', code:'b')
     )
     HCl::Task.expects(:find).with('456','123').returns(task)
-    task.expects(:start).with(starting_time:nil, note:'do stuff')
+    task.expects(:start).with(http, starting_time:nil, note:'do stuff')
     start *%w[ 456 123 do stuff ]
   end
 
   def test_stop
     entry = stub
-    HCl::DayEntry.expects(:with_timer).returns(entry)
-    entry.expects(:append_note).with('all done')
-    entry.expects(:toggle)
+    register_uri(:get, '/daily', {day_entries:[{id:123,notes:'',hours:1,client:nil,project:nil,timer_started_at:DateTime.now}]})
+    register_uri(:post, '/daily/update/123', {day_entry:{notes:'all done'}})
+    register_uri(:get, '/daily/timer/123')
     stop 'all done'
   end
 
@@ -90,22 +91,22 @@ class CommandTest < HCl::TestCase
   def test_resume_with_task_alias
     entry = stub
     expects(:get_task_ids).with('mytask',[]).returns(%w[ 456 789 ])
-    HCl::DayEntry.expects(:last_by_task).with('456', '789').returns(entry)
-    entry.expects(:toggle)
+    HCl::DayEntry.expects(:last_by_task).with(http, '456', '789').returns(entry)
+    entry.expects(:toggle).with(http)
     resume 'mytask'
   end
 
   def test_cancel
     entry = stub
-    HCl::DayEntry.expects(:with_timer).returns(entry)
-    entry.expects(:cancel).returns(true)
+    HCl::DayEntry.expects(:with_timer).with(http).returns(entry)
+    entry.expects(:cancel).with(http).returns(true)
     cancel
   end
 
   def test_note
     entry = stub
     HCl::DayEntry.expects(:with_timer).returns(entry)
-    entry.expects(:append_note).with('hi world')
+    entry.expects(:append_note).with(http, 'hi world')
     note 'hi world'
   end
 

data/test/day_entry_test.rb

@@ -1,49 +1,62 @@
 require 'test_helper'
 
 class DayEntryTest < HCl::TestCase
-  def test_from_xml
-    entries = HCl::DayEntry.from_xml(<<-EOD)
-<daily>
-  <for_day type="date">Wed, 18 Oct 2006</for_day>
-  <day_entries>
-    <day_entry>
-      <id type="integer">195168</id>
-      <client>Iridesco</client>
-      <project>Harvest</project>
-      <task>Backend Programming</task>
-      <hours type="float">2.06</hours>
-      <notes>Test api support</notes>
-      <timer_started_at type="datetime">
-        Wed, 18 Oct 2006 09:53:06 -0000
-      </timer_started_at>
-      <created_at type="datetime">Wed, 18 Oct 2006 09:53:06 -0000</created_at>
-    </day_entry>
-  </day_entries>
-</daily>
-    EOD
-    assert_equal 1, entries.size
-    {
-      :project => 'Harvest',
-      :client => 'Iridesco',
-      :task => 'Backend Programming',
-      :notes => 'Test api support',
-      :hours => '2.06',
-    }.each do |method, value|
-      assert_equal value, entries.first.send(method)
-    end
+  def test_project_info
+    register_uri(:get, '/daily', {projects:[], day_entries:[{project_id:123}]})
+    register_uri(:get, '/projects/123', {project:{name:'fun times'}})
+    assert_equal 'fun times', HCl::DayEntry.today(http).first.project_info(http).name
+  end
+
+  def test_all_today_empty
+    register_uri(:get, '/daily', {projects:[],day_entries:[]})
+    assert HCl::DayEntry.today(http).empty?
+  end
+
+  def test_all_today
+    register_uri(:get, '/daily', {projects:[], day_entries:[{id:1,note:'hi'}]})
+    assert_equal 'hi', HCl::DayEntry.today(http).first.note
+  end
+
+  def test_all_with_date
+    register_uri(:get, '/daily/013/2013', {projects:[], day_entries:[{id:1,note:'hi'}]})
+    assert_equal 'hi', HCl::DayEntry.daily(http,Date.civil(2013,1,13)).first.note
+  end
+
+  def test_toggle
+    entry = HCl::DayEntry.new(id:123)
+    register_uri(:get, '/daily/timer/123', {note:'hi'})
+    entry.toggle http
+  end
+
+  def test_cancel_success
+    entry = HCl::DayEntry.new(id:123)
+    register_uri(:delete, '/daily/delete/123')
+    assert entry.cancel http
+  end
+
+  def test_cancel_failure
+    entry = HCl::DayEntry.new(id:123)
+    http.expects(:delete).raises(HCl::HarvestMiddleware::Failure)
+    assert !entry.cancel(http)
+  end
+
+  def test_to_s
+    entry = HCl::DayEntry.new \
+      hours: '1.2', client: 'Taco Town', project:'Pizza Taco', task:'Preparation'
+    assert_equal "Taco Town - Pizza Taco - Preparation (1:12)", entry.to_s
   end
 
   def test_append_note
     entry = HCl::DayEntry.new(:id => '1', :notes => 'yourmom.', :hours => '1.0')
-    HCl::DayEntry.stubs(:post)
-    entry.append_note('hi world')
+    http.stubs(:post)
+    entry.append_note(http, 'hi world')
     assert_equal "yourmom.\nhi world", entry.notes
   end
 
   def test_append_note_to_empty
     entry = HCl::DayEntry.new(:id => '1', :notes => nil, :hours => '1.0')
-    HCl::DayEntry.stubs(:post)
-    entry.append_note('hi world')
+    http.stubs(:post)
+    entry.append_note(http, 'hi world')
     assert_equal 'hi world', entry.notes
   end
 end

data/test/ext/capture_output.rb

@@ -1,8 +1,10 @@
 module CaptureOutput
   def before_setup
     super
-    $stderr = @stderr = StringIO.new
-    $stdout = @stdout = StringIO.new
+    @stderr = StringIO.new
+    @stdout = StringIO.new
+    $stderr = @stderr
+    $stdout = @stdout
   end
   def after_teardown
     super

data/test/net_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class NetTest < HCl::TestCase
+
+  def test_configure
+    assert_equal 'bob', http.login
+    assert_equal 'secret', http.password
+    assert_equal 'bobclock', http.subdomain
+    assert_equal true, http.ssl
+  end
+
+  def test_http_deep_unescape
+    register_uri(:get, "/foo", {
+      status:'gotten &amp; got!',
+      comparisons:['burrito &gt; taco', 'rain &lt; sun']
+    })
+    body = http.get 'foo'
+    assert_equal 'gotten & got!', body[:status]
+    assert_equal 'burrito > taco', body[:comparisons][0]
+    assert_equal 'rain < sun', body[:comparisons][1]
+  end
+
+  def test_http_get
+    register_uri(:get, "/foo", {message:'gotten!'})
+    body = http.get 'foo'
+    assert_equal 'gotten!', body[:message]
+  end
+
+  def test_http_post
+    register_uri(:post, "/foo", {message:'posted!'})
+    body = http.post 'foo', {pizza:'taco'}
+    assert_equal 'posted!', body[:message]
+  end
+
+  def test_http_delete
+    register_uri(:delete, "/foo", {message:'wiped!'})
+    body = http.delete 'foo'
+    assert_equal 'wiped!', body[:message]
+  end
+end

data/test/task_test.rb

@@ -1,30 +1,47 @@
 
-class Task < HCl::TestCase
+class TaskTest < HCl::TestCase
   def test_cache_file
     assert_equal "#{HCl::App::HCL_DIR}/cache/tasks.yml", HCl::Task.cache_file
   end
 
-  def test_cache_tasks
-    HCl::Task.cache_tasks(REXML::Document.new(<<-EOD))
-<daily>
-  <projects>
-    <project>
-      <name>Click and Type</name>
-      <code></code>
-      <id type="integer">3</id>
-      <client>AFS</client>
-      <tasks>
-        <task>
-          <name>Security support</name>
-          <id type="integer">14</id>
-          <billable type="boolean">true</billable>
-        </task>
-      </tasks>
-    </project>
-  </projects>
-</daily>
-    EOD
+  def test_cache_tasks_hash
+    HCl::Task.cache_tasks_hash({ projects: [{
+      name: "Click and Type",
+      id: 3,
+      client: "AFS",
+      tasks: [{
+        name: "Security support",
+        id: 14,
+        billable: true
+      }]
+    }]})
     assert_equal 1, HCl::Task.all.size
     assert_equal 'Security support', HCl::Task.all.first.name
   end
+
+  def test_add
+    task = HCl::Task.new(id:1, project:HCl::Project.new({id:2}))
+    register_uri(:post, '/daily/add', {
+      note:'good stuff', hours:0.2, project_id:2, task_id:1, spent_at: Date.today})
+    entry = task.add(http, note:'good stuff', starting_time:0.2)
+    assert_equal 'good stuff', entry.note
+  end
+
+  def test_start_running
+    task = HCl::Task.new(id:1, project:HCl::Project.new({id:2}))
+    register_uri(:post, '/daily/add', {
+      note:'good stuff', timer_started_at:DateTime.now,
+      hours:0.2, project_id:2, task_id:1, spent_at: Date.today})
+    entry = task.start(http, note:'good stuff', starting_time:0.2)
+    assert_equal 'good stuff', entry.note
+  end
+
+  def test_start_then_toggle
+    task = HCl::Task.new(id:1, project:HCl::Project.new({id:2}))
+    register_uri(:post, '/daily/add', {id:123, note:'woot'})
+    register_uri(:get, '/daily/timer/123', {note:'good stuff', hours:0.2,
+                                            project_id:2, task_id:1, spent_at: Date.today})
+    entry = task.start(http, note:'good stuff', starting_time:0.2)
+    assert_equal 'good stuff', entry.note
+  end
 end

data/test/test_helper.rb

@@ -9,11 +9,7 @@ begin
       source_file.lines.count < 15
     end
     # source: https://travis-ci.org/zenhob/hcl
-    minimum_coverage case RUBY_ENGINE
-      when "rbx" then 84
-      when "jruby" then 73
-      else 78
-    end
+    minimum_coverage 84
   end
 rescue LoadError => e
   $stderr.puts 'No test coverage tools found, skipping coverage check.'
@@ -31,5 +27,25 @@ require 'fakeweb'
 # require test extensions/helpers
 Dir[File.dirname(__FILE__) + '/ext/*.rb'].each { |ext| require ext }
 
-class HCl::TestCase < MiniTest::Unit::TestCase; end
+class HCl::TestCase < MiniTest::Unit::TestCase
+  attr_reader :http
+  def setup
+    FakeWeb.allow_net_connect = false
+    @http = HCl::Net.new \
+      'login' => 'bob',
+      'password' => 'secret',
+      'subdomain' => 'bobclock',
+      'ssl' => true
+  end
+
+  def register_uri method, path, data={}
+    FakeWeb.register_uri(method, "https://bob:secret@bobclock.harvestapp.com#{path}",
+                         body: Yajl::Encoder.encode(data))
+  end
+
+  def teardown
+    FakeWeb.clean_registry
+  end
+end
+
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hcl
 version: !ruby/object:Gem::Version
-  version: 0.4.9
+  version: 0.4.10
 platform: ruby
 authors:
 - Zack Hobson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-22 00:00:00.000000000 Z
+date: 2014-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
@@ -52,6 +52,62 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: escape_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -166,7 +222,10 @@ files:
 - bin/hcl
 - lib/hcl/app.rb
 - lib/hcl/commands.rb
+- lib/hcl/console.rb
 - lib/hcl/day_entry.rb
+- lib/hcl/harvest_middleware.rb
+- lib/hcl/net.rb
 - lib/hcl/project.rb
 - lib/hcl/task.rb
 - lib/hcl/timesheet_resource.rb
@@ -177,9 +236,9 @@ files:
 - test/command_test.rb
 - test/day_entry_test.rb
 - test/ext/capture_output.rb
+- test/net_test.rb
 - test/task_test.rb
 - test/test_helper.rb
-- test/timesheet_resource_test.rb
 - test/utility_test.rb
 homepage: http://zackhobson.com/hcl/
 licenses:

data/test/timesheet_resource_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-class TimesheetResourceTest < HCl::TestCase
-
-  def setup
-    FakeWeb.allow_net_connect = false
-    HCl::TimesheetResource.configure \
-      'login' => 'bob',
-      'password' => 'secret',
-      'subdomain' => 'bobclock',
-      'ssl' => true
-  end
-
-  def test_configure
-    assert_equal 'bob', HCl::TimesheetResource.login
-    assert_equal 'secret', HCl::TimesheetResource.password
-    assert_equal 'bobclock', HCl::TimesheetResource.subdomain
-    assert_equal true, HCl::TimesheetResource.ssl
-  end
-
-  def test_http_get
-    FakeWeb.register_uri(:get, "https://bob:secret@bobclock.harvestapp.com/foo", :body => 'gotten!')
-    body = HCl::TimesheetResource.get 'foo'
-    assert_equal 'gotten!', body
-  end
-
-  def test_http_post
-    FakeWeb.register_uri(:post, "https://bob:secret@bobclock.harvestapp.com/foo", :body => 'posted!')
-    body = HCl::TimesheetResource.post 'foo', {pizza:'taco'}
-    assert_equal 'posted!', body
-  end
-
-  def test_http_delete
-    FakeWeb.register_uri(:delete, "https://bob:secret@bobclock.harvestapp.com/foo", :body => 'wiped!')
-    body = HCl::TimesheetResource.delete 'foo'
-    assert_equal 'wiped!', body
-  end
-end