todo.txt 0.0.3

data/lib/todo/data/matcher.rb

@@ -0,0 +1,42 @@
+module Todo
+  module Data
+    class Matcher < Struct.new(:item, :data)
+      def matches?
+        return true if data.empty?
+        data[:id] ? match_id : match_data
+      end
+
+      private
+
+        def match_data
+          data.keys.inject(true) do |result, key|
+            result && send(:"match_#{key}")
+          end
+        end
+
+        def match_id
+          item.id.to_i == data[:id].to_i
+        end
+
+        def match_text
+          item.text.include?(data[:text])
+        end
+
+        def match_status
+          item.status && item.status.to_sym == normalize_status(data[:status].to_sym)
+        end
+
+        def match_since
+          item.done_date.to_s >= data[:since].to_s
+        end
+
+        def match_before
+          item.done_date.to_s < data[:before].to_s
+        end
+
+        def normalize_status(status)
+          status == :pending ? :pend : status
+        end
+    end
+  end
+end

data/lib/todo/data/parser.rb

@@ -0,0 +1,41 @@
+require 'todo'
+require 'todo/helpers/hash/compact'
+
+module Todo
+  module Data
+    class Parser < Struct.new(:line)
+      STATUS = /^(#{STATUSES.values.join('|')}){1}\s*/
+      ID     = /\s*\[(\d+)\]/
+      TAG    = /\s*([^\s]+):([^\s]+)/
+
+      include Helpers::Hash::Compact
+
+      def parse
+        compact(
+          id: id,
+          text: text,
+          status: status,
+          tags: tags,
+        )
+      end
+
+      private
+
+        def status
+          STATUSES.invert[line.match(STATUS) && $1]
+        end
+
+        def id
+          line =~ ID && $1.to_i
+        end
+
+        def text
+          line.sub(STATUS, '').gsub(ID, '').gsub(TAG, '').rstrip
+        end
+
+        def tags
+          Hash[line.scan(TAG).map { |key, value| [key.to_sym, value] }]
+        end
+    end
+  end
+end

data/lib/todo/helpers/hash/compact.rb

@@ -0,0 +1,13 @@
+module Todo
+  module Helpers
+    module Hash
+      module Compact
+        def compact(hash)
+          hash.reject { |key, value| value.nil? }
+        end
+
+        extend self
+      end
+    end
+  end
+end

data/lib/todo/helpers/hash/format.rb

@@ -0,0 +1,13 @@
+module Todo
+  module Helpers
+    module Hash
+      module Format
+        def to_pairs(hash, separator = '=')
+          hash.map { |key, value| [key, value].join(separator) }
+        end
+
+        extend self
+      end
+    end
+  end
+end

data/lib/todo/helpers/hash/slice.rb

@@ -0,0 +1,17 @@
+module Todo
+  module Helpers
+    module Hash
+      module Slice
+        def slice(hash, *keys)
+          hash.select { |key, value| keys.include?(key) }
+        end
+
+        def except(hash, *keys)
+          hash.reject { |key, value| keys.include?(key) }
+        end
+
+        extend self
+      end
+    end
+  end
+end

data/lib/todo/helpers/object/presence.rb

@@ -0,0 +1,26 @@
+module Todo
+  module Helpers
+    module Object
+      module Presence
+        def present?(obj)
+          case obj
+          when NilClass, FalseClass
+            false
+          when TrueClass, Symbol, Numeric
+            true
+          when ::String, ::Array, ::Hash
+            !obj.empty?
+          else
+            fail "Unexpected object type #{obj.inspect}"
+          end
+        end
+
+        def blank?(obj)
+          not present?(obj)
+        end
+
+        extend self
+      end
+    end
+  end
+end

data/lib/todo/helpers/string/camelize.rb

@@ -0,0 +1,16 @@
+module Todo
+  module Helpers
+    module String
+      module Camelize
+        def camelize(string)
+          string.to_s.
+            sub(/^[a-z\d]*/) { $&.capitalize }.
+            gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }.
+            gsub('/', '::')
+        end
+
+        extend self
+      end
+    end
+  end
+end

data/lib/todo/src/file.rb

@@ -0,0 +1,24 @@
+module Todo
+  module Src
+    class File
+      attr_reader :path, :mode
+
+      def initialize(path, opts = {})
+        @path = path
+        @mode = opts[:mode] || 'w+'
+      end
+
+      def exists?
+        ::File.exists?(path)
+      end
+
+      def read
+        exists? ? ::File.readlines(path).map(&:rstrip) : []
+      end
+
+      def write(lines)
+        ::File.open(path, mode) { |f| f.puts(lines.join("\n")) }
+      end
+    end
+  end
+end

data/lib/todo/src/idonethis.rb

@@ -0,0 +1,52 @@
+require 'json'
+require 'todo/support/http'
+
+module Todo
+  module Src
+    class Idonthis < Struct.new(:config, :opts)
+      URL = 'https://idonethis.com/api/v0.1/dones/'
+
+      def include?(item)
+        texts.include?(item.text) or ids.include?(item.id)
+      end
+
+      def write(lines)
+        lines.each { |line| post(line) }
+      end
+
+      private
+
+        def texts
+          items.map(&:text)
+        end
+
+        def ids
+          items.map(&:id).compact
+        end
+
+        def items
+          @items ||= fetch.map { |item| Item.new(nil, item['raw_text']) }
+        end
+
+        def fetch
+          JSON.parse(get.body)['results'] || []
+        end
+
+        def get
+          Http.new(URL, headers: headers, params: params).get
+        end
+
+        def post(text)
+          Http.new(URL, headers: headers).post(raw_text: text, team: config[:team])
+        end
+
+        def headers
+          { 'Authorization' => "Token #{config[:token]}" }
+        end
+
+        def params
+          { owner: config[:username], team: config[:team], done_date_after: opts[:since], page_size: 100 }
+        end
+    end
+  end
+end

data/lib/todo/src/io.rb

@@ -0,0 +1,29 @@
+module Todo
+  module Src
+    class Io
+      attr_reader :opts
+
+      def initialize(opts = {})
+        @opts = opts
+      end
+
+      def read
+        @lines ||= input.readlines.map(&:rstrip)
+      end
+
+      def write(lines)
+        output.puts(lines.join("\n"))
+      end
+
+      private
+
+        def input
+          opts[:in] || $stdin
+        end
+
+        def output
+          opts[:out] || $stdout
+        end
+    end
+  end
+end

data/lib/todo/support/http.rb

@@ -0,0 +1,31 @@
+require 'net/http'
+require 'uri'
+
+module Todo
+  module Support
+    class Http
+      attr_reader :uri, :headers
+
+      def initialize(url, opts)
+        @uri = URI(url).tap { |url| url.query = URI.encode_www_form(opts[:params] || {}) }
+        @headers = opts[:headers] || {}
+      end
+
+      def get
+        client = Net::HTTP.new(url.host, url.port)
+        client.use_ssl = true
+        response = client.get(uri, headers)
+        raise "Failed to get #{url.to_s}" unless response.code.to_s[0] == '2'
+        response
+      end
+
+      def post(data)
+        request = Net::HTTP::Post.new(url, headers)
+        request.form_data = data
+        response = http.request(request)
+        raise "Failed to post to #{url.to_s}: #{response.body}" unless response.code.to_s[0] == '2'
+        response
+      end
+    end
+  end
+end

data/lib/todo/support/options_parser.rb

@@ -0,0 +1,31 @@
+require 'optparse'
+
+module Todo
+  module Support
+    module OptionsParser
+      def opt(*args, &block)
+        rules << [args, block]
+      end
+
+      def parse(args)
+        opts = {}
+        args = parser(opts).parse(args)
+        [args, opts]
+      end
+
+      private
+
+        def rules
+          @rules ||= (superclass.instance_variable_get(:@rules) || []).dup
+        end
+
+        def parser(opts)
+          OptionParser.new do |parser|
+            rules.each do |args, block|
+              parser.on(*args) { |value| block.call(opts, value.strip) }
+            end
+          end
+        end
+    end
+  end
+end

data/lib/todo/version.rb

@@ -0,0 +1,3 @@
+module Todo
+  VERSION = '0.0.3'
+end

data/lib/todo/view.rb

@@ -0,0 +1,49 @@
+require 'todo'
+require 'todo/helpers/hash/format'
+require 'todo/helpers/object/presence'
+
+module Todo
+  class View < Struct.new(:items, :cols)
+    COLS = [:status, :text, :tags, :id]
+
+    include Helpers::Hash::Format, Helpers::Object::Presence
+
+    def render
+      items.map { |item| format(item) }
+    end
+
+    private
+
+      def format(item)
+        cols.map { |col| format_col(col, item.send(col)) }.compact.join(' ')
+      end
+
+      def format_col(col, value)
+        send(:"format_#{col}", value) if present?(value)
+      end
+
+      def format_status(status)
+        STATUSES[status]
+      end
+
+      def format_id(id)
+        "[#{id}]"
+      end
+
+      def format_text(text)
+        text
+      end
+
+      def format_done_date(date)
+        date
+      end
+
+      def format_tags(tags)
+        to_pairs(tags, ':') if tags.any?
+      end
+
+      def cols
+        super || COLS
+      end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'time'
+require 'support/io'
+
+NOW = Time.parse('2015-12-01 00:02:00 +0200')
+
+RSpec.configure do |c|
+  c.mock_with :mocha
+  c.before { Time.stubs(:now).returns(NOW) }
+end

data/spec/support/io.rb

@@ -0,0 +1,9 @@
+require 'stringio'
+
+module Support
+  class Io < StringIO
+    def readlines
+      string.split("\n")
+    end
+  end
+end

data/spec/todo/cli/archive_spec.rb

@@ -0,0 +1,16 @@
+require 'todo/cli/archive'
+require 'fileutils'
+
+describe Todo::Cli::Archive do
+  let(:lines) { ['- foo [1]', 'x bar done:2015-11-01 [2]', 'x baz done:2015-12-01 [3]'] }
+  let(:io)    { Support::Io.new(lines.join("\n")) }
+  let(:out)   { Support::Io.new }
+  let(:opts)  { { archive: '/tmp/todo.archive.txt', in: io, out: out } }
+
+  subject     { described_class.new(nil, opts) }
+  before      { subject.run }
+  after       { FileUtils.rm_f(opts[:archive]) }
+
+  it { expect(out.readlines).to eq ['- foo [1]', 'x baz done:2015-12-01 [3]'] }
+  it { expect(File.read(opts[:archive]).strip).to eq 'x bar done:2015-11-01 [2]' }
+end