dircat 0.1.12 → 0.2.0

data/lib/simple_cataloger_dm/core.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+#
+# std lib
+#
+require 'pp'
+require 'optparse'
+require 'fileutils'
+require 'ostruct'
+
+#
+# rubygems
+#
+gem "treevisitor", "0.2.2"
+require 'treevisitor'
+
+gem "optparse-command", "0.1.7"
+require 'optparse-command'
+
+require 'dm-core'
+require 'dm-migrations'
+
+#
+# simple catalog
+#
+require 'simple_cataloger/version'
+require 'simple_cataloger/simple_cataloger_error'
+require 'simple_cataloger/extensions'
+
+#
+# db models
+#
+require 'simple_cataloger/models/item'
+require 'simple_cataloger/models/tag'
+require 'simple_cataloger/models/tagging'
+require 'simple_cataloger/models/category'
+require 'simple_cataloger/models/image'
+
+#
+# app
+#
+require 'simple_cataloger/directory_visitor'
+require 'simple_cataloger/catalog'
+

data/lib/simple_cataloger_dm/core/catalog.rb

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+module SimpleCataloger
+  class Catalog
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+
+      # find directory where to store catalog data
+      home_dir = ENV['HOME'] || ENV['APPDATA']
+      if RUBY_PLATFORM =~ /linux/
+        catalogs_dir = File.expand_path(File.join(home_dir, ".simple_cataloger"))
+      else
+        catalogs_dir = File.expand_path(File.join(home_dir, "simple_cataloger"))
+      end
+      Dir.mkdir(catalogs_dir) unless File.directory?(catalogs_dir)
+
+      db_filepath = File.join(catalogs_dir, "#{name}.sqlite3")
+      db_log_filepath = File.join(catalogs_dir, "#{name}.log")
+      @config_filepath = File.join(catalogs_dir, "#{name}.yml")
+      setup_db(db_filepath, db_log_filepath)
+    end
+
+    #
+    # Create a new catalog
+    # @param array of directories
+    #
+    def create(*catalog_roots)
+      if File.exist? @config_filepath
+        raise SimpleCatalogerError, "cannot create already existent catalog '#{@name}'"
+      end
+      @config = {
+          :roots => catalog_roots,
+          :ignore => ['sub', 'subtitles', 'images'],
+          :version => SimpleCataloger::VERSION
+      }
+      write_config
+      update
+    end
+
+    #
+    # Rebuild catalog
+    #
+    def update
+      unless File.exist? @config_filepath
+        raise "cannot update catalog #{@name}"
+      end
+      read_config
+      #
+      # migrate db
+      #
+      DataMapper.auto_migrate!
+      #DataMapper.auto_upgrade!
+
+      #
+      # Initialize categories
+      #
+      if @config[:categories]
+        # pp @config[:categories]
+        @config[:categories].each_pair do |category, tags|
+          # puts category
+          cat = Category.first_or_create(:name => category)
+          tags.each do |name|
+            tag = Tag.first_or_create(:name => name)
+            tag.category = cat
+            tag.save
+          end
+        end
+      end
+
+      #
+      # read catalog root
+      #
+      @config[:roots].each do |root|
+        dtw = TreeRb::DirTreeWalker.new(root)
+        dtw.ignore /^\./
+        @config[:ignore].each do |i|
+          dtw.ignore i
+        end
+        dtw.visit_file=true
+        dtw.run(DirectoryVisitor.new(root))
+      end
+
+      #
+      # cache rating tag
+      #
+      rating = Category.first(:name => "rating")
+      if rating
+        Item.all.each do |item|
+          t = item.tags.find { |t| t.category == rating }
+          if t
+            item.rating = t.name.to_i
+            item.save
+          end
+        end
+      end
+    end
+
+    def setup_db(db_path, db_log_filepath)
+      #TODO: logger usabile per loggare altri eventi oltre a quelli del db
+      DataMapper::Logger.new(db_log_filepath, :debug)
+      DataMapper.setup(:default, "sqlite3:#{db_path}")
+      DataMapper.finalize
+    end
+
+    #
+    # array of roots
+    #
+    def roots
+      read_config unless @config
+      @config[:roots]
+    end
+
+    #
+    # update config file with tag category list and association from category to tag name,
+    # so to not lose the association next time the catalog is rebuilt (updated)
+    #
+    def update_categories
+      h = {}
+      Category.all.each do |category|
+        next if ["rating", "year", "unknown"].include?(category.name)
+        h[category.name] = category.tags.collect { |tag| tag.name }
+      end
+      @config[:categories] = h
+    end
+
+    def write_config
+      File.open(@config_filepath, "w") { |f| f.write @config.to_yaml }
+    end
+
+    private
+
+    def read_config
+      #noinspection RubyResolve
+      @config = YAML.load(File.open(@config_filepath))
+    end
+
+  end # class
+
+end # module SimpleCatalog

data/lib/simple_cataloger_dm/core/directory_visitor.rb

@@ -0,0 +1,107 @@
+module SimpleCataloger
+
+  #
+  # Find directory without subdirectories
+  #
+  class DirectoryVisitor
+
+    def initialize(catalog_root)
+      super
+      @stack        = []
+      @files        = []
+      @nr           = 0
+      @catalog_root = catalog_root
+    end
+
+    def enter_node(pathname)
+      # each directory is associated to a number,
+      # so when exit_tree_node is called and the number @nr is not increased
+      # the directory doesn't have subdirectories
+      @nr     += 1
+
+      dirname = File.basename(pathname)
+      tags    = Tag.extract_tags(dirname)
+      tags = tags.concat(@stack.last.tags).uniq unless @stack.empty?
+      info   = OpenStruct.new(:nr => @nr, :pathname => pathname, :tags => tags, :name => Tag.extract_name(dirname))
+
+      @files = []
+      @stack.push(info)
+    end
+
+    def exit_node(pathname)
+      info = @stack.pop
+
+      if info.nr == @nr
+        # this directory doesn't have subdirectories
+        name    = info.name
+        tag_names    = info.tags
+        puts name
+        # pp tags
+
+        # every name must be unique, two films cannot have the some name
+        if Item.first( :name => name )
+          raise "item #{name} is not unique path #{pathname}"
+        end
+
+        item    = Item.create(
+            :name                   => name,
+            :added_at               => File.lstat(pathname).ctime,
+            :path                   => pathname,
+            :path_from_catalog_root => pathname[File.dirname(@catalog_root).length..-1]
+        )
+
+        #
+        # Associate item and tags
+        #
+        unknown = Category.first_or_create(:name => "unknown")
+        tag_names.each do |tag_name|
+          tag = Tag.first(:name => tag_name)
+          unless tag
+            tag = Tag.match_category(tag_name)
+            unless tag
+              tag = Tag.first_or_create(
+                  :name     => tag_name,
+                  :category => unknown
+              )
+            end
+          end
+          Tagging.first_or_create(:item=>item, :tag=> tag)
+        end
+
+        #
+        # Searches images
+        #
+        @files.each do |pathname|
+          next unless pathname.match /(jpg|jpeg)$/
+
+          image = Image.first_or_create(
+              :path                   => pathname,
+              :path_from_catalog_root => pathname[File.dirname(@catalog_root).length..-1]
+          )
+          item.images << image
+
+          filename = File.basename(pathname)
+          tag_names     = Tag.extract_tags(filename)
+          tag_names.each do |tag_name|
+            tag = Tag.first(:name => tag_name)
+            if tag
+              tag.images << image
+              tag.save
+            else
+              puts "WARNING: tag '#{tag_name}' not found"
+            end
+          end
+        end
+        item.save
+      end
+    end
+
+
+    #
+    # called when visit leaf node
+    #
+    def visit_leaf(pathname)
+      @files << pathname
+    end
+  end # class
+end # module SimpleCataloger

data/lib/simple_cataloger_dm/core/extensions.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+module SimpleCataloger
+  module CoreExtensions
+    module Array
+      def extract_options!
+        last.is_a?(::Hash) ? pop : {}
+      end
+    end
+  end
+end
+
+class Array
+  include SimpleCataloger::CoreExtensions::Array
+end
+
+module URI
+  class << self
+
+    def parse_with_safety(uri)
+      parse_without_safety uri.gsub('[', '%5B').gsub(']', '%5D')
+    end
+
+    # alias parse_without_safety parse
+    # alias parse parse_with_safety
+  end
+end

data/lib/simple_cataloger_dm/core/simple_cataloger_error.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+module SimpleCataloger
+  class SimpleCatalogerError < StandardError
+    def initialize(msg)
+      super
+    end
+  end
+end

data/lib/simple_cataloger_dm/models/category.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+module SimpleCataloger
+
+  class Category
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :name, String
+
+    has n, :tags, :order => [:name]
+
+    def self.order_by_name
+      all(:order => [:name])
+    end
+
+    def items
+      tags.collect { |t| t.items }.flatten
+    end
+  end
+
+end

data/lib/simple_cataloger_dm/models/image.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+module SimpleCataloger
+
+  class Image
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :path, String
+    property :path_from_catalog_root, String
+
+    belongs_to :item, :required => false
+    belongs_to :tag, :required => false
+
+    def to_json(*a)
+      {:item => if item then
+                  item.name
+                else
+                  nil
+                end,
+       :tag  => if tag then
+                  tag.name
+                else
+                  nil
+                end,
+       :src  => path_from_catalog_root}.to_json(*a)
+    end
+
+  end
+
+end

data/lib/simple_cataloger_dm/models/item.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+module SimpleCataloger
+
+  class Item
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+
+    property :added_at, Date
+    property :path, String
+    property :path_from_catalog_root, String
+    property :rating, Integer
+    property :flagged_at, Date
+
+    has n, :taggings
+    has n, :tags, :through => :taggings
+    has n, :images
+
+    def to_s
+      @name
+    end
+  end
+
+end

data/lib/simple_cataloger_dm/models/tag.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+module SimpleCataloger
+
+  class Tag
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :name, String
+
+    belongs_to :category, 'Category', :child_key => [:category_id]
+    has n, :taggings
+    has n, :items, :through => :taggings, :order => [:name]
+    has n, :images
+
+    ##################################################
+    #
+
+    RE_TAG = /\[([^\]]+)\]/
+
+    # extracts tags from directory or file name
+    def self.extract_tags(dir_or_file_name)
+      tags       = []
+      match_data = dir_or_file_name.match(RE_TAG)
+      while match_data
+        tags << match_data[1]
+        match_data = dir_or_file_name.match(RE_TAG, match_data.end(0))
+      end
+      tags
+    end
+
+    def self.extract_name(dir_or_file_name)
+      dir_or_file_name.gsub(Tag::RE_TAG, '').strip
+    end
+
+    RE_RATING = /^\d$/
+    RE_YEAR   = /^\d\d\d\d$/
+
+    MATCHES   = [
+        [RE_RATING, "rating", proc { |tag_name| tag_name.to_i }],
+        [RE_YEAR, "year", proc { |tag_name| tag_name.to_i }]
+    ]
+
+    #
+    # decode standard tags
+    #
+    def self.match_category(tag_name)
+      MATCHES.each do |re, category_name, convert|
+        if re.match tag_name
+          category = Category.first_or_create(:name => category_name)
+          tag      = Tag.first_or_create(
+              :name     => convert.call(tag_name),
+              :category => category
+          )
+          return tag
+        end
+      end
+      nil
+    end
+
+  end # class Tag
+
+end # module SimpleCatalog