conrad_filer 0.0.1

data/.project

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ConradFiler</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+	</natures>
+</projectDescription>

data/bin/conrad_filer.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'conrad_filer/cli'
+rescue LoadError
+  require 'rubygems'
+  require 'conrad_filer/cli'
+end
+
+cli = ConradFiler::CLI.new(ARGV)
+cli.run

data/lib/conrad_filer/cli.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+require 'conrad_filer/config'
+require 'inotify'
+
+module ConradFiler
+  
+  Thread.abort_on_exception = true
+
+  class CLI
+
+    def initialize(argv)
+      @file_data = Hash.new
+      @file_changes = Hash.new
+    end
+
+    def run
+      @config = ConradFiler::Config.new
+      @watch_jobs = @config.get_watch_jobs
+      @id_types = @config.get_id_types
+      @rules = @config.get_rules
+
+      # Go through each of the rules and add them to the watch jobs they are configured for
+      # (note: any watch jobs that are not assigned rules will be disabled later)
+      @rules.each_value do |rule|
+        rule.get_watch_job_names.each do |watch_job_name|
+          rule.get_id_type_names.each do |id_type_name|
+            # puts "#{rule.name} #{watch_job_name} #{id_type_name}"
+            watch_job = @watch_jobs[watch_job_name]
+            watch_job.add_rule(@id_types[id_type_name], rule)
+          end
+        end
+      end
+
+      # Start up each watch job in a thread that will monitor directories. If a change is detected matching the bitmask associated
+      # with the watch job, the rule will be asked to perform for each id type that matches the file associated with the event
+      @watch_jobs.each_pair do |name, watch_job|
+        if watch_job.is_valid?
+          watch_job.start_inotify_thread
+        else
+          @config.disable_watch_job(name) # if watch job is enabled but nobody is referencing it, disable it so next time we don't bother including it
+          @watch_jobs.delete(name)
+        end
+      end
+
+
+      # Now that we are monitoring live updates, its time to go hunt down changes since the last time the app was run and perform the rules
+      @watch_jobs.each_value do |watch_job|
+        # TODO: Tell the watch job to look for changes since last run
+        #watch_job.?????
+      end
+
+      # Scan the directories looking for changes since the app was last run
+
+      #DirMonitor.all_jobs(db) do |monitor_job|
+      #  @threads << Thread.new(polling_job) do |job|
+      #    cur_dir = job.directory
+      #    #Dir[job.].each do |filename|
+      #    fs = File::Stat.new(filename)
+      #  end
+      #end
+      #@threads.each {|thread| thread.join}
+
+      # Create a special watch job for the configuration file and db looking for changes
+      # by not spawning the thread, the app will continue running
+      self.create_config_watch_job.start_loop
+    end
+
+    # create a watch job to detect if the database or config file have changed (call on_config_file_changed if this happens)
+    def create_config_watch_job
+      config_watch = Inotify::InotifyThread.new
+      config_watch_bitmask = Inotify::InotifyBitmask.all_events
+      config_watch_bitmask.set_flag(:in_move_self)
+      config_watch_bitmask.set_flag(:in_delete_self)
+      config_watch_bitmask.set_flag(:in_modify)
+      #puts @config.cfg_filename
+      #puts config_watch_bitmask.as_array_of_symbols
+      config_watch.add_watch(@config.cfg_filename, config_watch_bitmask.bitmask, false)
+      config_watch.add_watch(@config.db_filename, config_watch_bitmask.bitmask, false)
+      config_watch.register_event(config_watch_bitmask.bitmask, &(self.method(:on_config_file_changed)))
+      config_watch
+    end
+
+    # ConradFilerApp.on_config_file_changed
+    # This is the callback which is called when the configuration changes
+    def on_config_file_changed(notify_event, path)
+      filename = path
+      if filename == File.expand_path(@config.cfg_filename)
+        print "config_file_changed - "
+      elsif filename == File.expand_path(@config.db_filename)
+        print "database updated - "
+      end
+      puts Inotify::InotifyBitmask.new(notify_event.mask).as_array_of_symbols
+    end
+  end
+
+end

data/lib/conrad_filer/config.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+require 'parseconfig'
+require 'conrad_filer/watch_job'
+require 'conrad_filer/id_type'
+require 'conrad_filer/rule'
+require 'conrad_filer/db'
+require 'inotify'
+
+module ConradFiler
+
+  class Config
+    attr_reader :cfg_filename
+    attr_reader :db_filename
+
+    # Register all tables referenced in this class so the database can be created if needed
+    ConradFiler::DB.register_table_definition("CREATE TABLE WATCH_JOBS (NAME TEXT, PATHNAME TEXT, BITMASK INTEGER, RECURSIVE TEXT, ENABLED TEXT)")
+    ConradFiler::DB.register_table_definition("CREATE TABLE ID_TYPES (NAME TEXT, MATCH_REGEXP TEXT, IGNORE_CASE TEXT)")
+    ConradFiler::DB.register_table_definition("CREATE TABLE RULES (NAME TEXT, DIRECTORY TEXT, RECURSIVE TEXT)")
+    ConradFiler::DB.register_table_definition("CREATE TABLE RULE_WATCH_JOBS (RULE TEXT, WATCH_JOB TEXT)")
+    ConradFiler::DB.register_table_definition("CREATE TABLE RULE_ID_TYPES (RULE TEXT, ID_TYPE TEXT)")
+
+
+    ## Register to create some data to play with when a new db is created
+    bitmask = Inotify::InotifyBitmask.all_events
+    bitmask.unset_flag(:in_close_nowrite)
+    bitmask.unset_flag(:in_open)
+    ConradFiler::DB.register_table_definition("INSERT INTO WATCH_JOBS (NAME,PATHNAME,BITMASK,RECURSIVE,ENABLED) VALUES ('WATCH_JOB','/home/jon/watch_job',#{bitmask.bitmask},'F','T')")
+    ConradFiler::DB.register_table_definition("INSERT INTO ID_TYPES (NAME,MATCH_REGEXP,IGNORE_CASE) VALUES ('ID_TYPE','.\\.MP3$','T')")
+    ConradFiler::DB.register_table_definition("INSERT INTO ID_TYPES (NAME,MATCH_REGEXP,IGNORE_CASE) VALUES ('ID_TYPE2','.\\.m4a$','T')")
+    ConradFiler::DB.register_table_definition("INSERT INTO RULES (NAME) VALUES ('RULE')")
+    ConradFiler::DB.register_table_definition("INSERT INTO RULE_WATCH_JOBS (RULE, WATCH_JOB) VALUES ('RULE', 'WATCH_JOB')")
+    ConradFiler::DB.register_table_definition("INSERT INTO RULE_ID_TYPES (RULE, ID_TYPE) VALUES ('RULE', 'ID_TYPE')")
+    ConradFiler::DB.register_table_definition("INSERT INTO RULE_ID_TYPES (RULE, ID_TYPE) VALUES ('RULE', 'ID_TYPE2')")
+
+
+    DEFAULT_CONFIG_FILENAME = '/etc/conrad_filer.conf'
+    #DEFAULT_DB_FILENAME = '/var/local/conrad_filer/conrad_filer.sdb'
+    DEFAULT_DB_FILENAME = 'conrad_filer.sdb'
+    #DEFAULT_LOG_FILENAME = '/var/local/conrad_filer/conrad_filer.log'
+    DEFAULT_LOG_FILENAME = 'conrad_filer.log'
+
+    def initialize(filename="")
+      @cfg_filename = filename
+      self.determine_file_locations
+      self.open_database
+    end
+
+    def determine_file_locations
+      @cfg_filename = DEFAULT_CONFIG_FILENAME if @cfg_filename.length == 0
+      @file_config = ParseConfig.new(@cfg_filename)
+      @db_filename = @file_config.get_value('database').to_s
+      @db_filename = DEFAULT_DB_FILENAME if @db_filename.length == 0
+      @log_filename = @file_config.get_value('logfile').to_s
+      @log_filename = DEFAULT_LOG_FILENAME if @log_filename.length == 0
+    end
+
+    def open_database
+      @db = ConradFiler::DB.new(@db_filename)
+      @db.open
+    end
+
+    def get_watch_jobs
+      objs = Hash.new
+      rows = @db.execute("SELECT * FROM WATCH_JOBS WHERE ENABLED = 'T'")
+      rows.each do |row|
+        obj = ConradFiler::WatchJob.new(@db, row)
+        objs[row['NAME']] = obj
+      end
+      objs
+    end
+
+    def disable_watch_job(watch_job_name)
+      @db.execute("UPDATE WATCH_JOBS SET ENABLED = 'F' WHERE NAME = '#{watch_job_name}'")
+    end
+
+    def get_id_types
+      objs = Hash.new
+      @db.execute("SELECT * FROM ID_TYPES").each do |row|
+        obj = ConradFiler::IdType.new(@db, row)
+        objs[row['NAME']] = obj
+      end
+      objs
+    end
+
+    def get_rules
+      objs = Hash.new
+      @db.execute("SELECT * FROM RULES").each do |row|
+        obj = ConradFiler::Rule.new(@db, row)
+        row['WATCH_JOBS'] = @db.execute_as_array("SELECT WATCH_JOB FROM RULE_WATCH_JOBS WHERE RULE = #{row['NAME']}")
+        row['ID_TYPES'] = @db.execute_as_array("SELECT ID_TYPE FROM RULE_ID_TYPES WHERE RULE = #{row['NAME']}")
+        objs[row['NAME']] = obj
+      end
+      objs
+    end
+
+  end
+
+end

data/lib/conrad_filer/db.rb

@@ -0,0 +1,87 @@
+include ObjectSpace
+require 'sqlite3'
+
+module ConradFiler
+
+  class DB
+   
+    @@table_defs = Array.new
+    @@table_defs << "CREATE TABLE DIR_INFO (DIR_NAME TEXT, DIR_HASH INTEGER, FULL_PATH TEXT)"
+
+    ## Class Methods ##
+
+    # Register the sql that will be called if the database needs to be created
+    def self.register_table_definition(sql)
+      @@table_defs << sql
+    end
+
+    # Finalizer definition for class instances (registered in ConradDB::open method if the database is successfully opened)
+    def self.finalize_instance(db)
+      proc { db.close }
+    end
+
+
+    ## Instance Methods ##
+
+    # Initialize the new instance
+    def initialize(filename)
+      @filename = filename
+    end
+
+    # Create the configuration database
+    def create
+      self.delete
+      @db = SQLite3::Database.new(@filename)
+      @@table_defs.each do |sql|
+        puts sql
+        @db.execute(sql)
+      end
+    end
+  
+    # Open the configuration database
+    def open
+      if File.exists?(@filename)
+        @db = SQLite3::Database.open(@filename)
+      else
+        self.create
+      end
+      @db.results_as_hash = true
+      # Register the finalizer to make sure the db connection is closed
+      ObjectSpace.define_finalizer(self, self.class.finalize_instance(@db))
+      self
+    end
+ 
+    # Execute the sql
+    def execute(sql)
+      @db.execute(sql)
+    end
+
+    # Execute the sql as normal, but return an array from the first column of the result set
+    def execute_as_array(sql)
+      return_array = Array.new
+      @db.results_as_hash = false
+        self.execute(sql).each do |rec|
+          return_array << rec[0]
+        end
+      @db.results_as_hash = true
+      return_array
+    end
+  
+    # Close the configuration database
+    def close
+      @db.close
+
+      # Unegister all finalizers since they are no longer needed
+      ObjectSpace.undefine_finalizer(self)
+    end
+
+    # Delete the configuration database
+    def delete
+      if File.exists?(@filename)
+         File.delete(@filename)
+      end
+    end
+ 
+  end
+
+end

data/lib/conrad_filer/db_objects.rb

@@ -0,0 +1,22 @@
+
+
+module ConradFiler
+  
+  class FileSystemEntry
+  class DBDir
+    puts "DBDir loading"
+    def initialize
+       @instvar
+      @@classvar
+    end
+     def self.from_path
+   end
+
+  class DBFile
+    puts "DBFile loading"
+    def initialize
+      @instvar
+      @@classvar
+    end  
+  end
+end

data/lib/conrad_filer/dir_polling_job.rb

@@ -0,0 +1,48 @@
+require 'conrad_filer/db'
+
+module ConradFiler
+
+  class DirPollingJob
+
+    ConradFiler::DB.register_table_definition("CREATE TABLE WATCH_LIST (DIRECTORY TEXT, GLOB TEXT, INC_SUBDIR TEXT, RECURSIVE TEXT)")
+
+    ## Class Methods ##
+    
+    def self.query
+      "SELECT DIRECTORY, GLOB, INC_SUBDIR, POLLING_DELAY FROM POLLING_JOBS"
+    end
+    
+    def self.all_jobs(db)
+      jobs = Array.new
+      db.execute(self.query) do |row|
+        jobs << self.new(row)
+      end
+      jobs
+    end
+    
+    
+    ## Instance Methods ##
+    
+    def initialize(an_array)
+      @rec = an_array
+    end
+    
+    def include_subdirs?
+      @rec[3] == "T"
+    end
+
+    def directory  
+      @rec[1]
+    end
+    
+    def glob
+      @rec[2]
+    end
+    
+    def perform
+      # Loop over all entries in the directory and collect the files and subdirectories
+    end
+    
+  end
+
+end

data/lib/conrad_filer/id_type.rb

@@ -0,0 +1,31 @@
+require 'conrad_filer/db'
+
+module ConradFiler
+
+  # An ID Type describes files in a directory using a regular expression.  It is used by a rule to define which file types the rule applies to.
+  class IdType
+
+    def initialize(db, a_hash)
+      @db_rec = a_hash
+    end
+    
+    def matches_pathname?(pathname)
+      pathname =~ self.get_regexp
+    end
+    
+    def match_regexp
+      @db_rec['MATCH_REGEXP']
+    end
+    
+    def ignore_case
+      @db_rec['IGNORE_CASE'][0,1].upcase == "T"
+    end
+    
+    def get_regexp
+      return @regexp if @regexp != nil
+      @regexp = Regexp.new(self.match_regexp, self.ignore_case)
+    end
+
+  end
+
+end

data/lib/conrad_filer/rule.rb

@@ -0,0 +1,37 @@
+require 'conrad_filer/db'
+require 'inotify'
+
+module ConradFiler
+
+  # A rule describes an action to perform on a file that matches one of its defined id types
+  class Rule
+
+    attr_accessor :db_rec
+
+    def initialize(db, a_hash)
+      @db_rec = a_hash
+    end
+
+    def get_watch_job_names
+      @db_rec['WATCH_JOBS']
+    end
+
+    def get_id_type_names
+      @db_rec['ID_TYPES']
+    end
+
+    def name
+      @db_rec['NAME']
+    end
+
+    def on_watch_event(watch_job, id_type, notify_event, path)
+      bitmask = Inotify::InotifyBitmask.new(notify_event.mask)
+      if notify_event.name.class == String
+        pathname = File.join(path, notify_event.name)
+      else
+        pathname = path
+      end
+      puts "[ConradRule::on_watch_event] '#{pathname}' #{bitmask.as_array_of_symbols}"
+    end
+  end
+end

data/lib/conrad_filer/version.rb

@@ -0,0 +1,3 @@
+module ConradFiler
+  VERSION = "0.0.1"
+end

data/lib/conrad_filer/watch_job.rb

@@ -0,0 +1,72 @@
+require 'conrad_filer/db'
+require 'inotify'
+
+module ConradFiler
+
+  # A watch job describes directories to monitor and includes a bitmask describing which actions to monitor
+  class WatchJob
+
+    def initialize(db, a_hash)
+      @db_rec = a_hash
+      @bitmask = Inotify::InotifyBitmask.new(@db_rec['BITMASK'])
+      @rules = Hash.new {Array.new}
+      @inotify_thread = Inotify::InotifyThread.new
+    end
+
+    def id_types
+      @rules.keys
+    end
+
+    def add_rule(id_type, rule)
+      @rules[id_type] = @rules[id_type] << rule
+    end
+
+    def recursive?
+      @db_rec['RECURSIVE'][0,1].upcase == "T"
+    end
+
+    def pathname
+      @db_rec['PATHNAME']
+    end
+
+    def bitmask
+      @bitmask.bitmask
+    end
+
+    def is_valid?
+      @rules.size > 0
+    end
+
+    def prepare_inotify_thread
+      @inotify_thread.add_watch(self.pathname, self.bitmask, self.recursive?)
+      @inotify_thread.register_event(self.bitmask, &(self.method(:process_event)))
+    end
+
+    def start_inotify_thread
+      self.prepare_inotify_thread
+      @inotify_thread.start_thread
+    end
+  
+    def start_inotify_loop
+      self.prepare_inotify_thread
+      @inotify_thread.start_loop
+    end
+
+    def process_event(notify_event, path)
+      bitmask = Inotify::InotifyBitmask.new(notify_event.mask)
+      puts "[ConradWatchJob::process_event] '#{path}/#{notify_event.name}' #{bitmask.as_array_of_symbols}"
+      @rules.each_pair do |id_type, rules_for_id_type|
+        if id_type.matches_pathname?(File.join(path,notify_event.name.to_s))
+          rules_for_id_type.each do |rule|
+            rule.on_watch_event(self, id_type, notify_event, path)
+          end
+        end
+      end
+    end
+
+    #def register_event(bitmask, &block)
+    #  @inotify_thread.register_event(bitmask, &block)
+    #end
+  end
+
+end

data/lib/conrad_filer.rb

@@ -0,0 +1,9 @@
+require 'conrad_filer/version'
+require 'conrad_filer/cli'
+require 'conrad_filer/config'
+require 'conrad_filer/db'
+require 'conrad_filer/id_type'
+require 'conrad_filer/rule'
+require 'conrad_filer/watch_job'
+require 'conrad_filer/db_objects'
+require 'conrad_filer/dir_polling_job'

data/lib/inotify/bitmask.rb

@@ -0,0 +1,96 @@
+require 'find'
+require 'inotify'
+
+module Inotify
+
+  class InotifyBitmask
+
+    @@symbols_and_bits = {
+      :in_access        =>  0,  0 => :in_access,	# File was accessed (read) (*)
+      :in_modify        =>  1,  1 => :in_modify,	# File was modified (*)
+      :in_attrib        =>  2,  2 => :in_attrib,	# Metadata changed (permissions, timestamps, extended attributes, etc.) (*)
+      :in_close_write   =>  3,  3 => :in_close_write,	# File opened for writing was closed (*)
+      :in_close_nowrite =>  4,  4 => :in_close_nowrite,	# File not opened for writing was closed (*)
+      :in_open          =>  5,  5 => :in_open,		# File was opened (*)
+      :in_moved_from    =>  6,  6 => :in_moved_from,	# File moved out of watched directory (*)
+      :in_moved_to      =>  7,  7 => :in_moved_to,	# File moved into watched directory (*)
+      :in_create        =>  8,  8 => :in_create,	# File/directory created in watched directory (*)
+      :in_delete        =>  9,  9 => :in_delete,	# File/directory deleted from watched directory (*)
+      :in_delete_self   => 10, 10 => :in_delete_self,	# Watched file/directory was itself deleted
+      :in_move_self     => 11, 11 => :in_move_self,	# Watched file/directory was itself moved
+      :in_unmount       => 13, 13 => :in_unmount,	# Backing fs was unmounted
+      :in_q_overflow    => 14, 14 => :in_q_overflow,	# Event queued overflowed
+      :in_ignored       => 15, 15 => :in_ignored,	# File was ignored
+      :in_mask_add      => 29, 29 => :in_mask_add,	# add to the mask of an already existing watch
+      :in_isdir         => 30, 30 => :in_isdir,		# event occurred against dir
+      :in_oneshot       => 31, 31 => :in_oneshot	# only send event once
+    }
+    @@symbols_to_masks = {
+      :in_access        => 0b00000000000000000000000000000001,
+      :in_modify        => 0b00000000000000000000000000000010,
+      :in_attrib        => 0b00000000000000000000000000000100,
+      :in_close_write   => 0b00000000000000000000000000001000,
+      :in_close_nowrite => 0b00000000000000000000000000010000,
+      :in_open          => 0b00000000000000000000000000100000,
+      :in_moved_from    => 0b00000000000000000000000001000000,
+      :in_moved_to      => 0b00000000000000000000000010000000,
+      :in_create        => 0b00000000000000000000000100000000,
+      :in_delete        => 0b00000000000000000000001000000000,
+      :in_delete_self   => 0b00000000000000000000010000000000,
+      :in_move_self     => 0b00000000000000000000100000000000,
+      :in_unmount       => 0b00000000000000000010000000000000,
+      :in_q_overflow    => 0b00000000000000000100000000000000,
+      :in_ignored       => 0b00000000000000001000000000000000,
+      :in_mask_add      => 0b00100000000000000000000000000000,
+      :in_isdir         => 0b01000000000000000000000000000000,
+      :in_oneshot       => 0b10000000000000000000000000000000
+    }
+
+    attr_reader :bitmask
+    @symbols
+ 
+    def self.all_events
+      inotify_bitmask = self.new(0b00000000000000000000111111111111)  # All standard events
+    end
+    def initialize(bitmask=0)
+      if bitmask.class == String
+        @bitmask = bitmask.to_i
+      else
+        @bitmask = bitmask
+      end
+    end
+    def set_flag(a_symbol)
+      @bitmask = @bitmask | @@symbols_to_masks[a_symbol]
+    end
+    def unset_flag(a_symbol)
+      @bitmask = @bitmask & ~@@symbols_to_masks[a_symbol]
+    end
+
+    def test?(bitmask2)
+      (@bitmask & bitmask2) != 0
+    end
+    def watch_ignored?
+      self.test?(Inotify::IGNORED)
+    end
+    def is_directory?
+      self.test?(Inotify::ISDIR)
+    end
+    def overflow?
+      self.test?(Inotify::Q_OVERFLOW)
+    end
+    def unmount?
+      self.test?(Inotify::UNMOUNT)
+    end
+    def as_array_of_symbols
+      return @symbols if @symbols != nil
+      @symbols = Array.new
+      31.downto(0) do |i|
+        if @bitmask[i] == 1
+          a_symbol = @@symbols_and_bits[i]
+          @symbols << a_symbol if a_symbol != nil
+        end
+      end
+      @symbols
+    end
+  end
+end

data/lib/inotify/thread.rb

@@ -0,0 +1,77 @@
+require 'find'
+require 'inotify'
+
+module Inotify
+
+  class InotifyThread
+    def initialize
+      @inotify = Inotify.new
+      @watch_list = Hash.new
+      @reg_events = Hash.new {Array.new}
+      @die_on_move = true
+    end
+ 
+    def start_thread
+      @thread = Thread.new do 
+        self.start_loop
+      end
+    end
+
+    def start_loop
+      @inotify.each_event do |notify_event|
+        @reg_events.keys.each do |reg_event|
+          if (notify_event.mask & reg_event) > 0
+            @reg_events[reg_event].each do |event_block|
+              # There is no way to get the new path if the watched directory is moved, so stop watching it
+              if @die_on_move and InotifyBitmask.new(notify_event.mask).test?(:in_move_self)
+                self.remove_watch(@watch_list[notify_event.wd])
+                break
+              else
+                event_block.call(notify_event, @watch_list[notify_event.wd])
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def end_thread
+      @thread.kill
+    end
+
+    def add_watch(pathname, bitmask, recursive)
+      bm = InotifyBitmask.new(bitmask)
+      if @die_on_move
+        bm.set_flag(:in_move_self)
+      end
+      full_path = File.expand_path(pathname)
+      wd = @inotify.add_watch(full_path, bm.bitmask)
+      return wd if wd < 0
+      @watch_list[wd] = full_path
+      if recursive and FileTest.directory?(full_path)
+        Dir.foreach(full_path) do |filename|
+          full_filename = File.join(full_path, filename)
+          if FileTest.directory?(full_filename)
+            if filename[0] != ?.
+              wd = self.add_watch(full_filename, bm.bitmask, recursive)
+            end
+          end
+        end
+      end
+      wd
+    end
+
+    def remove_watch(pathname)
+      wd = @watch_list[pathname]
+      if !wd.nil?
+        @inotify.rm_watch(wd)
+        @watch_list.delete(wd)
+      end
+    end
+
+    def register_event(bitmask, &block)
+      @reg_events[bitmask] = @reg_events[bitmask] << block
+    end
+  end
+
+end

data/lib/inotify.rb

@@ -0,0 +1,3 @@
+require 'inotify/inotify_native'
+require 'inotify/thread'
+require 'inotify/bitmask'

data/lib/test_run.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'conrad_filer/cli'
+cli = ConradFiler::CLI.new(ARGV)
+cli.run

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: conrad_filer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jon Raiford
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-03 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Think of it as applying a firewall ruleset to file management.
+email: 
+- jon@raiford.org
+executables: 
+- conrad_filer.rb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .project
+- README
+- bin/conrad_filer.rb
+- lib/conrad_filer.rb
+- lib/conrad_filer/cli.rb
+- lib/conrad_filer/config.rb
+- lib/conrad_filer/db.rb
+- lib/conrad_filer/db_objects.rb
+- lib/conrad_filer/dir_polling_job.rb
+- lib/conrad_filer/id_type.rb
+- lib/conrad_filer/rule.rb
+- lib/conrad_filer/version.rb
+- lib/conrad_filer/watch_job.rb
+- lib/inotify.rb
+- lib/inotify/bitmask.rb
+- lib/inotify/inotify_native.so
+- lib/inotify/thread.rb
+- lib/test_run.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A rule-based file manager
+test_files: []
+