taggata 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d7713cd81be332797275ebd869ea39818c825a8
+  data.tar.gz: 138c4eb01a7c07cad98c8522463474d912ab7023
+SHA512:
+  metadata.gz: 37a36288180cb07f9ba8889b77c2b3d54ef5ce6cffcba14d970caa6f4322a7410cd577427db3d76f5f13f21d4cbad44334b8c0d7d772999bcfb8c9870c47aecb
+  data.tar.gz: 6ec36c4c738c0265910a200428c6cdec2ccf7468cf2363677446c9ee7d37caed6ddba901a59c2106511676af136c79c25113ec2dfae15f69b667e97172575659

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+*.sqlite

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Style/HashSyntax:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Lint/UselessAccessModifier:
+  Enabled: false
+Style/RegexpLiteral:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+- 2.2.2
+- 2.1.6
+- 2.0.0
+- 1.9.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2015, Adam Ruzicka
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,69 @@
+# Taggata [![Build Status](https://travis-ci.org/adamruzicka/regren.svg?branch=master)](https://travis-ci.org/adamruzicka/regren)
+
+Ruby gem for file tagging, it can:
+- scan filesystem and store metadata in database
+- tag stored entries
+- lookup entries matching tag queries
+- add and remove tags from entries
+
+## Installation
+Clone this repository:
+
+    $ git clone https://github.com/adamruzicka/taggata.git
+
+And then execute:
+
+    $ bundle install
+    
+## Usage
+Scan filesystem:
+
+    $ taggata $DATABASE scan $PATH_TO_SCAN
+    
+Search for entries:
+    
+    $ taggata $DATABASE search "$SEARCH_QUERY"
+    
+Get count of matching entries:
+    
+    $ taggata $DATABASE count "$SEARCH_QUERY"
+    
+Tag an entry:
+
+    $ taggata $DATABASE tag "$SEARCH_QUERY" "$TAG_QUERY"
+
+Remove files matchine query:
+
+    $ taggata $DATABASE remove "$SEARCH_QUERY"
+    
+Query formats:
+Search query has format of "$TYPE:$PARAMETER", where:
+- $TYPE can be one of:
+  - ```is``` - searches for tag
+  - ```tag``` - the same as ```is```
+  - ```path``` - matches against absolute paths of files
+  - ```name``` - matches against name of the file
+- $PARAMETER
+  - for ```is``` and ```tag``` it is a string
+  - for ```path``` and ```name``` it is a regular expression
+- special cases
+  - ```missing``` - searches for files which are present in the database but not on filesystem
+  - ```untagged``` - searches for files without any tag
+
+The search queries can be combined by using operators ```and``` and ```or``` and parentheses.
+For example to get all files tagged as photos taken in year 2014 and 2015 one would issue:
+
+    $ taggata $DATABASE search "is:photo and ( is:2014 or is:2015 )"
+
+Tag query has format of ```+$TAG_NAME``` or ```-$TAG_NAME```, one can specify more in one query
+For example to tag all untagged files containing ```Photos``` in path with tags ```photo``` and ```to-backup``` one would issue:
+
+    $ taggata $DATABASE tag "untagged and path:Photos" "+photo +to-backup -default"
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/taggata/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/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => [:test]

data/bin/taggata

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'sequel'
+DB = Sequel.connect("sqlite://#{ARGV[0]}")
+
+DB.create_table :file_tags do
+  foreign_key :tag_id, :tags
+  foreign_key :file_id, :files
+end unless DB.table_exists? :file_tags
+
+Sequel::Model.plugin(:schema)
+
+require 'taggata'
+
+case ARGV[1]
+when 'scan'
+  root = ::Taggata::Directory.find_or_create(:name => ARGV[2])
+  root.scan
+when 'search'
+  result = ::Taggata::Parser::Query.parse(ARGV[2])
+  if result.empty?
+    puts "No files matching query '#{ARGV[2]}'"
+  else
+    result.each do |f|
+      puts f.path
+    end
+  end
+when 'tag'
+  result = ::Taggata::Parser::Query.parse(ARGV[2])
+  tag_hash = ::Taggata::Parser::Tag.parse(ARGV[3])
+  result.each do |file|
+    tag_hash[:del].each { |tag| file.remove_tag tag }
+    tag_hash[:add].each { |tag| file.add_tag tag }
+  end
+when 'remove'
+  files = ::Taggata::Parser::Query.parse(ARGV[2])
+  files.each(&:destroy)
+when 'count'
+  puts ::Taggata::Parser::Query.parse(ARGV[2]).count
+when 'pry'
+  require 'pry'; binding.pry
+end

data/lib/taggata.rb

@@ -0,0 +1,11 @@
+require 'taggata/version'
+require 'sequel'
+
+module Taggata
+  require 'taggata/constants'
+  require 'taggata/file'
+  require 'taggata/directory'
+  require 'taggata/tag'
+  require 'taggata/filesystem_scanner'
+  require 'taggata/parser'
+end

data/lib/taggata/constants.rb

@@ -0,0 +1,5 @@
+module Taggata
+  MISSING_TAG_NAME = '_MISSING'
+  DEFAULT_TAG_NAME = 'default'
+end
+

data/lib/taggata/directory.rb

@@ -0,0 +1,49 @@
+module Taggata
+  class Directory < Sequel::Model(:directories)
+    set_schema do
+      primary_key :id
+      String :name
+      foreign_key :parent_id, :directories
+    end
+
+    create_table unless table_exists?
+
+    one_to_many :directories,
+                :key => :parent_id,
+                :class => self
+
+    one_to_many :files,
+                :key => :parent_id,
+                :class => ::Taggata::File
+
+    many_to_one :parent,
+                :key => :parent_id,
+                :class => self
+
+    def entries
+      directories + files
+    end
+
+    # Scan children of this directory
+    def scan
+      scanner = ::Taggata::FilesystemScanner.new
+      scanner.process(self)
+      validate
+    end
+
+    def validate
+      missing = ::Taggata::Tag.find_or_create(:name => MISSING_TAG_NAME)
+      files.reject { |f| ::File.exist? f.path }.each { |f| f.add_tag missing }
+      directories.each(&:validate)
+    end
+
+    # Get full path of this directory
+    #
+    # @result full path of this directory
+    def path
+      parents = [self]
+      parents << parents.last.parent while parents.last.parent
+      ::File.join(parents.reverse.map(&:name))
+    end
+  end
+end

data/lib/taggata/file.rb

@@ -0,0 +1,33 @@
+module Taggata
+  class File < Sequel::Model(:files)
+    set_schema do
+      primary_key :id
+      String :name
+      foreign_key :parent_id, :directories, :on_delete => :set_null
+    end
+
+    def before_destroy
+      remove_all_tags
+    end
+
+    create_table unless table_exists?
+
+    require 'taggata/directory'
+
+    many_to_one :parent,
+                :key => :parent_id,
+                :class => ::Taggata::Directory
+
+    many_to_many :tags,
+                 :left_id => :file_id,
+                 :right_id => :tag_id,
+                 :join_table => :file_tags
+
+    # Gets full path of the file
+    #
+    # @return String full path of the file
+    def path
+      ::File.join(parent.path, name)
+    end
+  end
+end

data/lib/taggata/filesystem_scanner.rb

@@ -0,0 +1,72 @@
+module Taggata
+  class FilesystemScanner
+    # Initialize scanner's internal objects and default tag
+    def initialize
+      @jobs = []
+      @done_files = 0
+      @done_directories = 0
+    end
+
+    # Report progress
+    def report
+      print 'Done files/dirs - Queued: ',
+            "#{@done_files}/#{@done_directories} ",
+            "- #{@jobs.length}\n"
+    end
+
+    # Process directory at full path
+    #
+    # @param dir String name of the directory
+    # @param path String full path of the directory
+    def do_job(dir_id, path)
+      contents = Dir.glob("#{path}/*")
+                 .reduce(::Taggata::File => [],
+                         ::Taggata::Directory => []) do |acc, cur|
+        key = ::File.file?(cur) ? ::Taggata::File : ::Taggata::Directory
+        acc.merge(key => acc[key].push(cur))
+      end
+
+      contents.each_pair do |klass, files|
+        save_missing files.map { |f| ::File.basename f },
+                     dir_id,
+                     klass unless files.empty?
+      end
+      @done_files += contents[::Taggata::File].length
+      add_directory_jobs contents[::Taggata::Directory],
+                         dir_id unless contents[::Taggata::Directory].empty?
+      @done_directories += 1
+    end
+
+    def add_directory_jobs(dirs, parent_id)
+      ids = find_in_db ::Taggata::Directory,
+                       parent_id,
+                       dirs.map { |d| ::File.basename d },
+                       :id
+      ids.zip(dirs).each { |job| @jobs << job }
+    end
+
+    def save_missing(files, parent_id, klass)
+      in_db = find_in_db(klass, parent_id, files, :name)
+      to_save = (files - in_db).map do |basename|
+        { :name => basename, :parent_id => parent_id }
+      end
+      klass.dataset.multi_insert(to_save)
+    end
+
+    def find_in_db(klass, parent_id, names, param)
+      klass
+        .where(:parent_id => parent_id)
+        .where(:name => names)
+        .map(param)
+    end
+
+    # Breadth first search traversal through the filesystem tree
+    def process(dir)
+      @jobs << [dir.id, dir.name]
+      until @jobs.empty?
+        do_job(*@jobs.shift)
+        report
+      end
+    end
+  end
+end

data/lib/taggata/parser.rb

@@ -0,0 +1,4 @@
+module Taggata
+  require 'taggata/parser/tag'
+  require 'taggata/parser/query'
+end

data/lib/taggata/parser/query.rb

@@ -0,0 +1,111 @@
+module Taggata
+  module Parser
+    class Query
+      def self.parse(query)
+        process(postfix(query))
+      end
+
+      private
+
+      # Resolves a terminal to a value
+      #
+      # @param token String the terminal token to resolve
+      # @result [::Taggata::File] list of files with this tag
+      def self.resolve(token)
+        type, name = token.split(':', 2)
+        case type.downcase
+        when 'is', 'tag'
+          ::Taggata::Tag.files(:name => name)
+        when 'file', 'name'
+          File.all.select { |f| f.name[/#{name}/] }
+        when 'path'
+          File.all.select { |f| f.path[/#{name}/] }
+        when 'missing'
+          ::Taggata::Tag.files(:name => MISSING_TAG_NAME)
+        when 'untagged'
+          ids = File.map(:id)
+                .select { |id| DB[:file_tags].where(:file_id => id).empty? }
+          File.where(:id => ids).all
+        else
+          fail "Unknown token type '#{type}'"
+        end
+      end
+
+      # Evaluates the input
+      #
+      # @param postfix [String] the input in postfix notation as array
+      # @return [::Taggata::File]
+      def self.process(postfix)
+        stack = []
+        postfix.each do |token|
+          if operator? token
+            op_b = stack.pop
+            op_a = stack.pop
+            stack << apply(token, op_a, op_b)
+          else
+            stack << resolve(token)
+          end
+        end
+        stack.last
+      end
+
+      # Applies operator to operands op_A and op_B
+      #
+      # @param operator Symbol the operation(:and, :or) to apply to operands
+      # @param op_A [::Taggata::File] first operand
+      # @param op_B [::Taggata::File] second operand
+      # @result [::Taggata::File] result of applying operator to operands
+      def self.apply(operator, op_A, op_B)
+        case operator
+        when :and
+          op_A & op_B
+        when :or
+          op_A | op_B
+        else
+          fail "Unknown operator '#{operator}'"
+        end
+      end
+
+      # Converts string to postfix notation
+      #
+      # @param query String the query string
+      # @result [String] query in postfix notation as an array
+      def self.postfix(query)
+        postfix = []
+        operators = []
+        query.split.each do |token|
+          if operator? token
+            operators << translate(token)
+          elsif token == ')'
+            loop do
+              current = operators.pop
+              current == '(' ? break : postfix << current
+            end
+          else
+            postfix << token
+          end
+        end
+        operators.each { |op| postfix << op }
+        postfix
+      end
+
+      # Translates token to symbol or leaves it alone
+      #
+      # @param token String
+      # @result the token
+      def self.translate(token)
+        return :and if ['and', '&'].include? token.downcase
+        return :or if ['or', '|'].include? token.downcase
+        token
+      end
+
+      # Checks if token is an operator
+      #
+      # @param token String
+      # @result true/false
+      def self.operator?(token)
+        ['&', '|', 'or', 'and', '(', :and, :or].include? token.downcase
+      end
+    end
+  end
+end

data/lib/taggata/parser/tag.rb

@@ -0,0 +1,40 @@
+module Taggata
+  module Parser
+    class Tag
+      # Parses give tagging string
+      #
+      # @param query String tagging string
+      # @return [Hash]
+      def self.parse(query)
+        result = { :add => [], :del => [] }
+        hash = query.split.reduce(result) do |acc, tag|
+          handle_tag(tag, acc)
+        end
+        dels = hash[:del].empty? ? [] : ::Taggata::Tag.where(:name => hash[:del]).all
+        adds = hash[:add].empty? ? [] : find_tags(hash[:add])
+        { :add => adds, :del => dels }
+      end
+
+      private
+
+      def self.find_tags(names)
+        in_db = ::Taggata::Tag.where(:name => names).all
+        ::Taggata::Tag
+          .dataset
+          .multi_insert((names - in_db).map { |name| { :name => name } })
+        ::Taggata::Tag.where(:name => names).all
+      end
+
+      def self.handle_tag(tag, result)
+        if tag.start_with?('-')
+          result[:del] << tag[1..-1]
+        elsif tag.start_with?('+')
+          result[:add] << tag[1..-1]
+        else
+          fail "Unknown tag specifier '#{tag}'"
+        end
+        result
+      end
+    end
+  end
+end

data/lib/taggata/tag.rb

@@ -0,0 +1,20 @@
+module Taggata
+  class Tag < Sequel::Model
+    many_to_many :files,
+                 :left_id => :tag_id,
+                 :right_id => :file_id,
+                 :join_table => :file_tags
+
+    set_schema do
+      primary_key :id
+      String :name
+    end
+
+    create_table unless table_exists?
+
+    def self.files(query)
+      tag = find(query)
+      tag.nil? ? [] : tag.files
+    end
+  end
+end

data/lib/taggata/version.rb

@@ -0,0 +1,3 @@
+module Taggata
+  VERSION = '0.0.1'
+end

data/taggata.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'taggata/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'taggata'
+  spec.version       = Taggata::VERSION
+  spec.authors       = ['Adam Ruzicka']
+  spec.email         = ['a.ruzicka@outlook.com']
+  spec.summary       = 'Gem for scanning the filesystem and storing it in sqlite database with tagging'
+  # spec.summary       = %q{TODO: Write a short summary. Required.}
+  # spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.homepage      = 'https://github.com/adamruzicka/taggata'
+  spec.license       = 'BSD-2-Clause'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'sequel', '~> 4.22.0', '>= 4.22.0'
+  spec.add_dependency 'sqlite3', '~> 1.3.10', '>= 1.3.10'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.6.1', '>= 5.6.1'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.0.16', '>= 1.0.16'
+  spec.add_development_dependency 'mocha', '~> 1.1', '>= 1.1.0'
+  spec.add_development_dependency 'pry', '~> 0.1', '>= 0.0.1'
+  spec.add_development_dependency 'pry-coolline', '~> 0.1', '>= 0.0.1'
+
+end

data/test/filesystem_scanner_test.rb

@@ -0,0 +1,53 @@
+require 'taggata_test_helper'
+
+module Taggata
+  describe FilesystemScanner do
+    let(:workdir) { ::Dir.mktmpdir }
+    let(:scanner) { FilesystemScanner.new }
+    let(:root) { Directory.find_or_create(:name => workdir) }
+    let(:file) { mock }
+
+    before do
+      scanner.expects(:report)
+    end
+
+    after do
+      FileUtils.rm_rf workdir
+    end
+
+    it 'process creates initial job' do
+      root
+      scanner.expects(:do_job).with(root.id, root.name)
+      scanner.process(root)
+    end
+
+    it 'scans empty directory' do
+      scanner.expects(:save_missing).never
+      scanner.expects(:add_directory_jobs).never
+      scanner.process(root)
+    end
+
+    it 'scans directory with files' do
+      basenames = (1..5).map { |i| "file-#{i}" }
+      basenames.each do |name|
+        FileUtils.touch(::File.join(workdir, name))
+      end
+      scanner.expects(:save_missing).with(basenames, root.id, ::Taggata::File)
+      scanner.expects(:add_directory_jobs).never
+      scanner.process(root)
+    end
+
+    it 'scans subdirectories' do
+      basenames = (1..5).map { |i| "file-#{i}" }
+      subdir_path = ::File.join(workdir, 'subdir')
+      FileUtils.mkdir_p(subdir_path)
+      Directory.find_or_create(:name => 'subdir',
+                               :parent_id => root.id)
+      basenames.each do |name|
+        FileUtils.touch(::File.join(subdir_path, name))
+      end
+      scanner.expects(:add_directory_jobs).with([subdir_path], root.id)
+      scanner.process(root)
+    end
+  end
+end

data/test/parser/query_parser_test.rb

@@ -0,0 +1,51 @@
+require 'taggata_test_helper'
+
+module Taggata
+  module Parser
+    describe Query do
+      let(:parser) { ::Taggata::Parser::Query }
+
+      it 'translates' do
+        parser.send(:translate, '&').must_equal :and
+        parser.send(:translate, 'and').must_equal :and
+        parser.send(:translate, 'AND').must_equal :and
+        parser.send(:translate, '|').must_equal :or
+        parser.send(:translate, 'or').must_equal :or
+        parser.send(:translate, 'OR').must_equal :or
+        parser.send(:translate, 'asdasd').must_equal 'asdasd'
+      end
+
+      it 'applies' do
+        parser.apply(:and, [1, 2], [2, 3]).must_equal [2]
+        parser.apply(:or, [1, 2], [2, 3]).must_equal [1, 2, 3]
+        proc { parser.apply('q', [], []) }.must_raise RuntimeError
+      end
+
+      it 'converts to postfix' do
+        parser.send(:postfix, '').must_equal []
+        parser.send(:postfix, 'is:2014').must_equal ['is:2014']
+        parser.send(:postfix, 'is:2014 and tag:2015')
+          .must_equal ['is:2014', 'tag:2015', :and]
+        parser.send(:postfix, 'is:2014 or tag:2015')
+          .must_equal ['is:2014', 'tag:2015', :or]
+        parser.send(:postfix, 'is:2014 and ( is:2015 or is:2016 )')
+          .must_equal ['is:2014', 'is:2015', 'is:2016', :or, :and]
+      end
+
+      it 'return type is always an array' do
+        parser.send(:resolve, 'is:test').must_be_instance_of Array
+        parser.send(:resolve, 'tag:test').must_be_instance_of Array
+        parser.send(:resolve, 'file:test').must_be_instance_of Array
+        parser.send(:resolve, 'path:test').must_be_instance_of Array
+        parser.send(:resolve, 'untagged').must_be_instance_of Array
+        parser.send(:resolve, 'missing').must_be_instance_of Array
+      end
+
+      it 'tries to resolve the token' do
+        tag = mock.tap { |t| t.expects(:files).returns([1]) }
+        ::Taggata::Tag.expects(:find).with(:name => '2014').returns(tag)
+        parser.send(:resolve, 'is:2014').must_equal([1])
+      end
+    end
+  end
+end

data/test/parser/tag_parser_test.rb

@@ -0,0 +1,33 @@
+require 'taggata_test_helper'
+
+module Taggata
+  module Parser
+    describe Tag do
+      let(:parser) { ::Taggata::Parser::Tag }
+
+      after do
+        ::Taggata::Tag.each(&:destroy)
+      end
+
+      it 'parses' do
+        parsed = parser.parse('+tag1')
+        parsed[:add].length.must_equal 1
+        parsed[:add].first.name.must_equal 'tag1'
+        parsed = parser.parse('+tag2 -tag1')
+        parsed[:add].map(&:name).must_equal ['tag2']
+        parsed[:del].map(&:name).must_equal ['tag1']
+      end
+
+      it 'fails when no + or - is provided' do
+        proc { parser.parse('badtag') }.must_raise RuntimeError
+      end
+
+      it 'always returns a hash' do
+        parsed = parser.parse('+tag1 +tag2 -tag3 +tag4 -tag5')
+        parsed.must_be_instance_of Hash
+        parsed[:add].must_be_instance_of Array
+        parsed[:del].must_be_instance_of Array
+      end
+    end
+  end
+end

data/test/taggata_test_helper.rb

@@ -0,0 +1,13 @@
+require 'sequel'
+DB = Sequel.sqlite
+DB.create_table :file_tags do
+  foreign_key :tag_id, :tags
+  foreign_key :file_id, :files
+end unless DB.table_exists? :file_tags
+Sequel::Model.plugin(:schema)
+require 'taggata'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'fileutils'
+require 'mocha/mini_test'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: taggata
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Ruzicka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.22.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.22.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.22.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.22.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.6.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.6.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.6.1
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.16
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.16
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.16
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.16
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: pry-coolline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+description: 
+email:
+- a.ruzicka@outlook.com
+executables:
+- taggata
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/taggata
+- lib/taggata.rb
+- lib/taggata/constants.rb
+- lib/taggata/directory.rb
+- lib/taggata/file.rb
+- lib/taggata/filesystem_scanner.rb
+- lib/taggata/parser.rb
+- lib/taggata/parser/query.rb
+- lib/taggata/parser/tag.rb
+- lib/taggata/tag.rb
+- lib/taggata/version.rb
+- taggata.gemspec
+- test/filesystem_scanner_test.rb
+- test/parser/query_parser_test.rb
+- test/parser/tag_parser_test.rb
+- test/taggata_test_helper.rb
+homepage: https://github.com/adamruzicka/taggata
+licenses:
+- BSD-2-Clause
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Gem for scanning the filesystem and storing it in sqlite database with tagging
+test_files:
+- test/filesystem_scanner_test.rb
+- test/parser/query_parser_test.rb
+- test/parser/tag_parser_test.rb
+- test/taggata_test_helper.rb