taggata 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af1fd56a3c40bf5cae4dd502103e294280763987
-  data.tar.gz: f8f7b604307f9ce1402a5b73989475be2778ab45
+  metadata.gz: 316d77bbeae3f1cb3224e6a8c5e7a0e35398be06
+  data.tar.gz: 847538ab0379d0a7db9d1470c6e04d9257190af5
 SHA512:
-  metadata.gz: fce98df89bbb25cbe946517853ef9b675b12687071538c246bad6c6ae165697d65ecac7458e997699d2d6668d6a67c9b2d959748fd7e9b56012347c49dec23bd
-  data.tar.gz: cc2c1d8091c499072ebc92c0c7616626f96fd2eb83700ac92467126591a10587f31e2ae6efdcbf182be980ff786a350bc7b3c2148d5334577aeed24fb6b440fa
+  metadata.gz: d648822f874cf532bd2976541cfb790b4ab104a388c8d30424e83d34baa78cf47a13144874968a2fe4da249dc712e570d36116e9363be4b685a19920c5f3c6d5
+  data.tar.gz: f49c703ac45544a2d3e6c5103aa226c98557c1f08f5984baf505cdfb3217d1340565c543b5cf22b422e1419296cf329678ac810c1ec7e4c9a71b7b39e209cb6b

data/README.md

@@ -1,4 +1,4 @@
-# Taggata [![Build Status](https://travis-ci.org/adamruzicka/regren.svg?branch=master)](https://travis-ci.org/adamruzicka/regren)
+# Taggata [![Build Status](https://travis-ci.org/adamruzicka/taggata.svg?branch=master)](https://travis-ci.org/adamruzicka/taggata)
 
 Ruby gem for file tagging, it can:
 - scan filesystem and store metadata in database
@@ -14,28 +14,28 @@ Clone this repository:
 And then execute:
 
     $ bundle install
-    
+
 ## Usage
 Scan filesystem:
 
-    $ taggata $DATABASE scan $PATH_TO_SCAN
-    
+    $ taggata --db-path $DATABASE scan $PATH_TO_SCAN
+
 Search for entries:
-    
-    $ taggata $DATABASE search "$SEARCH_QUERY"
-    
+
+    $ taggata --db-path $DATABASE search "$SEARCH_QUERY"
+
 Get count of matching entries:
-    
-    $ taggata $DATABASE count "$SEARCH_QUERY"
-    
+
+    $ taggata --db-path $DATABASE -c search "$SEARCH_QUERY"
+
 Tag an entry:
 
-    $ taggata $DATABASE tag "$SEARCH_QUERY" "$TAG_QUERY"
+    $ taggata --db-path $DATABASE tag "$SEARCH_QUERY" "$TAG_QUERY"
+
+Remove files matching a query:
 
-Remove files matchine query:
+    $ taggata --db-path $DATABASE remove "$SEARCH_QUERY"
 
-    $ taggata $DATABASE remove "$SEARCH_QUERY"
-    
 Query formats:
 Search query has format of "$TYPE:$PARAMETER", where:
 - $TYPE can be one of:
@@ -62,7 +62,7 @@ For example to tag all untagged files containing ```Photos``` in path with tags
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/taggata/fork )
+1. Fork it ( https://github.com/adamruzicka/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`)

data/bin/taggata

@@ -1,47 +1,4 @@
 #!/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
-  primary_key [:tag_id, :file_id], :name => :file_tags_pk, :unique => true
-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|
-    deletions = tag_hash[:del].map { |tag| [file.id, tag.id] }
-    DB[:file_tags].where([:file_id, :tag_id] => deletions).delete
-  end.flatten 1
-  additions = result.map do |file|
-    adds = tag_hash[:add].map { |tag| [file.id, tag.id] }
-    in_db = DB[:file_tags].where([:file_id, :tag_id] => adds).map([:file_id, :tag_id])
-    (adds - in_db).map { |file_id, tag_id| { :file_id => file_id, :tag_id => tag_id } }
-  end.flatten
-  DB[:file_tags].multi_insert(additions)
-when 'remove'
-  files = ::Taggata::Parser::Query.parse(ARGV[2])
-  files.each(&:destroy)
-when 'count'
-  puts ::Taggata::Parser::Query.parse(ARGV[2]).count
-end
+require 'taggata/cli'
+include Taggata::Cli

data/lib/taggata.rb

@@ -3,9 +3,9 @@ require 'sequel'
 
 module Taggata
   require 'taggata/constants'
-  require 'taggata/file'
-  require 'taggata/directory'
-  require 'taggata/tag'
-  require 'taggata/filesystem_scanner'
+  require 'taggata/persistent'
+  require 'taggata/db'
+  require 'taggata/db_adapters'
+  require 'taggata/scanner'
   require 'taggata/parser'
 end

data/lib/taggata/cli.rb

@@ -0,0 +1,102 @@
+require 'clamp'
+require 'taggata'
+
+module Taggata
+  module Cli
+    Clamp do
+
+      option "--db-path", "DB_PATH", "path to the DB", :attribute_name => :db, :required => true do |db_path|
+        Taggata::Db.new "sqlite://#{db_path}", Taggata::DbAdapters::Sequel
+      end
+      option ['-v', '--verbose'], :flag, 'be verbose', :default => false
+      option ['-q', '--quiet'], :flag, 'be quite', :default => false
+
+      subcommand "scan", "Scan the system" do
+
+        parameter "[ROOT]", "the root of the scanned tree", :attribute_name => :root_path, :default => './'
+
+        def execute
+          scanner = Taggata::Scanner.new db
+          root = Taggata::Persistent::Directory.find_or_create db, :name => root_path
+          scanner.process(root)
+        end
+
+      end
+
+      subcommand 'tag', 'tag a file matching query' do
+
+        parameter 'TAG_QUERY', 'the tag query', :attribute_name => :tag_query, :required => true
+        parameter 'SEARCH_QUERY', 'the query to search', :attribute_name => :search_query, :required => true
+
+        def execute
+          tags = ::Taggata::Parser::Tag.new(db).parse(tag_query)
+          files = ::Taggata::Parser::Query.new(db).parse(search_query)
+          db.transaction do
+            files.each do |file|
+              file.add_tags *tags[:add]
+              file.remove_tags *tags[:del]
+            end
+          end
+        end
+
+      end
+
+      subcommand 'search', "search the database" do
+
+        option "-c", :flag, 'show only matched count', :attribute_name => :count, :default => false
+        option "-n", :flag, 'show only names without paths', :attribute_name => :names, :default => false
+        parameter "QUERY", 'the query to perform', :attribute_name => :query, :required => true
+
+        def execute
+          results = ::Taggata::Parser::Query.new(db).parse(query)
+          if count?
+            puts results.count
+          else
+            if results.empty?
+              puts "No results matching the query."
+            else
+              method = names? ? :name : :path
+              results.each { |file| puts file.send(method) }
+            end
+          end
+        end
+
+      end
+
+      subcommand 'remove', 'remove files matching query' do
+
+        parameter "QUERY", 'the query to perform', :attribute_name => :query, :required => true
+
+        def execute
+          parser = ::Taggata::Parser::Query.new db
+          results = parser.parse query
+          db.transaction do
+            results.each(&:destroy)
+          end
+        end
+
+      end
+
+      subcommand 'list', 'list things in database' do
+
+        parameter 'TYPE', 'type of records to list, can be one of file, directory, tag', :attribute_name => :type, :required => true do |type|
+          signal_usage_error 'TYPE must be one of file, directory, tag' unless %(file directory tag).include? type
+          type.to_sym
+        end
+
+        def execute
+          case type
+          when :file
+            db.find(Taggata::Persistent::File, {}).each { |file| puts file.path }
+          when :directory
+            db.find(Taggata::Persistent::Directory, {}).each { |dir| puts dir.path }
+          when :tag
+            db.find(Taggata::Persistent::Tag, {}).each { |tag| puts tag.name }
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/taggata/db.rb

@@ -0,0 +1,75 @@
+module Taggata
+  class Db
+
+    attr_reader :adapter
+
+    def initialize(db_path, adapter_class)
+      @adapter = adapter_class.new
+      @adapter.initialize_db db_path
+      @adapter.migrate_db
+    end
+
+    def transaction(&block)
+      if block_given?
+        adapter.transaction(block)
+      else
+        raise "Cannot initiate transaction without block."
+      end
+    end
+
+    def find_untagged_files
+      adapter.find_untagged_files.map { |hash| Persistent::File.new_from_hash self, hash }
+    end
+
+    def destroy(klass, options)
+      adapter.destroy(klass, options)
+    end
+
+    def bulk_insert(klass, values)
+      adapter.bulk_insert(klass, values)
+    end
+
+    def find(klass, options = {})
+      adapter.find(klass, options).map do |hash|
+        klass.new_from_hash self, hash
+      end
+    end
+
+    def find_one(klass, options = {})
+      record = adapter.find_one(klass, options)
+      klass.new_from_hash(self, record) unless record.nil?
+    end
+
+    def load(klass, id)
+      klass.new_from_hash(adapter.load(klass, id))
+    end
+
+    def find_or_create(klass, options)
+      search = adapter.find_one(klass, options)
+      if search.nil?
+        o = klass.new_from_hash self, options
+        o.save
+        o
+      else
+        klass.new_from_hash self, search
+      end
+    end
+
+    def save(object)
+      adapter.save(object.class.table, object.to_hash)
+    end
+
+    def find_child_directories(directory)
+      adapter.find(Persistent::Directory, :parent_id => directory.id).map do |hash|
+        Persistent::Directory.new_from_hash(self, hash)
+      end
+    end
+
+    def find_child_files(directory)
+      adapter.find(Persistent::File, :parent_id => directory.id) do |hash|
+        Persistent::File.new_from_hash(self, hash)
+      end
+    end
+
+  end
+end

data/lib/taggata/db_adapters.rb

@@ -0,0 +1,6 @@
+module Taggata
+  module DbAdapters
+    require 'taggata/db_adapters/abstract'
+    require 'taggata/db_adapters/sequel'
+  end
+end

data/lib/taggata/db_adapters/abstract.rb

@@ -0,0 +1,45 @@
+module Taggata
+  module DbAdapters
+    class Abstract
+
+      attr_reader :db
+
+      def bulk_insert(klass, values)
+        raise NotImplementedError
+      end
+
+      def find_untagged_files
+        raise NotImplementedError
+      end
+
+      def transaction(&block)
+        raise NotImplementedError
+      end
+
+      def destroy(klass, options)
+        raise NotImplementedError
+      end
+
+      def find_one(klass, options)
+        raise NotImplementedError
+      end
+
+      def find(klass, options)
+        raise NotImplementedError
+      end
+
+      def save(table, id)
+        raise NotImplementedError
+      end
+
+      def initialize_db(db_path)
+        raise NotImplementedError
+      end
+
+      def migrate_db
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/taggata/db_adapters/sequel.rb

@@ -0,0 +1,75 @@
+module Taggata
+  module DbAdapters
+
+    Sequel.extension :migration
+
+    class Sequel < Abstract
+
+      def bulk_insert(klass, values)
+        db[klass.table].multi_insert(values)
+      end
+
+      def transaction(block)
+        db.transaction do
+          block.call
+        end
+      end
+
+      def find_untagged_files
+        file_tags = db[Persistent::FileTag.table].select(:file_id).map { |hash| hash[:file_id] }
+        file_ids = db[Persistent::File.table].select(:id).map { |hash| hash[:id] }
+        untagged_ids = file_ids.reject { |id| file_tags.include? id }
+        find(Taggata::Persistent::File, :id => untagged_ids)
+      end
+
+      def destroy(klass, options)
+        db[klass.table].where(options).delete
+      end
+
+      def find(klass, options)
+        db[klass.table].where(options).all
+      end
+
+      def find_one(klass, options)
+        db[klass.table].where(options).limit(1).first
+      end
+
+      def search(klass, options)
+        db[klass.table].where(options)
+      end
+
+      def save(table, hash)
+        existing_record = db[table].where(primary_key(table, hash)).limit(1)
+        if existing_record.count == 0
+          db[table].insert(hash)
+        else
+          existing_record.update(hash)
+        end
+      end
+
+      def initialize_db(db_path)
+        @db = ::Sequel.connect db_path
+      end
+
+      def migrate_db
+        ::Sequel::Migrator.run(db, self.class.migrations_path, table: 'taggata_schema_info')
+      end
+
+      private
+
+      def primary_key(table, hash)
+        case table
+        when :taggata_file_tags
+          { :file_id => hash[:file_id], :tag_id => hash[:tag_id] }
+        else
+          { :id => hash[:id] }
+        end
+      end
+
+      def self.migrations_path
+        File.expand_path('../sequel_migrations', __FILE__)
+      end
+
+    end
+  end
+end

data/lib/taggata/db_adapters/sequel_migrations/001_initial.rb

@@ -0,0 +1,34 @@
+Sequel.migration do
+  up do
+    create_table(:taggata_directories) do
+      primary_key :id
+      column :name, String
+      foreign_key :parent_id, :taggata_directories, type: Integer
+    end
+
+    create_table(:taggata_files) do
+      primary_key :id
+      column :name, String
+      foreign_key :parent_id, :taggata_directories, type: Integer, :null => false
+    end
+
+    create_table(:taggata_tags) do
+      primary_key :id
+      column :name, String, unique: true
+    end
+
+    create_table(:taggata_file_tags) do
+      foreign_key :file_id, :taggata_files, type: Integer, null: false
+      foreign_key :tag_id, :taggata_tags, type: Integer, null: false
+      index [:file_id, :tag_id], unique: true
+      primary_key [:file_id, :tag_id]
+    end
+  end
+
+  down do
+    drop_table(:taggata_file_tags)
+    drop_table(:taggata_tags)
+    drop_table(:taggata_files)
+    drop_table(:taggata_directories)
+  end
+end