stickyflag 0.2.0

data/lib/stickyflag/database.rb

@@ -0,0 +1,162 @@
+# -*- encoding : utf-8 -*-
+require 'thread'
+require 'sequel'
+
+module StickyFlag
+  module Database
+    def load_database
+      @database.disconnect if @database
+      
+      if RUBY_PLATFORM == 'java'
+        @database = Sequel.connect("jdbc:sqlite:#{database_path}")
+      else
+        @database = Sequel.sqlite(:database => database_path)
+      end
+      raise Thor::Error.new("ERROR: Could not create database at '#{database_path}'") if @database.nil?
+      
+      create_tables
+      
+      # Do not do automatic cleanup from the RSpec test suite; this registers
+      # dozens of at_exit hooks and crashes Ruby
+      unless ENV['RSPEC_TESTING']
+        at_exit { @database.disconnect }
+      end
+    end
+  
+    def create_tables
+      @database.create_table?(:tag_list) do
+        primary_key :id, :type => Bignum
+        String :tag_name, :text => true
+      end
+      @database.create_table?(:file_list) do
+        primary_key :id, :type => Bignum
+        String :file_name, :text => true
+      end
+      @database.create_table?(:tagged_files) do
+        primary_key :id
+        Bignum :file
+        Bignum :tag
+      end
+    end
+  
+    def drop_tables
+      @database.drop_table(:tag_list, :file_list, :tagged_files)
+    end
+  
+    def get_tag_id(tag)
+      tag_id = @database[:tag_list].where(:tag_name => tag).get(:id)
+      unless tag_id
+        tag_id = @database[:tag_list].insert(:tag_name => tag)
+      end
+      
+      tag_id
+    end
+  
+    def get_file_id(file_name)
+      file_id = @database[:file_list].where(:file_name => file_name).get(:id)
+      unless file_id
+        file_id = @database[:file_list].insert(:file_name => file_name)
+      end
+    
+      file_id
+    end
+  
+    def update_database_from_files(directory = '.')
+      drop_tables
+      create_tables
+    
+      Dir.glob(File.join(directory, '**', "*{#{available_tagging_extensions.join(',')}}")).each do |file|
+        begin
+          tags = get_tags_for file
+        rescue Thor::Error
+          # Just skip this file, then, don't error out entirely
+          say_status :warning, "Could not read tags from '#{file}', despite a valid extension", :yellow
+          next
+        end
+        
+        # Don't record files in the DB that have no tags
+        next if tags.empty?
+      
+        file_id = get_file_id file      
+        tags.each do |tag|
+          tag_id = get_tag_id tag
+          @database[:tagged_files].insert(:file => file_id, :tag => tag_id)
+        end
+      end
+    end
+  
+    def set_database_tag(file_name, tag)
+      # Don't put in multiple entries for the same tag
+      file_id = get_file_id file_name
+      tag_id = get_tag_id tag
+      
+      return unless @database[:tagged_files].where(:file => file_id).and(:tag => tag_id).empty?
+      @database[:tagged_files].insert(:file => file_id, :tag => tag_id)
+    end
+  
+    def unset_database_tag(file_name, tag)
+      file_id = get_file_id file_name
+      tag_id = get_tag_id tag
+      @database[:tagged_files].where(:file => file_id).and(:tag => tag_id).delete
+    
+      # See if that was the last file with this tag, and delete it if so
+      if @database[:tagged_files].where(:tag => tag_id).empty?
+        @database[:tag_list].where(:id => tag_id).delete
+      end
+    end
+  
+    def clear_database_tags(file_name)
+      file_id = get_file_id file_name
+      @database[:tagged_files].where(:file => file_id).delete
+    
+      # That operation might have removed the last instance of a tag, clean up
+      # the tag list
+      @database[:tag_list].each do |row|
+        raise Thor::Error.new("INTERNAL ERROR: Database row error in tag_list") unless row.include? :id
+        tag_id = row[:id]
+        
+        if @database[:tagged_files].where(:tag => tag_id).empty?
+          @database[:tag_list].where(:id => tag_id).delete
+        end
+      end
+    end
+  
+    def files_for_tags(tags)
+      # Map tags to tag IDs, but don't add any missing tags
+      bad_tag = false
+      tag_ids = []
+      tags.each do |tag|
+        tag_id = @database[:tag_list].where(:tag_name => tag).get(:id)
+        unless tag_id
+          say_status :warning, "Tag '#{tag}' is not present in the database (try `stickyflag update`)", :yellow unless options.quiet?
+          bad_tag = true
+          next
+        end
+      
+        tag_ids << tag_id
+      end
+      return [] if bad_tag
+    
+      file_rows = @database[:tagged_files].where(:tag => tag_ids).group_by(:file).having{[[count(:*){}, tag_ids.count]]}
+      if file_rows.empty?
+        say_status :warning, "Requested combination of tags not found", :yellow unless options.quiet?
+        return []
+      end
+    
+      files = []
+      file_rows.each do |row|
+        file_id = row[:file]
+        file = @database[:file_list].where(:id => file_id).get(:file_name)
+        raise Thor::Error.new("ERROR: Could not get file_name for id saved in database (re-run `stickyflag update`)") unless file
+      
+        files << file
+      end
+    
+      files
+    end
+  
+    def tag_list
+      @database[:tag_list].map { |r| r[:tag_name] }
+    end
+  end
+end

data/lib/stickyflag/external_cmds.rb

@@ -0,0 +1,64 @@
+# -*- encoding : utf-8 -*-
+
+module StickyFlag
+  module ExternalCmds
+  
+    EXTERNAL_CMDS = {
+      'pdftk' => 'read and write PDF tags'
+    }
+  
+    def find_external_cmds
+      EXTERNAL_CMDS.each do |cmd, desc|
+        path = get_config "#{cmd}_path"
+      
+        # First, make sure that the listed file actually exists and is executable,
+        # so that if it isn't, we'll be able to fix it by checking $PATH down
+        # below.
+        unless path.nil? || path.empty?
+          unless File.executable? path
+            say_status :error, "Path set for #{cmd} is invalid", :red unless options.quiet?
+
+            path = ''
+            set_config "#{cmd}_path", ''
+            set_config "have_#{cmd}", false
+          else
+            # We do have this, make sure it's set that way
+            set_config "have_#{cmd}", true
+          end
+        end
+      
+        if path.nil? || path.empty?
+          # We don't have a path for this command, see if we can find it
+          found = which(cmd)
+          if found.nil?
+            say_status :warning, "Cannot find #{cmd} in path, will not be able to #{desc}", :yellow unless options.quiet?
+            set_config "have_#{cmd}", false
+            next
+          end
+        
+          # Okay, found it, set the configuration parameter
+          set_config "#{cmd}_path", found
+          set_config "have_#{cmd}", true
+        end
+      end
+    
+      # Save our results out to the configuration file
+      save_config!
+    end
+  
+    private
+  
+    # Thanks to mislav on Stack Overflow for this
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each { |ext|
+          exe = "#{path}#{File::SEPARATOR}#{cmd}#{ext}"
+          return exe if File.executable? exe
+        }
+      end
+      return nil
+    end
+    
+  end
+end

data/lib/stickyflag/patches/tempfile_encoding.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+require 'tempfile'
+
+class Tempfile
+  
+  unless Tempfile.respond_to?(:new_with_encoding)
+    def self.new_with_encoding(params)
+      # JRuby's Tempfile constructor got the third hash parameter in JRuby
+      # 1.7.0-preview1.
+      if RUBY_VERSION >= "1.9.0" && (RUBY_PLATFORM != 'java' || JRUBY_VERSION >= '1.7.0')
+        return Tempfile.new(params, Dir.tmpdir, :encoding => "UTF-8")
+      else
+        # No coverage on Ruby 1.8, ignore
+        #:nocov:
+        return Tempfile.new(params)
+        #:nocov:
+      end
+    end
+  end
+  
+end
+

data/lib/stickyflag/patches/tmpnam.rb

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+require 'tmpdir'
+
+class File
+  
+  unless File.respond_to?(:tmpnam)
+    def self.tmpnam(ext = '')
+      if ext != ''
+        if ext[0] != '.'
+          ext = ".#{ext}"
+        end
+      end
+    
+      pid = Process.pid
+      time = Time.now
+      sec = time.to_i
+      usec = time.usec
+    
+      counter = 0
+      path = File.join(Dir.tmpdir, "#{pid}_#{sec}_#{usec}_#{rand(1000)}#{ext}")
+    
+      # This is a corner case that should effectively never be possible, so
+      # don't try to cover it.
+      #:nocov:
+      while File.exist? path
+        sec = Time.now.to_i
+        usec = Time.now.usec
+        path = File.join(Dir.tmpdir, "#{pid}_#{sec}_#{usec}_#{rand(1000)}#{ext}")
+      
+        counter += 1
+        raise 'ERROR: Cannot get unique temporary name' if counter >= 100
+      end
+      #:nocov:
+    
+      path
+    end
+  end
+end

data/lib/stickyflag/paths.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+require 'rbconfig'
+require 'fileutils'
+
+module StickyFlag
+  module Paths
+    def config_path
+      # No code coverage: only ever runs one operating system branch
+      #:nocov:
+      case RbConfig::CONFIG['target_os']
+      when /darwin/i
+        root_dir = File.expand_path("~/Library/Application Support/StickyFlag")
+      when /linux/i
+        require 'xdg'
+        root_dir = File.join(XDG['CONFIG_HOME'].to_s, 'stickyflag')
+      when /mswin|mingw/i
+        root_dir = File.join(ENV['APPDATA'], 'StickyFlag')
+      else
+        root_dir = File.expand_path('~/.stickyflag')
+      end
+      #:nocov:
+      
+      FileUtils.mkdir_p root_dir
+      File.join(root_dir, 'config.yml')
+    end
+  
+    def database_path
+      # No code coverage: only ever runs one operating system branch
+      #:nocov:
+      case RbConfig::CONFIG['target_os']
+      when /darwin/i
+        root_dir = File.expand_path("~/Library/Application Support/StickyFlag")
+      when /linux/i
+        require 'xdg'
+        root_dir = File.join(XDG['DATA_HOME'].to_s, 'stickyflag')
+      when /mswin|mingw/i
+        root_dir = File.join(ENV['APPDATA'], 'StickyFlag')
+      else
+        root_dir = File.expand_path('~/.stickyflag')
+      end
+      #:nocov:
+    
+      FileUtils.mkdir_p root_dir
+      File.join(root_dir, 'db.sqlite')
+    end
+  end
+end

data/lib/stickyflag/tag_factory.rb

@@ -0,0 +1,108 @@
+# -*- encoding : utf-8 -*-
+require 'thor'
+require 'pathname'
+require 'backports'
+require 'stickyflag/tags/pdf'
+require 'stickyflag/tags/pdf'
+require 'stickyflag/tags/png'
+require 'stickyflag/tags/tex'
+require 'stickyflag/tags/c'
+require 'stickyflag/tags/mmd'
+
+module StickyFlag
+  module TagFactory
+    def available_tagging_extensions
+      ['.pdf', '.png', '.tex', '.c', '.cpp', '.cxx', '.c++',
+       '.h', '.hpp', '.hxx', '.mmd']
+    end
+  
+    def get_tags_for(file_name)
+      extension = File.extname file_name
+      case extension
+      when '.pdf' then return StickyFlag::Tags::PDF::get(file_name, get_config(:pdftk_path))
+      when '.png' then return StickyFlag::Tags::PNG::get(file_name)
+      when '.tex' then return StickyFlag::Tags::TeX::get(file_name)
+      when '.c' then return StickyFlag::Tags::C::get(file_name)
+      when '.cpp' then return StickyFlag::Tags::C::get(file_name)
+      when '.cxx' then return StickyFlag::Tags::C::get(file_name)
+      when '.c++' then return StickyFlag::Tags::C::get(file_name)
+      when '.h' then return StickyFlag::Tags::C::get(file_name)
+      when '.hpp' then return StickyFlag::Tags::C::get(file_name)
+      when '.hxx' then return StickyFlag::Tags::C::get(file_name)
+      when '.mmd' then return StickyFlag::Tags::MMD::get(file_name)
+      else raise Thor::Error.new("ERROR: Don't know how to get tags for a file of extension '#{extension}'")
+      end
+    end
+  
+    def set_tag_for(file_name, tag)
+      tags = get_tags_for file_name
+      if tags.include? tag
+        # Already set
+        return
+      end
+    
+      set_database_tag file_name, tag
+    
+      extension = File.extname file_name
+      case extension
+      when '.pdf' then return StickyFlag::Tags::PDF::set(file_name, tag, get_config(:pdftk_path))
+      when '.png' then return StickyFlag::Tags::PNG::set(file_name, tag)
+      when '.tex' then return StickyFlag::Tags::TeX::set(file_name, tag)
+      when '.c' then return StickyFlag::Tags::C::set(file_name, tag)
+      when '.cpp' then return StickyFlag::Tags::C::set(file_name, tag)
+      when '.cxx' then return StickyFlag::Tags::C::set(file_name, tag)
+      when '.c++' then return StickyFlag::Tags::C::set(file_name, tag)
+      when '.h' then return StickyFlag::Tags::C::set(file_name, tag)
+      when '.hpp' then return StickyFlag::Tags::C::set(file_name, tag)
+      when '.hxx' then return StickyFlag::Tags::C::set(file_name, tag)
+      when '.mmd' then return StickyFlag::Tags::MMD::set(file_name, tag)
+      else raise Thor::Error.new("ERROR: Don't know how to set tags for a file of extension '#{extension}'")
+      end
+    end
+  
+    def unset_tag_for(file_name, tag)
+      tags = get_tags_for file_name
+      unless tags.include? tag
+        raise Thor::Error.new("ERROR: Cannot unset tag #{tag} from file, not set")
+      end
+    
+      unset_database_tag file_name, tag
+    
+      extension = File.extname file_name
+      case extension
+      when '.pdf' then return StickyFlag::Tags::PDF::unset(file_name, tag, get_config(:pdftk_path))
+      when '.png' then return StickyFlag::Tags::PNG::unset(file_name, tag)
+      when '.tex' then return StickyFlag::Tags::TeX::unset(file_name, tag)
+      when '.c' then return StickyFlag::Tags::C::unset(file_name, tag)
+      when '.cpp' then return StickyFlag::Tags::C::unset(file_name, tag)
+      when '.cxx' then return StickyFlag::Tags::C::unset(file_name, tag)
+      when '.c++' then return StickyFlag::Tags::C::unset(file_name, tag)
+      when '.h' then return StickyFlag::Tags::C::unset(file_name, tag)
+      when '.hpp' then return StickyFlag::Tags::C::unset(file_name, tag)
+      when '.hxx' then return StickyFlag::Tags::C::unset(file_name, tag)
+      when '.mmd' then return StickyFlag::Tags::MMD::unset(file_name, tag)
+      else raise Thor::Error.new("ERROR: Don't know how to unset tags for a file of extension '#{extension}'")
+      end
+    end
+  
+    def clear_tags_for(file_name)
+      clear_database_tags file_name
+    
+      extension = File.extname file_name
+      case extension
+      when '.pdf' then return StickyFlag::Tags::PDF::clear(file_name, get_config(:pdftk_path))
+      when '.png' then return StickyFlag::Tags::PNG::clear(file_name)
+      when '.tex' then return StickyFlag::Tags::TeX::clear(file_name)
+      when '.c' then return StickyFlag::Tags::C::clear(file_name)
+      when '.cpp' then return StickyFlag::Tags::C::clear(file_name)
+      when '.cxx' then return StickyFlag::Tags::C::clear(file_name)
+      when '.c++' then return StickyFlag::Tags::C::clear(file_name)
+      when '.h' then return StickyFlag::Tags::C::clear(file_name)
+      when '.hpp' then return StickyFlag::Tags::C::clear(file_name)
+      when '.hxx' then return StickyFlag::Tags::C::clear(file_name)
+      when '.mmd' then return StickyFlag::Tags::MMD::clear(file_name)
+      else raise Thor::Error.new("ERROR: Don't know how to clear all tags for a file of extension '#{extension}'")
+      end
+    end
+  end
+end

data/lib/stickyflag/tags/c.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+require 'stickyflag/tags/source_code'
+
+module StickyFlag
+  module Tags
+    module C
+      module_function
+    
+      def comment_line_regex
+        /\A\/\/ .*/
+      end
+    
+      def tag_line_regex
+        /\A\/\/ SF_TAGS = (.*)/
+      end
+    
+      def tag_line_for(str)
+        "// SF_TAGS = #{str}"
+      end
+    
+      include StickyFlag::Tags::SourceCode
+      module_function :get, :set, :unset, :clear
+    end
+  end
+end

data/lib/stickyflag/tags/mmd.rb

@@ -0,0 +1,168 @@
+# -*- encoding : utf-8 -*-
+require 'stickyflag/patches/tmpnam.rb'
+
+module StickyFlag
+  module Tags
+    module MMD    
+      module_function
+    
+      # We duplicate the source-code module here because we want to have
+      # cute support for the indentation of tag contents in MMD, and because
+      # MMD metadata blocks have slightly weird syntax rules.
+    
+      def metadata_key_regex
+        /([A-Za-z0-9][A-Za-z0-9\-_ ]*):\s*(.*)/
+      end
+      def tag_line_regex
+        /[Tt]\s*[Aa]\s*[Gg]\s*[Ss]\s*:.*/
+      end
+    
+      def tag_line_for(tags, last_line = nil)
+        padding = ''
+      
+        if last_line
+          match = last_line.match(/([A-Za-z0-9][A-Za-z0-9\-_ ]*:\s*|\s*).*/)
+          if match
+            num = match[1].length - 'Tags: '.length
+            if num > 0
+              padding = ' ' * num
+            end
+          end
+        end
+      
+        "Tags: #{padding}#{tags.join(', ')}  "
+      end
+    
+      def write_tags(file_name, tags)
+        set_tags = false
+        eating_tags = false
+        last_line = ''
+        counter = 0
+
+        outpath = File.tmpnam
+        File.open(outpath, 'w:UTF-8') do |outfile|
+          File.open(file_name, 'r:UTF-8').each_line do |line|
+            if counter == 0
+              if line !~ metadata_key_regex
+                # If we're on the first line and there's no metadata at all,
+                # then we have to add a metadata block
+                outfile.puts tag_line_for(tags) if tags
+                outfile.puts ''
+                set_tags = true
+              end
+            else
+              # Not on the first line
+              if set_tags == true
+                # If we've already set tags, this is easy
+                outfile.puts line
+              else
+                # We're somewhere in the metadta, and we've yet to set any
+                # tags.
+                if line =~ tag_line_regex
+                  # We want to eat the tag block, which could theoretically
+                  # be extended onto multiple lines
+                  eating_tags = true
+                elsif eating_tags
+                  # We're currently eating tags; if this line is blank or a
+                  # key/value pair, we're done eating tags, time to print
+                  if line =~ metadata_key_regex || line.strip.empty?
+                    eating_tags = false
+                    outfile.puts tag_line_for(tags, last_line) if tags
+                    set_tags = true
+                  end
+                else
+                  # Not eating the tags key, just keep going, checking to see
+                  # if the metadata block is over
+                  if line.strip.empty?
+                    outfile.puts tag_line_for(tags, last_line) if tags
+                    set_tags = true
+                  end
+
+                  outfile.puts line
+                end
+              end
+            end
+          
+            counter += 1
+            last_line = line
+          end
+        end
+      
+        FileUtils.mv(outpath, file_name)
+      end
+    
+      def get(file_name)
+        counter = 0
+        key = ''
+        value = ''
+      
+        File.open(file_name, 'r:UTF-8').each_line do |line|
+          if counter == 0
+            # Check to see if there's any metadata at all
+            m = line.match(metadata_key_regex)
+            return [] unless m
+          
+            # Start capturing values
+            key = m[1]
+            value = m[2]
+          else
+            # Check to see if the metadata is over, or if there's another
+            # key/value pair starting on this line
+            m = line.match(metadata_key_regex)
+        
+            if m || line.strip.empty?
+              # We're done capturing this value, check if it's 'tags' (after
+              # removing whitespace and lowercasing, as per the spec)
+              key.gsub!(/\s/, '')
+              key.downcase!
+            
+              if key == 'tags'
+                return [] if value.nil? || value.empty?
+                return value.split(',').map { |t| t.empty? ? nil : t.strip }.compact
+              end
+            end
+        
+            # Quit if there's no more metadata
+            return if line.strip.empty?
+        
+            # Start grabbing a new key/value if there is one, or else just
+            # add to the current value
+            if m
+              key = m[1]
+              value = m[2]
+            else
+              # This doesn't strip the indentation off of the values, but
+              # that's okay, since we always strip whitespace off
+              # individual tags
+              value << line
+            end
+          end
+        
+          counter += 1
+        end
+      
+        []
+      end
+    
+      def set(file_name, tag)
+        tags = get(file_name)
+        return if tags.include? tag
+      
+        tags << tag
+        write_tags(file_name, tags)
+      end
+    
+      def unset(file_name, tag)
+        tags = get(file_name)
+        return unless tags.include? tag
+      
+        tags.delete(tag)
+        write_tags(file_name, tags)
+      end
+    
+      def clear(file_name)
+        write_tags(file_name, nil)
+      end
+    end
+  end
+end