htauth 1.0.1 → 1.0.2

data/lib/htauth/digest_entry.rb

@@ -2,72 +2,72 @@ require 'htauth/entry'
 require 'digest/md5'
 
 module HTAuth
-    class InvalidDigestEntry < StandardError ; end
+  class InvalidDigestEntry < StandardError ; end
 
-    # A single record in an htdigest file.  
-    class DigestEntry
+  # A single record in an htdigest file.  
+  class DigestEntry
 
-        attr_accessor :user
-        attr_accessor :realm
-        attr_accessor :digest
+    attr_accessor :user
+    attr_accessor :realm
+    attr_accessor :digest
 
-        class << self
-            def from_line(line)
-                parts = is_entry!(line)
-                d = DigestEntry.new(parts[0], parts[1])
-                d.digest = parts[2]
-                return d
-            end
+    class << self
+      def from_line(line)
+        parts = is_entry!(line)
+        d = DigestEntry.new(parts[0], parts[1])
+        d.digest = parts[2]
+        return d
+      end
 
-            # test if a line is an entry, raise InvalidDigestEntry if it is not.
-            # an entry must be composed of 3 parts, username:realm:md5sum
-            # where username, and realm do not contain the ':' character 
-            # and the md5sum must be 32 characters long.
-            def is_entry!(line)
-                raise InvalidDigestEntry, "line commented out" if line =~ /\A#/
-                parts = line.strip.split(":")
-                raise InvalidDigestEntry, "line must be of the format username:realm:md5checksum" if parts.size != 3
-                raise InvalidDigestEntry, "md5 checksum is not 32 characters long" if parts.last.size  != 32
-                raise InvalidDigestEntry, "md5 checksum has invalid characters" if parts.last !~ /\A[[:xdigit:]]{32}\Z/
-                return parts
-            end
+      # test if a line is an entry, raise InvalidDigestEntry if it is not.
+      # an entry must be composed of 3 parts, username:realm:md5sum
+      # where username, and realm do not contain the ':' character 
+      # and the md5sum must be 32 characters long.
+      def is_entry!(line)
+        raise InvalidDigestEntry, "line commented out" if line =~ /\A#/
+          parts = line.strip.split(":")
+        raise InvalidDigestEntry, "line must be of the format username:realm:md5checksum" if parts.size != 3
+        raise InvalidDigestEntry, "md5 checksum is not 32 characters long" if parts.last.size  != 32
+        raise InvalidDigestEntry, "md5 checksum has invalid characters" if parts.last !~ /\A[[:xdigit:]]{32}\Z/
+          return parts
+      end
 
-            # test if a line is an entry and return true or false
-            def is_entry?(line)
-                begin
-                    is_entry!(line)
-                    return true
-                rescue InvalidDigestEntry
-                    return false
-                end
-            end
+      # test if a line is an entry and return true or false
+      def is_entry?(line)
+        begin
+          is_entry!(line)
+          return true
+        rescue InvalidDigestEntry
+          return false
         end
+      end
+    end
 
-        def initialize(user, realm, password = "")
-            @user     = user
-            @realm    = realm
-            @digest   = calc_digest(password)
-        end
+    def initialize(user, realm, password = "")
+      @user     = user
+      @realm    = realm
+      @digest   = calc_digest(password)
+    end
 
-        def password=(new_password)
-            @digest = calc_digest(new_password)
-        end
+    def password=(new_password)
+      @digest = calc_digest(new_password)
+    end
 
-        def calc_digest(password)
-            ::Digest::MD5.hexdigest("#{user}:#{realm}:#{password}")
-        end
+    def calc_digest(password)
+      ::Digest::MD5.hexdigest("#{user}:#{realm}:#{password}")
+    end
 
-        def authenticated?(check_password)
-            hd = ::Digest::MD5.hexdigest("#{user}:#{realm}:#{check_password}")
-            return hd == digest
-        end
+    def authenticated?(check_password)
+      hd = ::Digest::MD5.hexdigest("#{user}:#{realm}:#{check_password}")
+      return hd == digest
+    end
 
-        def key
+    def key
             "#{user}:#{realm}"
-        end
+    end
 
-        def to_s
+    def to_s
             "#{user}:#{realm}:#{digest}"
-        end
     end
+  end
 end

data/lib/htauth/digest_file.rb

@@ -1,85 +1,80 @@
 require 'stringio'
-require 'tempfile'
 
 require 'htauth/file'
 require 'htauth/digest_entry'
 
 module HTAuth
-    class DigestFileError < StandardError ; end
-    class DigestFile < HTAuth::File
+  class DigestFileError < StandardError ; end
+  class DigestFile < HTAuth::File
 
-        ENTRY_KLASS = HTAuth::DigestEntry
+    ENTRY_KLASS = HTAuth::DigestEntry
 
-        # does the entry the the specified username and realm exist in the file
-        def has_entry?(username, realm)
-            test_entry = DigestEntry.new(username, realm)
-            @entries.has_key?(test_entry.key)
-        end
+    # does the entry the the specified username and realm exist in the file
+    def has_entry?(username, realm)
+      test_entry = DigestEntry.new(username, realm)
+      @entries.has_key?(test_entry.key)
+    end
 
-        # remove an entry from the file
-        def delete(username, realm)
-            if has_entry?(username, realm) then
-                ir = internal_record(username, realm)
-                line_index = ir['line_index']
-                @entries.delete(ir['entry'].key)
-                @lines[line_index] = nil
-                dirty!
-            end
-            nil
-        end
+    # remove an entry from the file
+    def delete(username, realm)
+      if has_entry?(username, realm) then
+        ir = internal_record(username, realm)
+        line_index = ir['line_index']
+        @entries.delete(ir['entry'].key)
+        @lines[line_index] = nil
+        dirty!
+      end
+      nil
+    end
 
-        # add or update an entry as appropriate
-        def add_or_update(username, realm, password)
-            if has_entry?(username, realm) then
-                update(username, realm, password)
-            else
-                add(username, realm, password)
-            end
-        end
+    # add or update an entry as appropriate
+    def add_or_update(username, realm, password)
+      if has_entry?(username, realm) then
+        update(username, realm, password)
+      else
+        add(username, realm, password)
+      end
+    end
 
-        # add an new record.  raises an error if the entry exists.
-        def add(username, realm, password)
-            raise DigestFileError, "Unable to add already existing user #{username} in realm #{realm}" if has_entry?(username, realm)
-            
-            new_entry = DigestEntry.new(username, realm, password)
-            new_index = @lines.size
-            @lines << new_entry.to_s
-            @entries[new_entry.key] = { 'entry' => new_entry, 'line_index' => new_index }
-            dirty!
-            return nil
-        end
+    # add an new record.  raises an error if the entry exists.
+    def add(username, realm, password)
+      raise DigestFileError, "Unable to add already existing user #{username} in realm #{realm}" if has_entry?(username, realm)
 
-        # update an already existing entry with a new password.  raises an error if the entry does not exist
-        def update(username, realm, password)
-            raise DigestFileError, "Unable to update non-existent user #{username} in realm #{realm}" unless has_entry?(username, realm)
-            ir = internal_record(username, realm)
-            ir['entry'].password = password
-            @lines[ir['line_index']] = ir['entry'].to_s
-            dirty!
-            return nil
-        end
+      new_entry = DigestEntry.new(username, realm, password)
+      new_index = @lines.size
+      @lines << new_entry.to_s
+      @entries[new_entry.key] = { 'entry' => new_entry, 'line_index' => new_index }
+      dirty!
+      return nil
+    end
 
-        # fetches a copy of an entry from the file.  Updateing the entry returned from fetch will NOT
-        # propogate back to the file.
-        def fetch(username, realm)
-            return nil unless has_entry?(username, realm)
-            ir = internal_record(username, realm)
-            return ir['entry'].dup
-        end
+    # update an already existing entry with a new password.  raises an error if the entry does not exist
+    def update(username, realm, password)
+      raise DigestFileError, "Unable to update non-existent user #{username} in realm #{realm}" unless has_entry?(username, realm)
+      ir = internal_record(username, realm)
+      ir['entry'].password = password
+      @lines[ir['line_index']] = ir['entry'].to_s
+      dirty!
+      return nil
+    end
 
-        def entry_klass
-            ENTRY_KLASS
-        end
+    # fetches a copy of an entry from the file.  Updateing the entry returned from fetch will NOT
+    # propogate back to the file.
+    def fetch(username, realm)
+      return nil unless has_entry?(username, realm)
+      ir = internal_record(username, realm)
+      return ir['entry'].dup
+    end
 
-        def file_type
-            "digest"
-        end
+    def entry_klass
+      ENTRY_KLASS
+    end
 
-        private
+    private
 
-        def internal_record(username, realm)
-            e = DigestEntry.new(username, realm)
-            @entries[e.key]
-        end
+    def internal_record(username, realm)
+      e = DigestEntry.new(username, realm)
+      @entries[e.key]
     end
+  end
 end

data/lib/htauth/entry.rb

@@ -1,9 +1,9 @@
 module HTAuth
 
-    # base class from which all entries are derived
-    class Entry
-        def dup
-            self.class.from_line(self.to_s)
-        end
+  # base class from which all entries are derived
+  class Entry
+    def dup
+      self.class.from_line(self.to_s)
     end
+  end
 end

data/lib/htauth/file.rb

@@ -2,102 +2,102 @@ require 'stringio'
 require 'htauth'
 
 module HTAuth
-    class FileAccessError < StandardError ; end
-    class File
-        ALTER  = "alter"
-        CREATE = "create"
-        STDOUT_FLAG = "-"
+  class FileAccessError < StandardError ; end
+  class File
+    ALTER  = "alter"
+    CREATE = "create"
+    STDOUT_FLAG = "-"
 
-        attr_reader :filename
-        attr_reader :file
+    attr_reader :filename
+    attr_reader :file
 
-        class << self
-            # open a file yielding the the file object for use.  The file is saved when 
-            # the block exists, if the file has had alterations made.
-            def open(filename, mode = ALTER) 
-                f = self.new(filename, mode)
-                if block_given?
-                    begin
-                        yield f
-                    ensure
-                        f.save! if f and f.dirty?
-                    end
-                end
-                return f
-            end
+    class << self
+      # open a file yielding the the file object for use.  The file is saved when 
+      # the block exists, if the file has had alterations made.
+      def open(filename, mode = ALTER) 
+        f = self.new(filename, mode)
+        if block_given?
+          begin
+            yield f
+          ensure
+            f.save! if f and f.dirty?
+          end
         end
+        return f
+      end
+    end
 
-        # Create or Alter a password file.
-        #
-        # Altering a non-existent file is an error.  Creating an existing file results in
-        # a truncation and overwrite of the existing file.
-        def initialize(filename, mode = ALTER)
-            @filename   = filename
-            @mode       = mode
-            @dirty      = false
-            
-            raise FileAccessError, "Invalid mode #{mode}" unless [ ALTER, CREATE ].include?(mode)
+    # Create or Alter a password file.
+    #
+    # Altering a non-existent file is an error.  Creating an existing file results in
+    # a truncation and overwrite of the existing file.
+    def initialize(filename, mode = ALTER)
+      @filename   = filename
+      @mode       = mode
+      @dirty      = false
 
-            if (filename != STDOUT_FLAG) and (mode == ALTER) and (not ::File.exist?(filename)) then
-                raise FileAccessError, "Could not open passwd file #{filename} for reading." 
-            end
+      raise FileAccessError, "Invalid mode #{mode}" unless [ ALTER, CREATE ].include?(mode)
 
-            begin
-                @entries  = {}
-                @lines    = []
-                load_entries if (@mode == ALTER) and (filename != STDOUT_FLAG)
-            rescue => e
-                raise FileAccessError, e.message
-            end
-        end
+      if (filename != STDOUT_FLAG) and (mode == ALTER) and (not ::File.exist?(filename)) then
+        raise FileAccessError, "Could not open passwd file #{filename} for reading." 
+      end
 
-        # return whether or not an alteration to the file has happened
-        def dirty?
-            @dirty
-        end
+      begin
+        @entries  = {}
+        @lines    = []
+        load_entries if (@mode == ALTER) and (filename != STDOUT_FLAG)
+      rescue => e
+        raise FileAccessError, e.message
+      end
+    end
 
-        # mark the file as dirty
-        def dirty!
-            @dirty = true
-        end
+    # return whether or not an alteration to the file has happened
+    def dirty?
+      @dirty
+    end
 
-        # update the original file with the new contents
-        def save!
-            begin
-                case filename
-                when STDOUT_FLAG
-                    $stdout.write(contents)
-                else
-                    ::File.open(@filename,"w") do |f|
-                        f.write(contents)
-                    end
-                end
-                @dirty = false
-            rescue => e
-                raise FileAccessError, "Error saving file #{@filename} : #{e.message}"
-            end
-        end
+    # mark the file as dirty
+    def dirty!
+      @dirty = true
+    end
 
-        # return what should be the contents of the file
-        def contents
-            c = StringIO.new
-            @lines.each do |l| 
-                c.puts l if l
-            end
-            c.string
+    # update the original file with the new contents
+    def save!
+      begin
+        case filename
+        when STDOUT_FLAG
+          $stdout.write(contents)
+        else
+          ::File.open(@filename,"w") do |f|
+            f.write(contents)
+          end
         end
+        @dirty = false
+      rescue => e
+        raise FileAccessError, "Error saving file #{@filename} : #{e.message}"
+      end
+    end
+
+    # return what should be the contents of the file
+    def contents
+      c = StringIO.new
+      @lines.each do |l| 
+        c.puts l if l
+      end
+      c.string
+    end
 
-        # load up entries, keep items in the same order and do not trim out any 
-        # items in the file, like commented out lines or empty space
-        def load_entries
-            @lines   = IO.readlines(@filename)
-            @lines.each_with_index do |line,idx|
-                if entry_klass.is_entry?(line) then
-                    entry = entry_klass.from_line(line)
-                    v     = { 'entry' => entry, 'line_index' => idx }
-                    @entries[entry.key] = v
-                end
-            end
+    # load up entries, keep items in the same order and do not trim out any 
+    # items in the file, like commented out lines or empty space
+    def load_entries
+      @lines   = IO.readlines(@filename)
+      @lines.each_with_index do |line,idx|
+        if entry_klass.is_entry?(line) then
+          entry = entry_klass.from_line(line)
+          v     = { 'entry' => entry, 'line_index' => idx }
+          @entries[entry.key] = v
         end
+      end
     end
+  end
 end