htauth 1.0.1 → 1.0.2

data/lib/htauth/passwd_entry.rb

@@ -2,96 +2,96 @@ require 'htauth/entry'
 require 'htauth/algorithm'
 
 module HTAuth
-    class InvalidPasswdEntry < StandardError ; end
+  class InvalidPasswdEntry < StandardError ; end
 
-    # A single record in an htdigest file.  
-    class PasswdEntry < Entry
+  # A single record in an htdigest file.  
+  class PasswdEntry < Entry
 
-        attr_accessor :user
-        attr_accessor :digest
-        attr_reader   :algorithm
+    attr_accessor :user
+    attr_accessor :digest
+    attr_reader   :algorithm
 
-        class << self
-            def from_line(line)
-                parts = is_entry!(line)
-                d = PasswdEntry.new(parts[0])
-                d.digest = parts[1]
-                d.algorithm = Algorithm.algorithms_from_field(parts[1])
-                return d
-            end
+    class << self
+      def from_line(line)
+        parts = is_entry!(line)
+        d = PasswdEntry.new(parts[0])
+        d.digest = parts[1]
+        d.algorithm = Algorithm.algorithms_from_field(parts[1])
+        return d
+      end
 
-            # test if a line is an entry, raise InvalidPasswdEntry if it is not.
-            # an entry must be composed of 2 parts, username:encrypted_password
-            # where username, and password do not contain the ':' character 
-            def is_entry!(line)
-                raise InvalidPasswdEntry, "line commented out" if line =~ /\A#/
-                parts = line.strip.split(":")
-                raise InvalidPasswdEntry, "line must be of the format username:pssword" if parts.size != 2
-                return parts
-            end
+      # test if a line is an entry, raise InvalidPasswdEntry if it is not.
+      # an entry must be composed of 2 parts, username:encrypted_password
+      # where username, and password do not contain the ':' character 
+      def is_entry!(line)
+        raise InvalidPasswdEntry, "line commented out" if line =~ /\A#/
+          parts = line.strip.split(":")
+        raise InvalidPasswdEntry, "line must be of the format username:pssword" if parts.size != 2
+        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 InvalidPasswdEntry
-                    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 InvalidPasswdEntry
+          return false
         end
+      end
+    end
 
-        def initialize(user, password = "", alg = Algorithm::DEFAULT, alg_params = {} ) 
-            @user      = user
-            alg = Algorithm::DEFAULT if alg == Algorithm::EXISTING 
-            @algorithm = Algorithm.algorithm_from_name(alg, alg_params)
-            @digest    = algorithm.encode(password)
-        end
+    def initialize(user, password = "", alg = Algorithm::DEFAULT, alg_params = {} ) 
+      @user      = user
+      alg = Algorithm::DEFAULT if alg == Algorithm::EXISTING 
+      @algorithm = Algorithm.algorithm_from_name(alg, alg_params)
+      @digest    = algorithm.encode(password)
+    end
 
-        def algorithm=(alg)
-            if alg.kind_of?(Array) then
-                if alg.size == 1 then
-                    @algorithm = alg.first
-                else
-                    @algorithm = alg
-                end
-            else
-                @algorithm = Algorithm.algorithm_from_name(alg) unless Algorithm::EXISTING == alg
-            end
-            return @algorithm
+    def algorithm=(alg)
+      if alg.kind_of?(Array) then
+        if alg.size == 1 then
+          @algorithm = alg.first
+        else
+          @algorithm = alg
         end
+      else
+        @algorithm = Algorithm.algorithm_from_name(alg) unless Algorithm::EXISTING == alg
+      end
+      return @algorithm
+    end
 
-        def password=(new_password)
-            if algorithm.kind_of?(Array) then
-                @algorithm = Algorithm.algorithm_from_name("crypt")
-            end
-            @digest = algorithm.encode(new_password)
-        end
+    def password=(new_password)
+      if algorithm.kind_of?(Array) then
+        @algorithm = Algorithm.algorithm_from_name("crypt")
+      end
+      @digest = algorithm.encode(new_password)
+    end
 
-        # check the password and make sure it works, in the case that the algorithm is unknown it
-        # tries all of the ones that it thinks it could be, and marks the algorithm if it matches
-        def authenticated?(check_password)
-            authed = false
-            if algorithm.kind_of?(Array) then
-                algorithm.each do |alg|
-                    if alg.encode(check_password) == digest then
-                        @algorithm = alg
-                        authed = true
-                        break
-                    end
-                end
-            else
-                authed = digest == algorithm.encode(check_password)
-            end
-            return authed
+    # check the password and make sure it works, in the case that the algorithm is unknown it
+    # tries all of the ones that it thinks it could be, and marks the algorithm if it matches
+    def authenticated?(check_password)
+      authed = false
+      if algorithm.kind_of?(Array) then
+        algorithm.each do |alg|
+          if alg.encode(check_password) == digest then
+            @algorithm = alg
+            authed = true
+            break
+          end
         end
+      else
+        authed = digest == algorithm.encode(check_password)
+      end
+      return authed
+    end
 
-        def key
-            return "#{user}"
-        end
+    def key
+      return "#{user}"
+    end
 
-        def to_s
-            "#{user}:#{digest}"
-        end
+    def to_s
+      "#{user}:#{digest}"
     end
+  end
 end

data/lib/htauth/passwd_file.rb

@@ -73,10 +73,6 @@ module HTAuth
             ENTRY_KLASS
         end
 
-        def file_type
-            "passwd"
-        end
-
         private
 
         def internal_record(username)

data/lib/htauth/version.rb

@@ -1,19 +1,22 @@
 require 'htauth'
 module HTAuth
-    class Version
-        MAJOR   = 1
-        MINOR   = 0
-        BUILD   = 1
+  module Version
+    MAJOR   = 1
+    MINOR   = 0
+    BUILD   = 2
 
-        class << self
-            def to_a
-                [MAJOR, MINOR, BUILD]
-            end
+    def to_a
+      [MAJOR, MINOR, BUILD]
+    end
 
-            def to_s
-                to_a.join(".")
-            end
-        end
+    def to_s
+      to_a.join(".")
     end
-    VERSION = Version.to_s
+
+    module_function :to_a
+    module_function :to_s
+
+    STRING = Version.to_s
+  end
+  VERSION = Version.to_s
 end

data/tasks/announce.rake

@@ -0,0 +1,38 @@
+require 'tasks/config'
+#-------------------------------------------------------------------------------
+# announcement methods
+#-------------------------------------------------------------------------------
+
+proj_config = Configuration.for('project')
+namespace :announce do
+  desc "create email for ruby-talk"
+  task :email do
+    info = Utils.announcement
+
+    File.open("email.txt", "w") do |mail|
+      mail.puts "From: #{proj_config.author} <#{proj_config.email}>"
+      mail.puts "To: ruby-talk@ruby-lang.org"
+      mail.puts "Date: #{Time.now.rfc2822}"
+      mail.puts "Subject: [ANN] #{info[:subject]}"
+      mail.puts
+      mail.puts info[:title]
+      mail.puts
+      mail.puts info[:urls]
+      mail.puts 
+      mail.puts info[:description]
+      mail.puts 
+      mail.puts "{{ Release notes for Version #{HTAuth::VERSION} }}"
+      mail.puts 
+      mail.puts info[:release_notes]
+      mail.puts
+      mail.puts info[:urls]
+    end 
+    puts "Created the following as email.txt:"
+    puts "-" * 72
+    puts File.read("email.txt")
+    puts "-" * 72
+  end 
+
+  CLOBBER << "email.txt"
+end
+

data/tasks/config.rb

@@ -0,0 +1,98 @@
+require 'configuration'
+
+require 'rake'
+require 'tasks/utils'
+
+#-----------------------------------------------------------------------
+# General project configuration
+#-----------------------------------------------------------------------
+Configuration.for('project') {
+  name          "htauth"
+  version       "1.0.1"
+  author        "Jeremy Hinegardner"
+  email         "jeremy@copiousfreetime.org"
+  homepage      "http://copiousfreetime.rubyforge.org/htauth"
+  description   Utils.section_of("README", "description")
+  summary       description.split(".").first
+  history       "HISTORY"
+  license       FileList["LICENSE", ]
+  readme        "README"
+}
+
+#-----------------------------------------------------------------------
+# Packaging 
+#-----------------------------------------------------------------------
+Configuration.for('packaging') {
+  # files in the project 
+  proj_conf = Configuration.for('project')
+  files {
+    bin       FileList["bin/*"]
+    lib       FileList["lib/**/*.rb"]
+    test      FileList["spec/**/*.rb", "test/**/*.rb"]
+    data      FileList["data/**/*"]
+    tasks     FileList["tasks/**/*.r{ake,b}"]
+    rdoc      FileList[proj_conf.readme, proj_conf.history,
+                       proj_conf.license] + lib
+    all       bin + lib + test + data + rdoc + tasks 
+  }
+
+  # ways to package the results
+  formats {
+    tgz true
+    zip true
+    rubygem Configuration::Table.has_key?('rubygem')
+  }
+}
+
+#-----------------------------------------------------------------------
+# Gem packaging
+#-----------------------------------------------------------------------
+Configuration.for("rubygem") {
+  spec "gemspec.rb"
+  Configuration.for('packaging').files.all << spec
+}
+
+#-----------------------------------------------------------------------
+# Testing
+#   - change mode to 'testunit' to use unit testing
+#-----------------------------------------------------------------------
+Configuration.for('test') {
+  mode      "spec"
+  files     Configuration.for("packaging").files.test
+  options   %w[ --format specdoc --color ]
+  ruby_opts %w[ ]
+}
+
+#-----------------------------------------------------------------------
+# Rcov 
+#-----------------------------------------------------------------------
+Configuration.for('rcov') {
+  output_dir  "coverage"
+  libs        %w[ lib ]
+  rcov_opts   %w[ --html ]
+  ruby_opts   %w[ ]
+  test_files  Configuration.for('packaging').files.test
+}
+
+#-----------------------------------------------------------------------
+# Rdoc 
+#-----------------------------------------------------------------------
+Configuration.for('rdoc') {
+  files       Configuration.for('packaging').files.rdoc
+  main_page   files.first
+  title       Configuration.for('project').name
+  options     %w[ --line-numbers --inline-source ]
+  output_dir  "doc"
+}
+
+#-----------------------------------------------------------------------
+# Rubyforge 
+#-----------------------------------------------------------------------
+Configuration.for('rubyforge') {
+  project       "copiousfreetime"
+  user          "jjh"
+  host          "rubyforge.org"
+  rdoc_location "#{user}@#{host}:/var/www/gforge-projects/#{project}/htauth"
+}
+
+

data/tasks/distribution.rake

@@ -0,0 +1,46 @@
+require 'tasks/config'
+
+#-------------------------------------------------------------------------------
+# Distribution and Packaging
+#-------------------------------------------------------------------------------
+if pkg_config = Configuration.for_if_exist?("packaging") then
+
+  require 'gemspec'
+  require 'rake/gempackagetask'
+  require 'rake/contrib/sshpublisher'
+
+  namespace :dist do
+
+    Rake::GemPackageTask.new(HTAuth::GEM_SPEC) do |pkg|
+      pkg.need_tar = pkg_config.formats.tgz
+      pkg.need_zip = pkg_config.formats.zip
+    end
+
+    desc "Install as a gem"
+    task :install => [:clobber, :package] do
+      sh "sudo gem install pkg/#{HTAuth::GEM_SPEC.full_name}.gem"
+    end
+
+    desc "Uninstall gem"
+    task :uninstall do 
+      sh "sudo gem uninstall -x #{HTAuth::GEM_SPEC.name}"
+    end
+
+    desc "dump gemspec"
+    task :gemspec do
+      puts HTAuth::GEM_SPEC.to_ruby
+    end
+
+    desc "distribute copiously"
+    task :copious => [ :package ] do
+      Rake::SshFilePublisher.new('jeremy@copiousfreetime.org',
+                                 '/var/www/vhosts/www.copiousfreetime.org/htdocs/gems/gems',
+                                 'pkg' ,"#{HTAuth::GEM_SPEC.full_name}.gem").upload
+      sh "ssh jeremy@copiousfreetime.org rake -f /var/www/vhosts/www.copiousfreetime.org/htdocs/gems/Rakefile"
+    end 
+
+    desc "reinstall gem"
+    task :reinstall => [:uninstall, :repackage, :install]
+
+  end
+end

data/tasks/documentation.rake

@@ -0,0 +1,31 @@
+require 'tasks/config'
+
+#-----------------------------------------------------------------------
+# Documentation
+#-----------------------------------------------------------------------
+
+if rdoc_config = Configuration.for_if_exist?('rdoc') then
+
+  namespace :doc do
+
+    require 'rake/rdoctask'
+
+    # generating documentation locally
+    Rake::RDocTask.new do |rdoc|
+      rdoc.rdoc_dir   = rdoc_config.output_dir
+      rdoc.options    = rdoc_config.options
+      rdoc.rdoc_files = rdoc_config.files
+      rdoc.title      = rdoc_config.title
+      rdoc.main       = rdoc_config.main_page
+    end 
+
+    if rubyforge_config = Configuration.for_if_exist?('rubyforge') then
+      desc "Deploy the RDoc documentation to #{rubyforge_config.rdoc_location}"
+      task :deploy => :rerdoc do
+        sh "rsync -zav --delete #{rdoc_config.output_dir}/ #{rubyforge_config.rdoc_location}"
+      end 
+    end 
+
+  end 
+end
+

data/tasks/rspec.rake

@@ -0,0 +1,29 @@
+
+require 'tasks/config'
+
+#--------------------------------------------------------------------------------
+# configuration for running rspec.  This shows up as the test:default task
+#--------------------------------------------------------------------------------
+if spec_config = Configuration.for_if_exist?("test") then
+  if spec_config.mode == "spec" then
+    namespace :test do
+
+      task :default => :spec
+
+      require 'spec/rake/spectask'
+      Spec::Rake::SpecTask.new do |r| 
+        r.ruby_opts   = spec_config.ruby_opts
+        r.libs        = [ HTAuth.lib_path, 
+                          HTAuth.root_dir ]
+        r.spec_files  = spec_config.files 
+        r.spec_opts   = spec_config.options
+
+        if rcov_config = Configuration.for_if_exist?('rcov') then
+          r.rcov      = true
+          r.rcov_dir  = rcov_config.output_dir
+          r.rcov_opts = rcov_config.rcov_opts
+        end
+      end
+    end
+  end
+end