taggata 0.0.2 → 0.1.0

data/lib/taggata/parser/query.rb

@@ -1,7 +1,14 @@
 module Taggata
   module Parser
     class Query
-      def self.parse(query)
+
+      attr_reader :db
+
+      def initialize(db)
+        @db = db
+      end
+
+      def parse(query)
         process(postfix(query))
       end
 
@@ -11,21 +18,26 @@ module Taggata
       #
       # @param token String the terminal token to resolve
       # @result [::Taggata::File] list of files with this tag
-      def self.resolve(token)
+      def resolve(token)
         type, name = token.split(':', 2)
         case type.downcase
         when 'is', 'tag'
-          ::Taggata::Tag.files(:name => name)
+          tag = ::Taggata::Persistent::Tag.find_one(db, :name => name)
+          tag.nil? ? [] : tag.files
+        when 'like'
+          files = ::Taggata::Persistent::File.find(db, Sequel.like(:name, name))
         when 'file', 'name'
-          File.all.select { |f| f.name[/#{name}/] }
+        #   File.all.select { |f| f.name[/#{name}/] }
+          files = ::Taggata::Persistent::File.find(db, {})
+          files.select { |f| f.name[/#{name}/] }
         when 'path'
-          File.all.select { |f| f.path[/#{name}/] }
+          files = ::Taggata::Persistent::File.find(db, {})
+          files.select { |f| f.path[/#{name}/] }
         when 'missing'
-          ::Taggata::Tag.files(:name => MISSING_TAG_NAME)
+          tag = ::Taggata::Persistent::Tag.find_or_create(db, :name => MISSING_TAG_NAME)
+          tag.files
         when 'untagged'
-          ids = File.map(:id)
-                .select { |id| DB[:file_tags].where(:file_id => id).empty? }
-          File.where(:id => ids).all
+          db.find_untagged_files
         else
           fail "Unknown token type '#{type}'"
         end
@@ -35,7 +47,7 @@ module Taggata
       #
       # @param postfix [String] the input in postfix notation as array
       # @return [::Taggata::File]
-      def self.process(postfix)
+      def process(postfix)
         stack = []
         postfix.each do |token|
           if operator? token
@@ -55,7 +67,7 @@ module Taggata
       # @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)
+      def apply(operator, op_A, op_B)
         case operator
         when :and
           op_A & op_B
@@ -70,7 +82,7 @@ module Taggata
       #
       # @param query String the query string
       # @result [String] query in postfix notation as an array
-      def self.postfix(query)
+      def postfix(query)
         postfix = []
         operators = []
         query.split.each do |token|
@@ -93,7 +105,7 @@ module Taggata
       #
       # @param token String
       # @result the token
-      def self.translate(token)
+      def translate(token)
         return :and if ['and', '&'].include? token.downcase
         return :or if ['or', '|'].include? token.downcase
         token
@@ -103,7 +115,7 @@ module Taggata
       #
       # @param token String
       # @result true/false
-      def self.operator?(token)
+      def operator?(token)
         ['&', '|', 'or', 'and', '(', :and, :or].include? token.downcase
       end
     end

data/lib/taggata/parser/tag.rb

@@ -1,31 +1,37 @@
 module Taggata
   module Parser
     class Tag
+
+      attr_reader :db
+
+      def initialize(db)
+        @db = db
+      end
+
       # Parses give tagging string
       #
       # @param query String tagging string
       # @return [Hash]
-      def self.parse(query)
+      def 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
+        dels = hash[:del].empty? ? [] : ::Taggata::Persistent::Tag.find(db, :name => hash[:del])
         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).map(:name)
-        ::Taggata::Tag
-          .dataset
-          .multi_insert((names - in_db).map { |name| { :name => name } })
-        ::Taggata::Tag.where(:name => names).all
+      def find_tags(names)
+        in_db = ::Taggata::Persistent::Tag.find(db, :name => names).map(&:name)
+        values = (names - in_db).map { |name| { :name => name } }
+        ::Taggata::Persistent::Tag.bulk_insert(db, values)
+        ::Taggata::Persistent::Tag.find(db, :name => names)
       end
 
-      def self.handle_tag(tag, result)
+      def handle_tag(tag, result)
         if tag.start_with?('-')
           result[:del] << tag[1..-1]
         elsif tag.start_with?('+')

data/lib/taggata/persistent.rb

@@ -0,0 +1,10 @@
+module Taggata
+  module Persistent
+    require 'taggata/persistent/abstract'
+    require 'taggata/persistent/with_parent'
+    require 'taggata/persistent/directory'
+    require 'taggata/persistent/file'
+    require 'taggata/persistent/tag'
+    require 'taggata/persistent/file_tag'
+  end
+end

data/lib/taggata/persistent/abstract.rb

@@ -0,0 +1,53 @@
+module Taggata
+  module Persistent
+    class Abstract
+
+      def save
+        @id ||= db.save(self)
+      end
+
+      def self.destroy(db, options)
+        db.destroy(self, options)
+      end
+
+      def destroy(options = {})
+        db.destroy(self.class, self.to_hash)
+      end
+
+      def self.find_one(db, options)
+        db.find_one(self, options)
+      end
+
+      def self.bulk_insert(db, values)
+        db.bulk_insert(self, values)
+      end
+
+      def self.find(db, options)
+        db.find(self, options)
+      end
+
+      def self.find_or_create(db, options)
+        db.find_or_create(self, options)
+      end
+
+      def invalidate_cache
+      end
+
+      def to_hash
+        raise NotImplementedError
+      end
+
+      def self.new_from_hash(db, hash)
+        raise NotImplementedError
+      end
+
+      def self.table
+        raise NotImplementedError
+      end
+
+      def show(indent = 0)
+      end
+
+    end
+  end
+end

data/lib/taggata/persistent/directory.rb

@@ -0,0 +1,80 @@
+module Taggata
+  module Persistent
+    class Directory < Abstract
+
+      include ::Taggata::Persistent::WithParent
+
+      attr_reader :db, :name, :parent_id, :id
+
+      def initialize(db, name, parent_id = nil, id = nil)
+        @db = db
+        @name = name
+        @parent_id = parent_id
+        @id = id
+      end
+
+      def self.table
+        :taggata_directories
+      end
+
+      def to_hash
+        {
+          :name => name,
+          :parent_id => parent_id,
+          :id => id
+        }
+      end
+
+      def self.new_from_hash(db, hash)
+        self.new(db,
+                 hash[:name],
+                 hash[:parent_id],
+                 hash[:id])
+      end
+
+      def show(indent = 0)
+        indent.times { print "  " }
+        puts "+ #{self.name}"
+        entries.each { |e| e.show(indent + 1) }
+      end
+
+      def directories
+        @child_directories ||= db.find_child_directories(self)
+      end
+
+      def files
+        @child_files ||= db.find_child_files(self)
+      end
+
+      def invalidate_cache
+        @child_directories = @child_files = nil
+      end
+
+      def entries
+        directories + files
+      end
+
+      # Scan children of this directory
+      def scan
+        scanner = ::Taggata::FilesystemScanner.new db
+        scanner.process(self)
+        validate
+      end
+
+      def validate
+        missing = ::Taggata::Persistent::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
+end

data/lib/taggata/persistent/file.rb

@@ -0,0 +1,99 @@
+module Taggata
+  module Persistent
+    class File < Abstract
+
+      include WithParent
+
+      attr_reader :db, :name, :parent_id, :id
+
+      def initialize(db, name, parent_id, id = nil)
+        @name = name
+        @db = db
+        @parent_id = parent_id
+        @id = id
+      end
+
+      def add_tags_by_name(*tag_names)
+        tag_records = nil
+        db.transaction do
+          tag_records = tag_names.map { |tag_name| ::Taggata::Persistent::Tag.find_or_create(db, :name => tag_name) }
+        end
+        add_tags(*tag_records)
+      end
+
+      def add_tags(*to_add)
+        current_tag_ids = tags.map(&:id)
+        missing_tag_ids = to_add.map(&:id) - current_tag_ids
+        return if missing_tag_ids.empty?
+        options = missing_tag_ids.map { |tag_id| { :file_id => id, :tag_id => tag_id } }
+        db.bulk_insert(FileTag, options)
+      end
+
+      def remove_tags(*to_remove)
+        return if to_remove.empty?
+        current_tag_ids = tags.map(&:id)
+        to_remove_ids = current_tag_ids - to_remove.map(&:id)
+        options = to_remove_ids.map { |tag_id| { :file_id => id, :tag_id => tag_id } }
+        db.destroy(FileTag, options)
+      end
+
+      def remove_tags_by_name(*tag_names)
+        tags = tag_names.map { |tag_name| Tag.find_or_create db, :name => tag_name }
+        remove_tags(*tags)
+      end
+
+      def destroy
+        file_tags.each(&:destroy)
+        super
+      end
+
+      def file_tags
+        ::Taggata::Persistent::FileTag.find(db, :file_id => id)
+      end
+
+      def tags
+        file_tags.map(&:tag)
+      end
+
+      def to_hash
+        {
+          :name => name,
+          :id => id,
+          :parent_id => parent_id
+        }
+      end
+
+      def self.new_from_hash(db, hash)
+        self.new(db,
+                 hash[:name],
+                 hash[:parent_id],
+                 hash[:id])
+      end
+
+      def self.table
+        :taggata_files
+      end
+
+      def show(indent = 0)
+        indent.times { print "  " }
+        puts "- #{self.name}"
+      end
+
+      def path
+        ::File.join(parent.path, name)
+      end
+
+    end
+  end
+end
+
+#     def before_destroy
+#       remove_all_tags
+#     end
+#
+#     # Gets full path of the file
+#     #
+#     # @return String full path of the file
+
+#   end
+# end

data/lib/taggata/persistent/file_tag.rb

@@ -0,0 +1,48 @@
+module Taggata
+  module Persistent
+    class FileTag < Abstract
+
+      attr_reader :db, :file_id, :tag_id
+
+      def initialize(db, file_id, tag_id)
+        @file_id = file_id
+        @tag_id = tag_id
+        @db = db
+      end
+
+      def self.table
+        :taggata_file_tags
+      end
+
+      def file
+        ::Taggata::Persistent::File.find_one(db, :id => file_id)
+      end
+
+      def tag
+        ::Taggata::Persistent::Tag.find_one(db, :id => tag_id)
+      end
+
+      def to_hash
+        {
+          :file_id => file_id,
+          :tag_id => tag_id
+        }
+      end
+
+      def self.new_from_hash(db, hash)
+        self.new(db,
+                 hash[:file_id],
+                 hash[:tag_id])
+      end
+
+      private
+
+      def self.file_tags_hashes(tags, files)
+        file_tags = tags.map do |tag|
+          files.map { |file| { :file_id => file.id, :tag_id => tag.id } }
+        end.flatten
+      end
+
+    end
+  end
+end

data/lib/taggata/persistent/tag.rb

@@ -0,0 +1,40 @@
+module Taggata
+  module Persistent
+    class Tag < Abstract
+
+      attr_reader :db, :name, :id
+
+      def initialize(db, name, id = nil)
+        @db = db
+        @name = name
+        @id = id
+      end
+
+      def files
+        file_tags.map { |file_tag| file_tag.file }
+      end
+
+      def file_tags
+        FileTag.find(db, :tag_id => id)
+      end
+
+      def to_hash
+        {
+          :name => name,
+          :id => id
+        }
+      end
+
+      def self.new_from_hash(db, hash)
+        self.new(db,
+                 hash[:name],
+                 hash[:id])
+      end
+
+      def self.table
+        :taggata_tags
+      end
+
+    end
+  end
+end