todoist_querynaut 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c812ff2de231d377f592d944c80e8e090803ce39
+  data.tar.gz: 54f155642e5e2f205eb8b18011495568ab6efb7c
+SHA512:
+  metadata.gz: 5b9f67cdd4ad545a160c8094bd3613b996780d4c55580c2e3225d44aa938af98f08b62a0b078f938a2aa2b9c1fde6119c1d7ee1164914495a78f61f45981ddec
+  data.tar.gz: ab61e52a42a093363e88ca21f7ed1d26838f36401feae953e0fc8cc73ffb3cedfb4d660d284f8c35fbdafe28906e030502f41af1d5efea924fda9b5d69ebb40d

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Stefan Siegl
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# TodoistQuerynaut
+
+Todoist Querynaut is a Ruby Gem that reimplements the [filter query language](https://support.todoist.com/hc/en-us/articles/205248842-Filters)
+of Todoist.
+
+[Todoist](https://todoist.com) has a powerful feature named filters,
+yet they are implemented on client side (i.e. within their web application).
+It even has a REST API that allows to do searches, yet they are not as powerful,
+e.g. they don't allow for boolean operator logic.
+
+This is where Todoist Querynaut kicks in, it has a parser for the query
+language and does one or more calls to the REST API to collect the correct set
+of result items.
+
+Querynaut isn't yet fully fledged, some search capabilities are missing
+
+* search for items within sub-projects
+* filtering based on exact due dates
+* filtering based on creation date
+* "no labels" query
+
+## Installation
+
+Add this line to your application's Gemfile
+
+```ruby
+gem 'todoist_querynaut'
+```
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+```ruby
+querynaut = TodoistQuerynaut::Client.new(Todoist::Client.new("your_api_token"))
+result = @client.run("(overdue | today) & #work")
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/stesie/todoist_querynaut/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/todoist_querynaut.rb

@@ -0,0 +1,9 @@
+require 'treetop'
+require 'todoist'
+
+module TodoistQuerynaut; end
+
+require 'todoist_querynaut/client'
+require 'todoist_querynaut/parser'
+require 'todoist_querynaut/project_not_found_error'
+require 'todoist_querynaut/todoist_query/node_extensions'

data/lib/todoist_querynaut/client.rb

@@ -0,0 +1,36 @@
+module TodoistQuerynaut
+  class Client
+    def initialize(todoist)
+      @todoist = todoist
+    end
+
+    def run(query)
+      TodoistQuerynaut::Parser.parse(query).run_query self
+    end
+
+    def search(query)
+      # Todoist doesn't always set "query" on the results, hence we cannot
+      # search(value)[value] here, as ruby-todoist-api Gem then assigns "nil"
+      # as the hash's key.  Instead we do .first.last, to get the value of the
+      # first hash entry
+      @todoist.query.search(query).first.last.data
+    end
+
+    def all_items
+      search "view all"
+    end
+
+    def project_name_to_id(name)
+      projects = all_projects.select{|p| p["name"].casecmp(name) == 0}
+      raise ProjectNotFoundError if projects.empty?
+      projects.first["id"].to_i
+    end
+
+    private
+
+    def all_projects()
+      @projects ||= @todoist.projects.retrieve(["projects"])["Projects"]
+    end
+  end
+end
+

data/lib/todoist_querynaut/parser.rb

@@ -0,0 +1,35 @@
+module TodoistQuerynaut
+  class Parser
+    Treetop.load(File.join(File.dirname(__FILE__), 'todoist_query_parser.treetop'))
+    @@parser = TodoistQueryParser.new
+
+    def self.parse(data)
+      tree = @@parser.parse(data)
+
+      if tree.nil?
+	raise Exception, "Parse error at offset: #{@@parser.index}"
+      end
+
+      #return tree
+      return self.clean_tree(tree)
+    end
+
+    private
+
+    def self.clean_tree(node)
+      if node.class.name == "Treetop::Runtime::SyntaxNode"
+	if node.elements.nil? || node.elements.length == 0
+	  return node.empty? ? [] : node
+	else
+	  return node.elements.map{|n| self.clean_tree n}.flatten(1)
+	end
+      else
+	if !node.elements.nil?
+	  node.elements.replace node.elements.map{|n| self.clean_tree n}.flatten(1)
+	  return node.children[0] if node.is_a?(TodoistQuery::SetExpressionNode) && node.sole?
+	end
+	return node
+      end
+    end
+  end
+end

data/lib/todoist_querynaut/project_not_found_error.rb

@@ -0,0 +1,2 @@
+class ProjectNotFoundError < RuntimeError
+end

data/lib/todoist_querynaut/todoist_query/node_extensions.rb

@@ -0,0 +1,72 @@
+module TodoistQuerynaut
+  module TodoistQuery
+    class SetExpressionNode < Treetop::Runtime::SyntaxNode
+      def children
+        elements.reject{|a| a.class.name == 'Treetop::Runtime::SyntaxNode'}
+      end
+
+      def sole?
+        children.size == 1
+      end
+    end
+
+    class Union < SetExpressionNode
+      def run_query(todoist)
+        children.inject [] {|acc,child| acc | (child.run_query todoist)}
+      end
+    end
+
+    class Intersection < SetExpressionNode
+      def run_query(todoist)
+        acc = children[0].run_query todoist
+        children.drop(1).inject(acc) {|acc,child| acc & (child.run_query todoist)}
+      end
+    end
+
+    class LiteralQuery < Treetop::Runtime::SyntaxNode
+      def value
+        text_value
+      end
+
+      def run_query(todoist)
+        todoist.search(value)
+      end
+    end
+
+    class NDaysQuery < Treetop::Runtime::SyntaxNode
+    end
+
+    class PriorityQuery < Treetop::Runtime::SyntaxNode
+      def value
+        text_value[-1].to_i
+      end
+
+      def run_query(todoist)
+        todoist.search "p#{value}"
+      end
+    end
+
+    class ProjectNameQuery < Treetop::Runtime::SyntaxNode
+      def value
+        text_value[2..-1]
+      end
+
+      def run_query(todoist)
+        project_id = todoist.project_name_to_id value
+        todoist.all_items.select{|item| item["project_id"] == project_id}
+      end
+    end
+
+    class LabelQuery < Treetop::Runtime::SyntaxNode
+    end
+
+    class NoLabelsQuery < Treetop::Runtime::SyntaxNode
+    end
+
+    class NegatedQuery < Treetop::Runtime::SyntaxNode
+      def run_query(todoist)
+        todoist.all_items - query.run_query(todoist)
+      end
+    end
+  end
+end

data/lib/todoist_querynaut/todoist_query_parser.treetop

@@ -0,0 +1,55 @@
+module TodoistQuerynaut
+  grammar TodoistQuery
+    rule union
+      intersection ( '|' intersection )*  <Union>
+    end
+
+    rule intersection
+      primary ( '&' primary )*  <Intersection>
+    end
+
+    rule primary
+      space? ( '(' union ')' / query_part ) space?
+    end
+
+    rule query_part
+      negated_part / literal_query / n_days_query / priority_query / project_name_query / label_query / no_labels_query
+    end
+
+    rule negated_part
+      '!' query:query_part <NegatedQuery>
+    end
+
+    rule literal_query
+      'over due' <LiteralQuery> / 'overdue' <LiteralQuery> / 'today' <LiteralQuery> / 'tomorrow' <LiteralQuery> / 'view all' <LiteralQuery>
+    end
+
+    rule n_days_query
+      [0-9]+ space "days" <NDaysQuery> {
+        def value
+          text_value.to_i
+        end
+      }
+    end
+
+    rule priority_query
+      ("priority" space / "p") [1-4] <PriorityQuery>
+    end
+
+    rule project_name_query
+      'p:' [\w]+ <ProjectNameQuery>
+    end
+
+    rule label_query
+      '@' [\w]+ <LiteralQuery>
+    end
+
+    rule no_labels_query
+      'no labels' <NoLabelsQuery>
+    end
+
+    rule space
+      [\s]+
+    end
+  end
+end

data/spec/lib/todoist_querynaut/client_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe TodoistQuerynaut::Client do
+  describe "#search" do
+    it "delegates search query to todoist api and returns result" do
+      todoist_api = double()
+      allow(todoist_api).to receive(:query) {
+        query_obj = double()
+        allow(query_obj).to receive(:search) { |query|
+          { query => Todoist::Result.new({ "query" => "foo", "data" => [ "content_here" ] }) }
+        }
+        query_obj
+      }
+
+      result = TodoistQuerynaut::Client.new(todoist_api).search("foobar")
+      expect(result).to eq(["content_here"])
+    end
+  end
+
+  describe "#all_items" do
+    it "should run a 'view all' query" do
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"view all\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_view_all"), :headers => {})
+      result = TodoistQuerynaut::Client.new(Todoist::Client.new("some_token")).all_items
+
+      expect(result.size).to eq(4)
+    end
+  end
+
+  describe "#project_name_to_id" do
+    before :each do
+      stub_request(:post, "https://todoist.com/API/v6/sync").
+        with(:body => { "seq_no" => "0", "seq_no_global" => "0", "resource_types" => '["projects"]', "token" => "some_token" }).
+        to_return(:status => 200, :body => json_response_raw("sync_projects_all"), :headers => {})
+      @client = TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+    end
+
+    it "should resolve 'Someday Maybe' to 185594700" do
+      result = @client.project_name_to_id("Someday Maybe")
+      expect(result).to eq(185594700)
+    end
+
+    it "should resolve project names without case-sensitivity" do
+      result = @client.project_name_to_id("SomeDAY MayBE")
+      expect(result).to eq(185594700)
+    end
+
+    it "should raise ProjectNotFoundError for 'No Such Project'" do
+      expect{ @client.project_name_to_id("No Such Project") }.to raise_error(ProjectNotFoundError)
+    end
+  end
+
+  describe "#run" do
+    before :each do
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"view all\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_view_all"), :headers => {})
+      @client = TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+    end
+
+    it "should parse the query, execute it and return the results" do
+      result = @client.run("view all")
+      expect(result.size).to eq(4)
+    end
+  end
+
+end

data/spec/lib/todoist_querynaut/parser_spec.rb

@@ -0,0 +1,207 @@
+require "spec_helper"
+
+describe "#parse" do
+  describe "query literals" do
+    it "should parse 'today'" do
+      tree = TodoistQuerynaut::Parser.parse("today")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+
+    it "should ignore trailing whitespace" do
+      tree = TodoistQuerynaut::Parser.parse("today  ")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+
+    it "should ignore leading whitespace" do
+      tree = TodoistQuerynaut::Parser.parse("  today")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+
+    it "should parse 'tomorrow'" do
+      tree = TodoistQuerynaut::Parser.parse("tomorrow")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+
+    it "should parse 'overdue'" do
+      tree = TodoistQuerynaut::Parser.parse("overdue")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+
+    it "should parse 'over due'" do
+      tree = TodoistQuerynaut::Parser.parse("over due")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+
+    it "should parse 'view all'" do
+      tree = TodoistQuerynaut::Parser.parse("view all")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+  end
+
+  describe "negated queries" do
+    it "should parse '!today'" do
+      tree = TodoistQuerynaut::Parser.parse("!today")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::NegatedQuery)
+      expect(tree.query).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+    end
+  end
+
+  describe "n-days queries" do
+    it "should parse '4 days'" do
+      tree = TodoistQuerynaut::Parser.parse("4 days")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::NDaysQuery)
+      expect(tree.value).to eq(4)
+    end
+
+    it "should parse '23 days'" do
+      tree = TodoistQuerynaut::Parser.parse("23 days")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::NDaysQuery)
+      expect(tree.value).to eq(23)
+    end
+
+    it "should parse '42   days'" do
+      tree = TodoistQuerynaut::Parser.parse("42   days")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::NDaysQuery)
+      expect(tree.value).to eq(42)
+    end
+  end
+
+  describe "priority queries" do
+    it "should parse 'p1'" do
+      tree = TodoistQuerynaut::Parser.parse("p1")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::PriorityQuery)
+      expect(tree.value).to eq(1)
+    end
+
+    it "should parse 'priority 3'" do
+      tree = TodoistQuerynaut::Parser.parse("priority 3")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::PriorityQuery)
+      expect(tree.value).to eq(3)
+    end
+
+    it "should parse 'priority   2'" do
+      tree = TodoistQuerynaut::Parser.parse("priority   2")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::PriorityQuery)
+      expect(tree.value).to eq(2)
+    end
+  end
+
+  describe "project name queries" do
+    it "should parse 'p:foo'" do
+      tree = TodoistQuerynaut::Parser.parse("p:foo")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::ProjectNameQuery)
+      expect(tree.value).to eq("foo")
+    end
+
+    it "should parse 'p:some_long_project23'" do
+      tree = TodoistQuerynaut::Parser.parse("p:some_long_project23")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::ProjectNameQuery)
+      expect(tree.value).to eq("some_long_project23")
+    end
+  end
+
+  describe "label queries" do
+    it "should parse '@foo'" do
+      tree = TodoistQuerynaut::Parser.parse("@foo")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+      expect(tree.value).to eq("@foo")
+    end
+
+    it "should parse '@rspec'" do
+      tree = TodoistQuerynaut::Parser.parse("@rspec")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+      expect(tree.value).to eq("@rspec")
+    end
+
+    it "should parse 'no labels'" do
+      tree = TodoistQuerynaut::Parser.parse("no labels")
+      expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::NoLabelsQuery)
+    end
+  end
+
+  describe "logical operations" do
+    describe "intersections" do
+      it "should support intersections of two labels'" do
+        tree = TodoistQuerynaut::Parser.parse("@foo & @bar")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Intersection)
+        expect(tree.children[0]).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+        expect(tree.children[0].value).to eq("@foo")
+        expect(tree.children[1]).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+        expect(tree.children[1].value).to eq("@bar")
+      end
+
+      it "should support intersections of two different query parts'" do
+        tree = TodoistQuerynaut::Parser.parse("p4 & today")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Intersection)
+        expect(tree.children.size).to eq(2)
+        expect(tree.children[0]).to be_a(TodoistQuerynaut::TodoistQuery::PriorityQuery)
+        expect(tree.children[0].value).to eq(4)
+        expect(tree.children[1]).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+        expect(tree.children[1].value).to eq("today")
+      end
+
+
+      it "should support intersections of multiple parts" do
+        tree = TodoistQuerynaut::Parser.parse("@foo & @bar & @here & @there")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Intersection)
+        expect(tree.children.size).to eq(4)
+        tree.children.each { |node| expect(node).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery) }
+      end
+    end
+
+    describe "unions" do
+      it "should support unions of two labels'" do
+        tree = TodoistQuerynaut::Parser.parse("@foo | @bar")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Union)
+        expect(tree.children[0]).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+        expect(tree.children[0].value).to eq("@foo")
+        expect(tree.children[1]).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+        expect(tree.children[1].value).to eq("@bar")
+      end
+
+      it "should support unions of two different query parts'" do
+        tree = TodoistQuerynaut::Parser.parse("p4 | today")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Union)
+        expect(tree.children.size).to eq(2)
+        expect(tree.children[0]).to be_a(TodoistQuerynaut::TodoistQuery::PriorityQuery)
+        expect(tree.children[0].value).to eq(4)
+        expect(tree.children[1]).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery)
+        expect(tree.children[1].value).to eq("today")
+      end
+
+      it "should support unions of multiple parts" do
+        tree = TodoistQuerynaut::Parser.parse("@foo | @bar | @here | @there")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Union)
+        expect(tree.children.size).to eq(4)
+        tree.children.each { |node| expect(node).to be_a(TodoistQuerynaut::TodoistQuery::LiteralQuery) }
+      end
+    end
+
+    describe "operator precedence" do
+      it "should give higher precedence to intersection" do
+        tree = TodoistQuerynaut::Parser.parse("p1 & p1 | p4")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Union)
+        expect(tree.children[0]).to be_a(TodoistQuerynaut::TodoistQuery::Intersection)
+      end
+
+      it "should give higher precedence to intersection (2)" do
+        tree = TodoistQuerynaut::Parser.parse("p4 | p1 & p1")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Union)
+        expect(tree.children[1]).to be_a(TodoistQuerynaut::TodoistQuery::Intersection)
+      end
+
+      it "should give even higher precedence to parentheses" do
+        tree = TodoistQuerynaut::Parser.parse("p1 & (p1 | p4)")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Intersection)
+        expect(tree.children[1]).to be_a(TodoistQuerynaut::TodoistQuery::Union)
+      end
+
+      it "should give even higher precedence to parentheses (2)" do
+        tree = TodoistQuerynaut::Parser.parse("(p1 | p4) & p2")
+        expect(tree).to be_a(TodoistQuerynaut::TodoistQuery::Intersection)
+        expect(tree.children[0]).to be_a(TodoistQuerynaut::TodoistQuery::Union)
+      end
+    end
+
+  end
+end

data/spec/lib/todoist_querynaut/todoist_query/intersection_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe TodoistQuerynaut::TodoistQuery::Intersection do
+  describe "#run_query" do
+    it "should return items of 'today' for 'today & today'" do
+      intersection_query = TodoistQuerynaut::TodoistQuery::Intersection.new("today&today", 0...13, [
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("today", 0...5),
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("today", 0...5)
+      ])
+
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"today\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_today"), :headers => {})
+      result = intersection_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(1)
+    end
+
+    it "should run both queries and return the intersection" do
+      intersection_query = TodoistQuerynaut::TodoistQuery::Intersection.new("overdue & overdue_one", 0...21, [
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("overdue", 0...7),
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("overdue_one", 0...11)
+      ])
+
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"overdue_one\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_overdue_one"), :headers => {})
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"overdue\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_overdue"), :headers => {})
+      result = intersection_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(1)
+      expect(result[0]["content"]).to eq("overdue_two")
+    end
+  end
+end

data/spec/lib/todoist_querynaut/todoist_query/literal_query_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe TodoistQuerynaut::TodoistQuery::LiteralQuery do
+  describe "#value" do
+    it "should return the literal query string 'today'" do
+      literal_query = TodoistQuerynaut::TodoistQuery::LiteralQuery.new("today", 0...5)
+      expect(literal_query.value).to eq("today")
+    end
+
+    it "should return the literal query string 'overdue'" do
+      literal_query = TodoistQuerynaut::TodoistQuery::LiteralQuery.new("overdue", 0...7)
+      expect(literal_query.value).to eq("overdue")
+    end
+  end
+
+  describe "#run_query" do
+    it "should run a 'today' query" do
+      literal_query = TodoistQuerynaut::TodoistQuery::LiteralQuery.new("today", 0...5)
+
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"today\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_today"), :headers => {})
+      result = literal_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(1)
+      expect(result[0]["content"]).to eq("query_today_item_content")
+    end
+
+    it "should run a 'overdue' query" do
+      literal_query = TodoistQuerynaut::TodoistQuery::LiteralQuery.new("overdue", 0...7)
+
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"overdue\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_overdue"), :headers => {})
+      result = literal_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(2)
+      expect(result[0]["content"]).to eq("overdue_one")
+      expect(result[1]["content"]).to eq("overdue_two")
+    end
+  end
+end

data/spec/lib/todoist_querynaut/todoist_query/negated_query_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe TodoistQuerynaut::TodoistQuery::NegatedQuery do
+  describe "#run_query" do
+    it "should negate a 'today' query" do
+      negated_query = TodoistQuerynaut::Parser.parse("!today")
+
+      # will run two queries: today and "view all"
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"today\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_today"), :headers => {})
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"view all\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_view_all"), :headers => {})
+      result = negated_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      # all items (4) excluding today (1)  --> 3
+      expect(result.size).to eq(3)
+    end
+  end
+end
+

data/spec/lib/todoist_querynaut/todoist_query/priority_query_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe TodoistQuerynaut::TodoistQuery::PriorityQuery do
+  describe "#value" do
+    it "should return the priority of query string 'p4'" do
+      priority_query = TodoistQuerynaut::TodoistQuery::PriorityQuery.new("p4", 0...2)
+      expect(priority_query.value).to eq(4)
+    end
+
+    it "should return the priority of query string 'priority 3'" do
+      priority_query = TodoistQuerynaut::TodoistQuery::PriorityQuery.new("priority 3", 0...10)
+      expect(priority_query.value).to eq(3)
+    end
+  end
+
+  describe "#run_query" do
+    it "should run a 'p4' query" do
+      priority_query = TodoistQuerynaut::TodoistQuery::PriorityQuery.new("p4", 0...2)
+
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"p4\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_p4"), :headers => {})
+      result = priority_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(1)
+      expect(result[0]["content"]).to eq("weekly_p4_item")
+    end
+  end
+end
+

data/spec/lib/todoist_querynaut/todoist_query/project_name_query_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe TodoistQuerynaut::TodoistQuery::ProjectNameQuery do
+  describe "#value" do
+    it "should return the project name (foo) of query string 'p:foo'" do
+      project_name_query = TodoistQuerynaut::TodoistQuery::ProjectNameQuery.new("p:foo", 0...5)
+      expect(project_name_query.value).to eq("foo")
+    end
+
+    it "should return the project name (blarg) of query string 'p:blarg'" do
+      project_name_query = TodoistQuerynaut::TodoistQuery::ProjectNameQuery.new("p:blarg", 0...7)
+      expect(project_name_query.value).to eq("blarg")
+    end
+  end
+
+  describe "#run_query" do
+    before :each do
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"view all\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_view_all"), :headers => {})
+      stub_request(:post, "https://todoist.com/API/v6/sync").
+        with(:body => { "seq_no" => "0", "seq_no_global" => "0", "resource_types" => '["projects"]', "token" => "some_token" }).
+        to_return(:status => 200, :body => json_response_raw("sync_projects_all"), :headers => {})
+    end
+
+    it "should run a 'p:Inbox' query" do
+      project_name_query = TodoistQuerynaut::TodoistQuery::ProjectNameQuery.new("p:Inbox", 0...7)
+      result = project_name_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(1)
+      expect(result[0]["content"]).to eq("query_today_item_content")
+    end
+
+    it "should match project names without case-sensitivity" do
+      project_name_query = TodoistQuerynaut::TodoistQuery::ProjectNameQuery.new("p:INBoX", 0...7)
+      result = project_name_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(1)
+      expect(result[0]["content"]).to eq("query_today_item_content")
+    end
+  end
+end
+
+

data/spec/lib/todoist_querynaut/todoist_query/union_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe TodoistQuerynaut::TodoistQuery::Union do
+  describe "#run_query" do
+    it "should run both queries and return the union" do
+      union_query = TodoistQuerynaut::TodoistQuery::Union.new("today|overdue", 0...13, [
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("today", 0...5),
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("overdue", 0...7)
+      ])
+
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"today\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_today"), :headers => {})
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"overdue\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_overdue"), :headers => {})
+      result = union_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(3)
+    end
+
+    it "should remove duplicate items" do
+      union_query = TodoistQuerynaut::TodoistQuery::Union.new("today|overdue", 0...13, [
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("today", 0...5),
+        TodoistQuerynaut::TodoistQuery::LiteralQuery.new("today", 0...5),
+      ])
+
+      stub_request(:post, "https://todoist.com/API/v6/query").
+        with(:body => {"queries" => "[\"today\"]", "token" => "some_token"}).
+        to_return(:status => 200, :body => json_response_raw("query_today"), :headers => {})
+      result = union_query.run_query TodoistQuerynaut::Client.new(Todoist::Client.new("some_token"))
+
+      expect(result.size).to eq(1)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "todoist_querynaut"
+
+require "webmock/rspec"
+WebMock.disable_net_connect!
+
+def json_response_raw(fixture_name)
+  File.read(File.join(__dir__, "lib/todoist_querynaut/fixtures/#{fixture_name}.json"))
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: todoist_querynaut
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stefan Siegl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: ruby-todoist-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Todoist implements its filter and query language client side, this Gem
+  reimplements the language features against Todoist's REST API.
+email:
+- stesie@brokenpipe.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/todoist_querynaut.rb
+- lib/todoist_querynaut/client.rb
+- lib/todoist_querynaut/parser.rb
+- lib/todoist_querynaut/project_not_found_error.rb
+- lib/todoist_querynaut/todoist_query/node_extensions.rb
+- lib/todoist_querynaut/todoist_query_parser.treetop
+- spec/lib/todoist_querynaut/client_spec.rb
+- spec/lib/todoist_querynaut/parser_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/intersection_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/literal_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/negated_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/priority_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/project_name_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/union_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/stesie/todoist_querynaut
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Todoist Query Language implementation
+test_files:
+- spec/lib/todoist_querynaut/todoist_query/literal_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/priority_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/union_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/project_name_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/negated_query_spec.rb
+- spec/lib/todoist_querynaut/todoist_query/intersection_spec.rb
+- spec/lib/todoist_querynaut/parser_spec.rb
+- spec/lib/todoist_querynaut/client_spec.rb
+- spec/spec_helper.rb