rtasklib 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6594a20f1c965ccf953918bf9fb7eba89832dc70
-  data.tar.gz: 6c889440f54c76d7eac9f46e62ad1d7300e44399
+  metadata.gz: 6dd45dd292c87269556e732b902f18cf38a098eb
+  data.tar.gz: a8adeee47b89eb6cadc2a5cf79e4825711f4e181
 SHA512:
-  metadata.gz: 23c9ecccf416dcf6e94835258096ec96dc5257d9ee1109a31014c11100bfd329b11b02ca42a59d2c72c095b6f360b21ddbdc5db1726cdf0c21dc61a6fb127b5b
-  data.tar.gz: b9962b934cca761f7a8e3c7ad623d76238a1b10722e0e1eb876c75d06640cf5b326e9339f31da34cfe73c12669f7b322d7e1f2652eef35afaf0c1782380aa670
+  metadata.gz: f2ad056508be0fabd7365c5431abe144220283ea6ba7beb77718d807f1549307876f1cde5708342339a50b3c4e6fa9b0ce4d9781b52c670020d55397850d5678
+  data.tar.gz: 8afd466375b305d8ed56fe5e98b66328391063c864db40637a02ecb9f65b58bfc4b6f49542977a739a7f44ccd394744deb9e0d5a7fe7bd2e3ff7b028eb2459c1

data/.gitignore

@@ -6,7 +6,6 @@
 /pkg/
 /doc/
 /spec/reports/
+/spec/data/
 /tmp/
 *.py
-lib/rtasklib/marshallable.rb
-spec/marshallable_spec.rb

data/.travis.yml

@@ -25,6 +25,8 @@ before_install:
     - export TASKRC=/home/travis/build/dropofwill/rtasklib/spec/data/.taskrc
     - export TASKDATA=/home/travis/build/dropofwill/rtasklib/spec/data/.task
     - task _version
+    - task export
+    - task add "Test task persistence"
 
 script: 'bundle exec rake'
 

data/README.md

@@ -36,7 +36,18 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```
+require 'rtasklib'
+
+tw = Rtasklib::TW.new('../path/to/.task')
+
+# do some stuff with the task database
+# available commands are documented in the Controller class
+
+tw.all
+```
+
+[Controller docs](http://will-paul.com/rtasklib/Rtasklib/Controller.html)
 
 
 ## Development

data/Rakefile

@@ -1,5 +1,7 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "open3"
+require "pp"
 
 # run tests with `rake spec`
 RSpec::Core::RakeTask.new :spec do |task|
@@ -10,9 +12,12 @@ task default: :spec
 
 desc "Update and publish docs to gh-pages"
 task :docs do |task|
-  `yard docs`
-  `ghp-import -p doc`
-end
+  o, s = Open3.capture2("yard doc")
+  o.split("\n").each { |line| p line }
+  p ""
 
-task :build_rpm do
+  Open3.capture2("ghp-import -p doc")
 end
+
+# task :build_rpm do
+# end

data/lib/rtasklib.rb

@@ -2,15 +2,15 @@ require_relative "rtasklib/version"
 require_relative "rtasklib/models"
 require_relative "rtasklib/execute"
 require_relative "rtasklib/controller"
+require_relative "rtasklib/helpers"
 require_relative "rtasklib/taskrc"
 
-require "open3"
 require "pathname"
 
 module Rtasklib
 
   class TaskWarrior
-    attr_reader :version, :data_location, :taskrc,
+    attr_reader :version, :data_location, :taskrc, :udas,
                 :override, :override_a, :override_str
 
     include Controller
@@ -25,22 +25,24 @@ module Rtasklib
     LOWEST_VERSION = Gem::Version.new('2.4.0')
 
     def initialize data="#{Dir.home}/.task", opts = {}
+      # Check TaskWarrior version, and throw warning if unavailable
+      begin
+        @version = check_version
+      rescue
+        warn "Couldn't verify TaskWarrior's version"
+      end
 
       @data_location = data
       override_h     = DEFAULTS.merge({data_location: data}).merge(opts)
       @override      = Taskrc.new(override_h, :hash)
       @override_a    = override.model_to_rc
       @taskrc        = get_rc
-
-      # Check TaskWarrior version, and throw warning if unavailable
-      begin
-        @version = check_version(get_version())
-      rescue
-        warn "Couldn't verify TaskWarrior's version"
-      end
+      @udas          = get_udas
+      add_udas_to_model!(udas) unless udas.nil?
     end
 
-    def check_version version
+    def check_version version=nil
+      version = get_version if version.nil?
       if version < LOWEST_VERSION
         warn "The current TaskWarrior version, #{version}, is untested"
       end

data/lib/rtasklib/controller.rb

@@ -3,6 +3,15 @@ require "oj"
 
 module Rtasklib
 
+  # Accessed through the main TW, which includes this module, e.g. `tw.all`
+  #
+  # Ideally should only be the well documented public, user-facing methods.
+  # We're getting there.
+  #
+  # By convention bang methods modify the task database, and non-bang read
+  # from the database, e.g. `Controller#all` vs `Controller#modify!`
+  #
+  # XXX: depends on @override_a currently, which isn't great.
   module Controller
     extend self
 
@@ -12,65 +21,115 @@ module Rtasklib
     # @api public
     def all
       all = []
-      Execute.task_popen3(*@override_a, "export") do |i, o, e, t|
+      Execute.task_popen3(*override_a, "export") do |i, o, e, t|
         all = MultiJson.load(o.read).map do |x|
           Rtasklib::Models::TaskModel.new(x)
         end
       end
-      all
+      return all
     end
 
-    def filter ids: nil, tags: nil, query: nil
+    # Retrieves the current task list filtered by id, tag, or a dom query
+    #
+    # @example filter by an array of ids
+    #   tw.some(ids: [1..2, 5])
+    # @example filter by tags
+    #   tw.some(tags: ["+school", "or", "-work"]
+    #
+    # @param ids [Array<Range, Fixnum, String>, String, Range, Fixnum]
+    # @param tags [Array<String>, String]
+    # @param dom [Array<String>, String]
+    # @return [Array<Models::TaskModel>]
+    # @api public
+    def some ids: nil, tags: nil, dom: nil
+      some = []
+      filter_s = Helpers.filter(ids: ids, tags: tags, dom: dom)
+      Execute.task_popen3(*@override_a, filter_s, "export") do |i, o, e, t|
+        some = MultiJson.load(o.read).map do |x|
+          Rtasklib::Models::TaskModel.new(x)
+        end
+      end
+      return some
     end
 
-    def add!
+    # 
+    #
+    # @param ids [Array<Range, Fixnum, String>, String, Range, Fixnum]
+    # @param tags [Array<String>, String]
+    # @param dom [Array<String>, String]
+    # @api public
+    def add! description
     end
 
-    # def modify! attr:, val:, ids: nil, tags: nil, query: nil
-    # end
+    #
+    #
+    # @param ids [Array<Range, Fixnum, String>, String, Range, Fixnum]
+    # @param tags [Array<String>, String]
+    # @param dom [Array<String>, String]
+    # @api public
+    def modify! attr:, val:, ids: nil, tags: nil, dom: nil
+      f = filter(ids, tags, dom)
+      query = "#{f} modify #{attr} #{val}"
+      Execute.task_popen3(*override_a, query) do |i, o, e, t|
+        return t.value
+      end
+    end
 
+    # Directly call `task undo`, which only applies to edits to the task db
+    # not configuration changes
+    #
+    # @api public
     def undo!
+      Execute.task_popen3(*override_a, "undo") do |i, o, e, t|
+        return t.value
+      end
     end
 
+    # Update a configuration variable in the .taskrc
+    #
+    # @param attr [String]
+    # @param val [String]
+    # @api public
     def update_config! attr, val
       Execute.task_popen3(*override_a, "config #{attr} #{val}") do |i, o, e, t|
         return t.value
       end
     end
 
-    # Retrieves an array of hashes with info about the udas currently available
+    # Retrieves a hash of hashes with info about the UDAs currently available
+    #
+    # @return [Hash{Symbol=>Hash}]
+    # @api public
     def get_udas
+      udas = {}
       taskrc.config.attributes
-        .select { |attr, val| uda_attr? attr }
+        .select { |attr, val| Helpers.uda_attr? attr }
         .sort
-        .chunk  { |attr, val| arbitrary_attr attr }
-        .map do |attr, arr|
+        .chunk  { |attr, val| Helpers.arbitrary_attr attr }
+        .each do |attr, arr|
           uda = arr.map do |pair|
-            key = deep_attr(pair[0])
-            val = pair[1]
-            [key, val]
+            [Helpers.deep_attr(pair[0]), pair[1]]
           end
-          {attr.to_sym => Hash[uda]}
+          udas[attr.to_sym] = Hash[uda]
         end
+        return udas
     end
 
-    # Is a given attribute dealing with udas?
-    def uda_attr? attr
-      attr.to_s.start_with? "uda"
-    end
-    private :uda_attr?
-
-    # Returns part of attribute at a given depth
-    def arbitrary_attr attr, depth: 1
-      attr.to_s.split("_")[depth]
-    end
-
-    # Returns all attribute string after given depth
-    def deep_attr attr, depth: 2
-      attr.to_s.split("_")[depth..-1].join("_")
+    # Add new found udas to our internal TaskModel
+    #
+    # @param uda_hash [Hash{Symbol=>Hash}]
+    # @param type [Class, nil]
+    # @param model [Models::TaskModel, Class]
+    # @api protected
+    def add_udas_to_model! uda_hash, type=nil, model=Models::TaskModel
+      uda_hash.each do |attr, val|
+        val.each do |k, v|
+          type = Helpers.determine_type(v) if type.nil?
+          model.attribute attr, type
+        end
+      end
     end
-    private :deep_attr
-    
+    protected :add_udas_to_model!
 
     # Retrieve an array of the uda names
     #
@@ -95,18 +154,32 @@ module Rtasklib
       end
     end
 
-    def create_uda name, type: "string", label: nil, values: nil,
+    # Add a UDA to the users config/database
+    #
+    # @param name [String]
+    # @param type [String]
+    # @param label [String]
+    # @param values [String]
+    # @param default [String]
+    # @param urgency [String]
+    # @return [Boolean] success
+    # @api public
+    def create_uda! name, type: "string", label: nil, values: nil,
                    default: nil, urgency: nil
       label = name if label.nil?
-      p name, label, values, default, urgency
 
-      update_config "uda.#{name}.type",  type
-      update_config "uda.#{name}.label", label
-      update_config "uda.#{name}.values",  values unless values.nil?
-      update_config "uda.#{name}.default", default unless default.nil?
-      update_config "uda.#{name}.urgency", urgency unless urgency.nil?
+      update_config("uda.#{name}.type",  type)
+      update_config("uda.#{name}.label", label)
+      update_config("uda.#{name}.values",  values)  unless values.nil?
+      update_config("uda.#{name}.default", default) unless default.nil?
+      update_config("uda.#{name}.urgency", urgency) unless urgency.nil?
     end
 
+    # Calls `task _show` with initial overrides returns a Taskrc object of the
+    # result
+    #
+    # @return [Taskrc]
+    # @api public
     def get_rc
       res = []
       Execute.task_popen3(*@override_a, "_show") do |i, o, e, t|
@@ -115,22 +188,16 @@ module Rtasklib
       Taskrc.new(res, :array)
     end
 
+    # Calls `task _version` and returns the result
+    #
+    # @return [String]
+    # @api public
     def get_version
       version = nil
-      Execute.task_popen3(*@override_a, "_version") do |i, o, e, t|
-        version = to_gem_version(o.read.chomp)
+      Execute.task_popen3("_version") do |i, o, e, t|
+        version = Helpers.to_gem_version(o.read.chomp)
       end
       version
     end
-
-    # Converts a string of format "1.6.2 (adf342jsd)" to Gem::Version object
-    #
-    #
-    def to_gem_version raw
-      std_ver = raw.chomp.gsub(' ','.').delete('(').delete(')')
-      Gem::Version.new std_ver
-    end
-    private :to_gem_version
-
   end
 end

data/lib/rtasklib/execute.rb

@@ -12,12 +12,23 @@ module Rtasklib
                     so \s taskwarrior \s can \s proceed\? \s
                     \(yes/no\)}x }
 
-    # popen versions
+    # Use Open3#popen3 to execute a unix program with an array of options
+    # and an optional block to handle the response.
     #
+    # @example
+    #    Execute.popen3("task", "export") do |i, o, e, t|
+    #      # Arbitrary code to handle the response...
+    #    end
+    #
+    # @param program [String]
+    # @param opts [Array<String>] args to pass directly to the program
+    # @param block [Block] to execute after thread is successful
+    # @yield [i,o,e,t] STDIN, STDOUT, STDERR, and the thread to that block.
+    # @api public
     def popen3 program='task', *opts, &block
       execute = opts.unshift(program)
       execute = execute.join(" ")
-      p execute
+      warn execute
 
       Open3.popen3(execute) do |i, o, e, t|
         handle_response(e, t)
@@ -25,10 +36,30 @@ module Rtasklib
       end
     end
 
+    # Same as Execute#popen3, only defaults to using the 'task' program for
+    # convenience.
+    #
+    # @example
+    #    Execute.task_popen3("export") do |i, o, e, t|
+    #      # Arbitrary code to handle the response...
+    #    end
+    #
+    # @param opts [Array<String>] args to pass directly to the program
+    # @param block [Block] to execute after thread is successful
+    # @yield [i,o,e,t] STDIN, STDOUT, STDERR, and the thread to that block.
+    # @api public
     def task_popen3 *opts, &block
       popen3('task', opts, &block)
     end
 
+    # Same as Execute#popen3, but yields each line of input
+    #
+    # @param program [String]
+    # @param opts [Array<String>] args to pass directly to the program
+    # @param block [Block] to execute after thread is successful
+    # @yield [l,i,o,e,t] a line of STDIN, STDIN, STDOUT, STDERR,
+    #     and the thread to that block.
+    # @api public
     def each_popen3 program='task', *opts, &block
       popen3(program, *opts) do |i, o, e, t|
         o.each_line do |l|
@@ -37,49 +68,28 @@ module Rtasklib
       end
     end
 
+    # Same as Execute#each_popen3, but calls it with the 'task' program
+    #
+    # @param opts [Array<String>] args to pass directly to the program
+    # @param block [Block] to execute after thread is successful
+    # @yield [l,i,o,e,t] a line of STDIN, STDIN, STDOUT, STDERR,
+    #     and the thread to that block.
+    # @api public
     def task_each_popen3 *opts, &block
-      popen3(program, *opts) do |i, o, e, t|
-        yield(i, o, e, t)
+      each_popen3("task", *opts) do |l, i, o, e, t|
+        yield(l, i, o, e, t)
       end
     end
 
+    # Default error handling called in every popen3 call. Only executes if
+    # thread had a failing exit code
+    #
+    # @raise [RuntimeError] if failing exit code
     def handle_response stderr, thread
       unless thread.value.success?
         puts stderr.read
-        exit(-1)
+        raise thread.inspect
       end
     end
-
-    # Non-greedy json object detection
-    # if /\{.*\}/ =~ l
-      # p l.chomp
-      # res.push(l.chomp)
-    # end
-    # def task create_new, *opts, &block
-    #   exp_regex = @@exp_regex
-    #   retval = 0
-    #   res = nil
-    #   buff = ""
-    #
-    #   run("task", *opts) do |exp, procedure|
-    #     res = procedure.any do
-    #       puts exp
-    #       expect exp_regex[:create_rc] do
-    #         if create_new
-    #           send "yes"
-    #         else
-    #           send "no"
-    #         end
-    #       end
-    #       block.call if block_given?
-    #     end
-
-    # Filters should be a list of values
-    # Ranges interpreted as ids
-    #   1...5 : "1-5"
-    #   1..5  : "1-4"
-    #   1     : "1"
-    #   and joined with ","
-    #   [1...5, 8, 9] : "1-5,8,9"
   end
 end

data/lib/rtasklib/helpers.rb

@@ -0,0 +1,205 @@
+require "multi_json"
+require "oj"
+
+module Rtasklib
+
+  # A collection of stateless, non-end-user facing functions available
+  # throughout the library
+  module Helpers
+    # make this module a stateless, singleton
+    extend self
+
+    # Converts ids, tags, and dom queries to a single string ready to pass
+    # directly to task.
+    #
+    # @param ids[Range, Array<String, Range, Fixnum>, String, Fixnum]
+    # @param tags[String, Array<String>]
+    # @param dom[String, Array<String>]
+    # @return [String] a string with ids tags and dom joined by a space
+    # @api public
+    def filter ids: nil, tags: nil, dom: nil
+      id_s = tag_s = dom_s = ""
+      id_s   = process_ids(ids)   unless ids.nil?
+      tag_s  = process_tags(tags) unless tags.nil?
+      dom_s  = process_dom(dom)   unless dom.nil?
+      return "#{id_s} #{tag_s} #{dom_s}".strip
+    end
+
+    # Filters should be a list of values
+    # Ranges interpreted as ids
+    # 1...5 : "1,2,3,4,5"
+    # 1..5  : "1,2,3,4"
+    # 1     : "1"
+    # and joined with ","
+    # [1...5, 8, 9] : "1,2,3,4,5,8,9"
+    #
+    # @param id_a [Array<String, Range, Fixnum>]
+    # @return [String]
+    # @api public
+    def id_a_to_s id_a
+      id_a.map do |el|
+         proc_ids = process_ids(el)
+         proc_ids
+      end.compact.join(",")
+    end
+
+    # Converts arbitrary id input to a task safe string
+    #
+    # @param ids[Range, Array<String, Range, Fixnum>, String, Fixnum]
+    # @api public
+    def process_ids ids
+      case ids
+      when Range
+        return id_range_to_s(ids)
+      when Array
+        return id_a_to_s(ids)
+      when String
+        return ids.delete(" ")
+      when Fixnum
+        return ids
+      end
+    end
+
+    # Convert a range to a comma separated strings, e.g. 1..4 -> "1,2,3,4"
+    #
+    # @param id_range [Range]
+    # @return [Array<String>]
+    # @api public
+    def id_range_to_s id_range
+      id_range.to_a.join(",")
+    end
+
+    # Convert a tag string or an array of strings to a space separated string
+    #
+    # @param tags [String, Array<String>]
+    # @api private
+    def process_tags tags
+      case tags
+      when String
+        tags.split(" ").map { |t| process_tag t }.join(" ")
+      when Array
+        tags.map { |t| process_tags t }.join(" ")
+      end
+    end
+
+    # Ensures that a tag begins with a + or -
+    #
+    # @return [String]
+    # @api public
+    def process_tag tag
+      reserved_symbols = %w{+ - and or xor < <= = != >=  > ( )}
+
+      # convert plain tags to plus tags
+      unless tag.start_with?(*reserved_symbols)
+        tag = "+#{tag}"
+      end
+      return tag
+    end
+
+    # @api private
+    def process_dom dom
+    end
+
+    # Is a given taskrc attribute dealing with udas?
+    #
+    # @api public
+    def uda_attr? attr
+      attr.to_s.start_with? "uda"
+    end
+
+    # Returns part of attribute at a given depth
+    #
+    # @api public
+    def arbitrary_attr attr, depth: 1
+      attr.to_s.split("_")[depth]
+    end
+
+    # Returns all attribute string after given depth
+    #
+    # @api public
+    def deep_attr attr, depth: 2
+      attr.to_s.split("_")[depth..-1].join("_")
+    end
+
+    # Converts a string of format "1.6.2 (adf342jsd)" to Gem::Version object
+    #
+    # @param raw [String]
+    # @return [Gem::Version]
+    # @api public
+    def to_gem_version raw
+      std_ver = raw.chomp.gsub(' ','.').delete('(').delete(')')
+      Gem::Version.new std_ver
+    end
+
+    # Determine the type that a value should be coerced to
+    # Int needs to precede float because ints are also floats
+    # Doesn't detect arrays, b/c task stores these as comma separated strings
+    # which could just as easily be Strings....
+    # If nothing works it defaults to String.
+    # TODO: JSON parse
+    #
+    # @param value [Object] anything that needs to be coerced, probably string
+    # @return [Axiom::Types::Boolean, Integer, Float, String]
+    # @api public
+    def determine_type value
+      if boolean? value
+        return Axiom::Types::Boolean
+      elsif integer? value
+        return Integer
+      elsif float? value
+        return Float
+      elsif json? value
+        return MultiJson
+      else
+        return String
+      end
+    end
+
+    # Can the input be coerced to an integer without losing information?
+    #
+    # @return [Boolean] true if coercible, false if not
+    # @api private
+    def integer? value
+      value.to_i.to_s == value rescue false
+    end
+    private :integer?
+
+    # Can the input be coerced to a JSON object without losing information?
+    #
+    # @return [Boolean] true if coercible, false if not
+    # @api private
+    def json? value
+      begin
+        return false unless value.is_a? String
+        MultiJson.load(value)
+        true
+      rescue MultiJson::ParseError
+        false
+      end
+    end
+    private :json?
+
+    # Can the input be coerced to a float without losing information?
+    #
+    # @return [Boolean] true if coercible, false if not
+    # @api private
+    def float? value
+      begin
+        true if Float(value)
+      rescue
+        false
+      end
+    end
+    private :float?
+
+    # Can the input be coerced to a boolean without losing information?
+    #
+    # @return [Boolean] true if coercible, false if not
+    # @api private
+    def boolean? value
+      ["on", "off", "yes", "no", "false", "true"]
+        .include? value.to_s.downcase rescue false
+    end
+    private :boolean?
+  end
+end

data/lib/rtasklib/models.rb

@@ -1,22 +1,37 @@
 require "virtus"
 require "active_model"
+require 'iso8601'
+require 'date'
 
 module Rtasklib::Models
-  ValidationError = Class.new RuntimeError
 
-  class UUID < Virtus::Attribute
-    def coerce(value)
-      value.to_s
+  # A subclass of the ISO8601::Duration object that use `task calc` to parse
+  # string names like 'weekly', 'biannual', and '3 quarters'
+  #
+  # Modifies the #initialize method, preserving the original string duration
+  class TWDuration < ISO8601::Duration
+    attr_reader :frozen_value
+
+    def initialize input, base=nil
+      @frozen_value = input.dup.freeze
+      parsed = `task calc #{input}`.chomp
+
+      super parsed, base
+    end
+  end
+
+  # Custom coercer to change a string input into an TWDuration object
+  class VirtusDuration < Virtus::Attribute
+    def coerce(v)
+      if v.nil? || v.blank? then nil else TWDuration.new(v) end
     end
   end
 
   RcBooleans = Virtus.model do |mod|
     mod.coerce = true
     mod.coercer.config.string.boolean_map = {
-      'no'  => false,
-      'yes' => true,
-      'on'  => true,
-      'off' => false }
+      'yes' => true,  'on'  => true,
+      'no'  => false, 'off' => false }
   end
 
   class TaskrcModel
@@ -61,7 +76,7 @@ module Rtasklib::Models
     attribute :wait,          DateTime
 
     # Required only for tasks that are Recurring or have Recurring Parent
-    attribute :recur,         DateTime
+    attribute :recur,         VirtusDuration
 
     # Optional except for tasks with Recurring Parents
     attribute :due,           DateTime
@@ -74,8 +89,6 @@ module Rtasklib::Models
     attribute :imask,         String
     attribute :modified,      DateTime
 
-    # TODO: handle arbitrary UDA's
-
     # Refactoring idea, need to understand Virtus internals a bit better
     # [:mask, :imask, :modified, :status, :uuid, :entry].each do |ro_attr|
     #   define_method("set_#{ro_attr.to_s}") do |value|

data/lib/rtasklib/taskrc.rb

@@ -25,7 +25,7 @@ module Rtasklib
         hash_to_model(rc)
       when :path
         if path_exist?(rc)
-          mappable_to_model(File.open(rc))
+          mappable_to_model(File.open(rc).readlines)
         else
           raise RuntimeError.new("rc path does not exist on the file system")
         end
@@ -53,7 +53,7 @@ module Rtasklib
     # Converts a .taskrc file path into a Hash that can be converted into a
     # TaskrcModel object
     #
-    # @param rc_path [String,Pathname] a valid pathname to a .taskrc file
+    # @param rc_file [String,Pathname] a valid pathname to a .taskrc file
     # @return [Models::TaskrcModel] the instance variable config
     # @api private
     def mappable_to_model rc_file
@@ -123,7 +123,6 @@ module Rtasklib
 
     # Dynamically add a Virtus attr, detect Boolean, Integer, and Float types
     # based on the value, otherwise just treat it like a string.
-    # Int needs to precede float because ints are also floats
     # Modifies the config instance variable
     # TODO: May also be able to detect arrays
     #
@@ -132,22 +131,14 @@ module Rtasklib
     # @return [undefined]
     # @api private
     def add_model_attr attr, value
-      if boolean? value
-        config.attribute attr.to_sym, Axiom::Types::Boolean
-      elsif integer? value
-        config.attribute attr.to_sym, Integer
-      elsif float? value
-        config.attribute attr.to_sym, Float
-      else
-        config.attribute attr.to_sym, String
-      end
+      config.attribute(attr.to_sym, Helpers.determine_type(value))
     end
     private :add_model_attr
 
     # Modifies the value of a given attr in the config object
     #
     # @param attr [#to_s] the name for the attr, e.g. "json_array"
-    # @param attr [String] the value of the attr, e.g. "yes"
+    # @param value [String] the value of the attr, e.g. "yes"
     # @return [undefined]
     # @api public
     def set_model_attr_value attr, value
@@ -194,20 +185,5 @@ module Rtasklib
       end
     end
     private :path_exist?
-
-    def integer? value
-      value.to_i.to_s == value
-    end
-    private :integer?
-
-    def float? value
-      Float(value) rescue false
-    end
-    private :float?
-
-    def boolean? value
-      ["on", "off", "yes", "no", "false", "true"].include? value.to_s.downcase
-    end
-    private :boolean?
   end
 end

data/lib/rtasklib/version.rb

@@ -1,3 +1,3 @@
 module Rtasklib
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/spec/controller_spec.rb

@@ -3,16 +3,62 @@ require 'spec_helper'
 describe Rtasklib::Controller do
   include Rtasklib::Controller
 
-  it 'can handle sub version numbers' do
-    expect(to_gem_version("2.5.3 (afdj5)"))
-      .to eq(Gem::Version.new("2.5.3.afdj5"))
+  shared_examples_for 'export' do
+    it 'should return an Array' do
+      expect(subject.class).to eq Array
+    end
+
+    it 'should return an Array<TaskModel>' do
+      expect(subject.each do |t|
+        expect(t.class).to eq(Rtasklib::Models::TaskModel)
+      end)
+    end
+  end
+
+  shared_examples_for 'export all' do
+    it_behaves_like 'export'
+
+    it 'should load in the correct number of task models' do
+      expect(subject.size).to eq(4)
+    end
   end
 
   describe 'Rtasklib::Controller#all' do
+    subject { Rtasklib::TaskWarrior.new("spec/data/.task").all }
+    it_behaves_like 'export all'
+  end
+
+  describe 'Rtasklib::Controller#some' do
+
+    describe '#some without arguments should behave like #all' do
+      subject { Rtasklib::TaskWarrior.new("spec/data/.task").some }
+      it_behaves_like 'export all'
+    end
+
+    describe '#some should accept filter parameters' do
+      subject { Rtasklib::TaskWarrior.new("spec/data/.task").some ids:[1,2] }
+      it_behaves_like 'export'
+
+      it 'should load in the correct number of task models' do
+        expect(subject.size).to eq(2)
+      end
+    end
   end
 
   describe 'Rtasklib::Controller#check_uda' do
     it 'should return true if a uda is found that matches the input' do
     end
   end
+
+  describe 'Rtasklib::Controller#all' do
+  end
+
+  describe 'Rtasklib::Controller#add!' do
+  end
+
+  describe 'Rtasklib::Controller#modify!' do
+  end
+
+  describe 'Rtasklib::Controller#undo!' do
+  end
 end

data/spec/data/.task/backlog.data

@@ -1,2 +1,5 @@
 {"description":"Wash dishes","entry":"20150316T174823Z","modified":"20150316T174823Z","status":"pending","uuid":"1ecac94d-b4d6-4c02-98f7-75e4de03006b"}
 {"description":"Clean room","entry":"20150316T174852Z","modified":"20150316T174852Z","status":"pending","uuid":"12d3176a-b6b1-42ab-90ad-6cd6acf8d6a1"}
+{"description":"Test recur","entry":"20150512T200658Z","modified":"20150512T200658Z","status":"pending","uuid":"d203a656-f7ab-4707-8e38-abdced29acc4"}
+{"description":"Test recur","due":"20160101T045959Z","entry":"20150512T200658Z","modified":"20150512T200658Z","recur":"weekly","status":"recurring","uuid":"d203a656-f7ab-4707-8e38-abdced29acc4"}
+{"description":"biannual test","due":"20160101T045959Z","entry":"20150512T204148Z","modified":"20150512T204148Z","recur":"biannual","status":"recurring","uuid":"45fc918e-f106-45d8-96b6-37eaf61f2f4e"}

data/spec/data/.task/pending.data

@@ -1,2 +1,4 @@
 [description:"Wash dishes" entry:"1426528103" modified:"1426528103" status:"pending" uuid:"1ecac94d-b4d6-4c02-98f7-75e4de03006b"]
 [description:"Clean room" entry:"1426528132" modified:"1426528132" status:"pending" uuid:"12d3176a-b6b1-42ab-90ad-6cd6acf8d6a1"]
+[description:"Test recur" due:"1451624399" entry:"1431461218" modified:"1431461218" recur:"weekly" status:"recurring" uuid:"d203a656-f7ab-4707-8e38-abdced29acc4"]
+[description:"biannual test" due:"1451624399" entry:"1431463308" modified:"1431463308" recur:"biannual" status:"recurring" uuid:"45fc918e-f106-45d8-96b6-37eaf61f2f4e"]

data/spec/data/.task/undo.data

@@ -4,3 +4,13 @@ new [description:"Wash dishes" entry:"1426528103" modified:"1426528103" status:"
 time 1426528132
 new [description:"Clean room" entry:"1426528132" modified:"1426528132" status:"pending" uuid:"12d3176a-b6b1-42ab-90ad-6cd6acf8d6a1"]
 ---
+time 1431461218
+new [description:"Test recur" entry:"1431461218" modified:"1431461218" status:"pending" uuid:"d203a656-f7ab-4707-8e38-abdced29acc4"]
+---
+time 1431461251
+old [description:"Test recur" entry:"1431461218" modified:"1431461218" status:"pending" uuid:"d203a656-f7ab-4707-8e38-abdced29acc4"]
+new [description:"Test recur" due:"1451624399" entry:"1431461218" modified:"1431461218" recur:"weekly" status:"recurring" uuid:"d203a656-f7ab-4707-8e38-abdced29acc4"]
+---
+time 1431463308
+new [description:"biannual test" due:"1451624399" entry:"1431463308" modified:"1431463308" recur:"biannual" status:"recurring" uuid:"45fc918e-f106-45d8-96b6-37eaf61f2f4e"]
+---

data/spec/helpers_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Rtasklib::Helpers do
+
+  describe 'Rtasklib::Helpers#to_gem_version' do
+
+    it 'can handle sub version numbers' do
+      expect(Rtasklib::Helpers.to_gem_version("2.5.3 (afdj5)"))
+        .to eq(Gem::Version.new("2.5.3.afdj5"))
+    end
+  end
+
+  describe 'Rtasklib::Helpers#determine_type' do
+
+    it 'considers "10" an integer' do
+      expect(Rtasklib::Helpers.determine_type("10")).to eq(Integer)
+    end
+
+    it 'considers "10.1" a float' do
+      expect(Rtasklib::Helpers.determine_type("10.1")).to eq(Float)
+    end
+
+    it 'considers "on" a boolean' do
+      expect(Rtasklib::Helpers.determine_type("on")).to eq(Axiom::Types::Boolean)
+    end
+
+    it 'considers "{"yolo":[1,2,3]}" a JSON object' do
+      test_json = '{"id":1,"description":"Anonymous Book",
+                   "entry":"20150115T190114Z","modified":"20150115T190114Z",
+                   "project":"Read","status":"pending","tags":["stuff"],
+                   "uuid":"c483b58d-a3f2-4a2a-b944-8b41414309cb",
+                   "urgency":"2.45753"}'
+      expect(Rtasklib::Helpers.determine_type(test_json)).to eq(MultiJson)
+    end
+
+    it 'considers "on off" a String' do
+      expect(Rtasklib::Helpers.determine_type("on ")).to eq(String)
+    end
+  end
+
+  describe 'Rtasklib::Helpers#filter' do
+
+    it 'treats arrays of ranges properly' do
+      expect(Rtasklib::Helpers.filter(ids: [1..3,5...6])).to eq("1,2,3,5")
+    end
+
+    it 'treats arrays of strings properly' do
+      expect(Rtasklib::Helpers.filter(ids: ["1,2", "5"])).to eq("1,2,5")
+    end
+
+    it 'treats arrays of ints properly' do
+      expect(Rtasklib::Helpers.filter(ids: [1,2,3,4,5])).to eq("1,2,3,4,5")
+    end
+
+    it 'treats arrays mixed objects properly' do
+      expect(Rtasklib::Helpers.filter(ids: [1,2,3,4,5, 10..20, "7,8"]))
+      .to eq("1,2,3,4,5,10,11,12,13,14,15,16,17,18,19,20,7,8")
+    end
+
+    it 'treats tag arrays properly' do
+      expect(Rtasklib::Helpers.filter(tags: ["(", "+stuff", "or", "-school", ")", "work"]))
+        .to eq("( +stuff or -school ) +work")
+    end
+
+    it 'treats tag strings properly' do
+      expect(Rtasklib::Helpers.filter(tags: "+stuff -school work"))
+        .to eq("+stuff -school +work")
+    end
+
+    it 'treats tag/id combos properly' do
+      expect(Rtasklib::Helpers.filter(ids: [1,2,4..5], tags: "+stuff -school work"))
+        .to eq("1,2,4,5 +stuff -school +work")
+    end
+
+  end
+end

data/spec/rtasklib_spec.rb

@@ -6,8 +6,8 @@ describe Rtasklib do
   end
 
   describe Rtasklib::TaskWarrior do
-    describe "Rtasklib::TaskWarrior.new('spec/data/.taskrc')" do
-      subject{ Rtasklib::TaskWarrior.new('spec/data/.taskrc') }
+    describe "Rtasklib::TaskWarrior.new('spec/data/.task')" do
+      subject{ Rtasklib::TaskWarrior.new('spec/data/.task') }
       it 'has a version number' do
         expect(subject.version.class).to eq Gem::Version
       end
@@ -16,8 +16,8 @@ describe Rtasklib do
       end
     end
 
-    describe "Rtasklib::TaskWarrior.new('spec/data/.taskrc', {color: off})" do
-      subject{ Rtasklib::TaskWarrior.new('spec/data/.taskrc', {verbose: 'on'}) }
+    describe "Rtasklib::TaskWarrior.new('spec/data/.task', {color: off})" do
+      subject{ Rtasklib::TaskWarrior.new('spec/data/.task', {verbose: 'on'}) }
       it 'updates the default configuration override' do
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtasklib
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Will Paul
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-12 00:00:00.000000000 Z
+date: 2015-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -245,8 +245,8 @@ files:
 - lib/rtasklib.rb
 - lib/rtasklib/controller.rb
 - lib/rtasklib/execute.rb
+- lib/rtasklib/helpers.rb
 - lib/rtasklib/models.rb
-- lib/rtasklib/serializer.rb
 - lib/rtasklib/taskrc.rb
 - lib/rtasklib/version.rb
 - rtasklib.gemspec
@@ -257,9 +257,9 @@ files:
 - spec/data/.task/undo.data
 - spec/data/.taskrc
 - spec/execute_spec.rb
+- spec/helpers_spec.rb
 - spec/models_spec.rb
 - spec/rtasklib_spec.rb
-- spec/serializer_spec.rb
 - spec/spec_helper.rb
 - spec/taskrc_spec.rb
 homepage: http://github.com/dropofwill/rtasklib
@@ -283,7 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - taskwarrior, >=2.4.0
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A Ruby wrapper around the TaskWarrior CLI

data/lib/rtasklib/serializer.rb

@@ -1,10 +0,0 @@
-require "active_model"
-require "active_model/serializer"
-
-module Rtasklib
-
-  module Models
-    class TaskSerializer < ActiveModel::Serializer
-    end
-  end
-end