rb.rotate 0.1.0

data/lib/rb.rotate/log.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+require "rb.rotate/configuration"
+
+module RbRotate
+
+    ##
+    # Logfile.
+    #
+    
+    class Log 
+    
+        ##
+        # Singletone instance.
+        #
+        
+        @@self = nil
+        
+        ##
+        # Path to log.
+        #
+        
+        @path
+        
+        ##
+        # Returns its singletone instance.
+        #
+        
+        def self.get
+            if @@self.nil?
+                @@self = self::new(Configuration::get.paths[:"log file"])
+            end
+            
+            return @@self
+        end
+        
+        ##
+        # Alias for #write.
+        #
+        
+        def self.write(message, caller = nil)
+            self::get.write(message, caller)
+        end
+        
+        ##
+        # Constructor.
+        #
+        
+        def initialize(path)
+            @path = path
+        end
+        
+        ##
+        # Writes to log.
+        #
+        
+        def write(message, caller = nil)
+            output = "[" << Time.now.strftime("%Y-%m-%d %H:%M:%S.%L") << "] "
+            if caller
+                output << caller.class.name << ": "
+            end
+            output << message << "\n"
+            
+            ::File.open(@path, "a") do |io|
+                io.write(output)
+            end
+        end
+    end    
+    
+end
+
+
+class Object
+    ##
+    # Logs an message.
+    #
+
+    def log(message)
+        RbRotate::Log::write(message, self)
+    end    
+end

data/lib/rb.rotate/mail.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module RbRotate
+
+    ##
+    # Mail sender.
+    #
+    
+    class Mail 
+    
+        ##
+        # Pony class for delivering.
+        #
+        
+        @@pony = nil
+        
+        ##
+        # Sends mail through Pony mail using specified parameters.
+        #
+        
+        def self.send(parameters)
+            self::pony.mail(parameters)
+        end
+        
+        ##
+        # Returns the Pony class (includes if necessary).
+        #
+        
+        def self.pony
+            if @@pony.nil?
+                require "pony"
+                @@pony = Pony
+            end
+            
+            return @@pony
+        end
+        
+    end    
+    
+end

data/lib/rb.rotate/reader.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+require "rb.rotate/state"
+
+module RbRotate
+
+    ##
+    # Represents reader of some directory.
+    #
+    
+    class Reader
+    
+        ##
+        # Directory for which reader has been created.
+        #
+        
+        @directory
+        
+        ##
+        # Reads the directory. (Shortcut for non-static read.)
+        # Create new instance and call read.
+        #
+        
+        def self.read(directory, options = { }, &block)
+            self::new(directory).read(options, &block)
+        end
+        
+        ##
+        # Constructor.
+        #
+        
+        def initialize(directory)
+            @directory = directory
+        end
+        
+        ##
+        # Reads the directory content.
+        #
+        
+        def read(options = { }, &block)
+            filter = options[:filter]
+        
+            dirpath = @directory.path
+            Dir.open(dirpath) do |dir|
+                dir.each_entry do |item|
+                    filepath = dirpath.dup << "/" << item
+                    
+                    if (not @directory.configuration[:follow]) and (::File.symlink? filepath)
+                        next
+                    elsif (filter.nil? or (filter == :files)) and (::File.file? filepath)
+                        emit_file filepath, &block
+                    elsif (filter.nil? or (filter == :dirs)) and (item != ?.) and (item.to_sym != :"..") and (::File.directory? filepath)
+                        emit_directory filepath, &block
+                    end
+                end
+            end
+        end
+        
+        ##
+        # Returns the state file object.
+        #
+        
+        def state
+            State::get
+        end
+        
+        
+        
+        private
+        
+        ##
+        # Emits file.
+        #
+        
+        def emit_file(filepath)
+            if not self.state.archive.has_file? filepath
+                yield File::new(filepath, @directory)
+            end
+        end
+        
+        ##
+        # Emits directory.
+        #
+        
+        def emit_directory(filepath)
+            if not self.state.archive.has_directory? filepath
+                yield Directory::new(filepath, @directory)
+            end
+        end
+        
+    end
+    
+end
+
+

data/lib/rb.rotate/state.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+
+require "yaml"
+require "rb.rotate/configuration"
+require "rb.rotate/state/archive"
+require "rb.rotate/state/file"
+
+module RbRotate
+
+    ##
+    # Represents state file.
+    #
+    
+    class State
+    
+        ##
+        # Holds self-instance as singleton.
+        #
+        
+        @@self = nil
+        
+        ##
+        # Holds state data.
+        #
+        
+        @data
+        
+        ##
+        # Holds path to state file.
+        #
+        
+        @path
+        
+        ##
+        # Holds archive accessor instance.
+        #
+        
+        @archive
+        
+        ##
+        # Constructor.
+        #
+        
+        def initialize
+            @path = self.configuration.paths[:"state file"]
+        end
+        
+        ##
+        # Returns self instance.
+        #
+        
+        def self.get
+            if @@self.nil?
+                @@self = self::new
+            end
+            
+            return @@self
+        end
+        
+        ##
+        # Saves the file. (Shortcut to instance.)
+        #
+        
+        def self.save!
+            self::get.save!
+        end
+        
+        ##
+        # Alias for #archive.
+        #
+        
+        def self.archive
+            self::get.archive
+        end
+        
+        ##
+        # Alias for #files.
+        #
+        
+        def self.files
+            self::get.files
+        end
+        
+        ##
+        # Alias for #each_file.
+        #
+        
+        def self.each_file(&block)
+            self::get.each_file(&block)
+        end
+        
+        ##
+        # Returns data array.
+        #
+        
+        def data
+            if @data.nil?
+                if not ::File.exists? @path
+                    self.create!
+                else
+                    @data = YAML.load(::File.read(@path))
+                end
+            end
+            
+            return @data
+        end
+        
+        ##
+        # Formats new storage.
+        #
+        
+        def new
+            Hash[
+                :archive => {
+                    :files => { },
+                    :directories => { }
+                },
+                
+                :files => { },
+            ]
+        end
+        
+        ##
+        # Creates new storage.
+        #
+        
+        def create!
+            @data = self.new
+            self.save! 
+        end
+        
+        ##
+        # Saves the file.
+        #
+        
+        def save!
+            self.compact!
+            ::File.open(@path, "w") do |io|
+                io.write(self.data.to_yaml)
+            end
+        end
+        
+        ##
+        # Returns archive accessor instance.
+        #
+        
+        def archive
+            if @archive.nil?
+                @archive = StateModule::Archive::new(self.data[:archive])
+            end
+            
+            return @archive
+        end
+        
+        ##
+        # Returns files list.
+        #
+        
+        def files
+            self.data[:files]
+        end
+        
+        ##
+        # Compacts the file specifications.
+        # It removes all empty entries records.
+        #
+        
+        def compact!
+            self.files.reject! do |key, value|
+                value.empty?
+            end
+        end
+        
+        ##
+        # Returns record for appropriate file.
+        #
+        
+        def file(path)
+            data = self.files[path.to_sym]
+            
+            if data.nil?
+                data = { }
+                self.files[path.to_sym] = data
+            end
+            
+            StateModule::File::new(path, data)
+        end
+        
+        ##
+        # Returns configuration object instance.
+        #
+        
+        def configuration
+            Configuration::get
+        end
+        
+        ##
+        # Traverses through all files and emits path and 
+        # StateModule::File objects.
+        #
+        
+        def each_file
+            self.files.each_pair do |path, data|
+                if not data.empty?
+                    yield path, StateModule::File::new(path, data)
+                end
+            end
+        end
+        
+    end
+end

data/lib/rb.rotate/state/archive.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+module RbRotate
+    module StateModule
+    
+        ##
+        # State file archive section.
+        #
+        
+        class Archive
+        
+            ##
+            # Holds the archive data.
+            #
+            
+            @data
+            
+            ##
+            # Constructor.
+            #
+            
+            def initialize(data)
+                @data = data
+            end
+            
+            ##
+            # Returns file data.
+            #
+            
+            def file(path)
+                self.files[path.to_sym]
+            end
+            
+            ##
+            # Returns files data.
+            #
+            
+            def files
+                @data[:files]
+            end
+            
+            ##
+            # Indicates, file is in archive.
+            #
+            
+            def has_file?(path)
+                @data[:files].has_key? path.to_sym
+            end
+            
+            ##
+            # Indicates, directory is in archive.
+            #
+            
+            def has_directory?(path)
+                @data[:directories].has_key? path.to_sym
+            end
+            
+            ##
+            # Registers file.
+            #
+            
+            def register_file(path, value = true)
+                self.register_item(:files, path, value)
+            end
+            
+            ##
+            # Unregisters file.
+            #
+            
+            def unregister_file(path)
+                self.unregister_item(:files, path)
+            end
+            
+
+            ##
+            # Registers directory.
+            #
+            
+            def register_directory(path, value = true)
+                self.register_item(:directories, path, value)
+            end
+            
+            ##
+            # Unregisters file.
+            #
+            
+            def unregister_directory(path)
+                self.unregister_item(:directories, path)
+            end
+            
+            ##
+            # Registers item.
+            #
+            
+            def register_item(group, path, value = true)
+                @data[group][path.to_sym] = value
+            end
+            
+            ##
+            # Unregister item.
+            #
+            
+            def unregister_item(group, path)
+                @data[group].delete(path.to_sym)
+            end
+            
+        end
+    end
+end