htauth 2.3.0 → 3.0.0

data/spec/passwd_file_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-require 'htauth/passwd_file'
-require 'tempfile'
-
-describe HTAuth::PasswdFile do
-
-  before(:each) do
-    @tf             = Tempfile.new("rpasswrd-passwd")
-    @tf.write(IO.read(PASSWD_ORIGINAL_TEST_FILE))
-    @tf.close
-    @passwd_file    = HTAuth::PasswdFile.new(@tf.path)
-
-    @tf2                = Tempfile.new("rpasswrd-passwd-empty")
-    @tf2.close
-    @empty_passwd_file  = HTAuth::PasswdFile.new(@tf2.path)
-  end
-
-  after(:each) do
-    @tf2.close(true)
-    @tf.close(true)
-  end
-
-  it "can add a new entry to an already existing passwd file" do
-    @passwd_file.add_or_update("charlie", "c secret", "sha1")
-    _(@passwd_file.contents).must_equal IO.read(PASSWD_ADD_TEST_FILE)
-  end
-
-  it "can tell if an entry already exists in the passwd file" do
-    _(@passwd_file.has_entry?("alice")).must_equal true
-    _(@passwd_file.has_entry?("david")).must_equal false
-  end
-
-  it "can update an entry in an already existing passwd file, algorithm can change" do
-    @passwd_file.add_or_update("alice", "a new secret", "sha1")
-    _(@passwd_file.contents).must_equal IO.read(PASSWD_UPDATE_TEST_FILE)
-  end
-
-  it "can update an entry in an already existing passwd file, algorithm and arguments can change" do
-    @passwd_file.add_or_update("brenda", "b secret", "bcrypt")
-    entry = @passwd_file.fetch("brenda")
-    _(entry.algorithm.cost).must_equal(::HTAuth::Bcrypt::DEFAULT_APACHE_COST)
-    @passwd_file.add_or_update("brenda", "b secret", "bcrypt", :cost => 12)
-    entry = @passwd_file.fetch("brenda")
-    _(entry.algorithm.cost).must_equal(12)
-  end
-
-  it "fetches a copy of an entry" do
-    _(@passwd_file.fetch("alice").to_s).must_equal "alice:$apr1$DghnA...$CsPcgerfsI/Ryy0AOAJtb0"
-  end
-
-  it "raises an error if an attempt is made to alter a non-existent file" do
-    _ { HTAuth::PasswdFile.new("some-file") }.must_raise(HTAuth::FileAccessError)
-  end
-
-  # this test will only work on systems that have /etc/ssh_host_rsa_key 
-  it "raises an error if an attempt is made to open a file where no permissions are granted" do
-    _ { HTAuth::PasswdFile.new("/etc/ssh_host_rsa_key") }.must_raise(HTAuth::FileAccessError)
-  end
-
-  it "deletes an entry" do
-    @passwd_file.delete("bob")
-    _(@passwd_file.contents).must_equal IO.read(PASSWD_DELETE_TEST_FILE)
-  end
-
-  it "checks authentication of an entry - true" do
-    _(@passwd_file.authenticated?("alice", "a secret")).must_equal true
-  end
-
-  it "checks authentication of an entry - false" do
-    _(@passwd_file.authenticated?("alice", "the wrong secret")).must_equal false
-  end
-
-
-  it "is usable in a ruby manner and yields itself when opened" do
-    HTAuth::PasswdFile.open(@tf.path) do |pf|
-      pf.add_or_update("alice", "a new secret", "md5")
-      pf.delete('bob')
-    end
-    lines = IO.readlines(@tf.path)
-    _(lines.size).must_equal 1
-    _(lines.first.split(':').first).must_equal "alice"
-    _(lines.first.split(':').last).must_match( /\$apr1\$/ )
-  end
-end

data/spec/plaintext_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-require 'htauth/plaintext'
-
-describe HTAuth::Plaintext do
-  it "encrypts the same way that apache does" do
-    apache_result = "a secret"
-    pt = HTAuth::Plaintext.new
-    _(pt.encode("a secret")).must_equal apache_result
-  end
-end
-

data/spec/sha1_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe HTAuth::Sha1 do
-  it "encrypts the same way that apache does" do
-    apache_result = "{SHA}ZrnlrvmM7ZCOV3FAvM7la89NKbk="
-    sha1 = HTAuth::Sha1.new
-    _(sha1.encode("a secret")).must_equal apache_result
-  end
-end
-

data/spec/spec_helper.rb

@@ -1,25 +0,0 @@
-require 'simplecov'
-SimpleCov.start if ENV['COVERAGE']
-
-require 'minitest/autorun'
-require 'minitest/pride'
-
-PASSWD_ORIGINAL_TEST_FILE  = File.join(File.dirname(__FILE__), "test.original.passwd")
-PASSWD_ADD_TEST_FILE       = File.join(File.dirname(__FILE__), "test.add.passwd")
-PASSWD_UPDATE_TEST_FILE    = File.join(File.dirname(__FILE__), "test.update.passwd")
-PASSWD_DELETE_TEST_FILE    = File.join(File.dirname(__FILE__), "test.delete.passwd")
-PASSWD_COMMENTED_TEST_FILE = File.join(File.dirname(__FILE__), "test.comments.passwd")
-
-DIGEST_ORIGINAL_TEST_FILE  = File.join(File.dirname(__FILE__), "test.original.digest")
-DIGEST_ADD_TEST_FILE       = File.join(File.dirname(__FILE__), "test.add.digest")
-DIGEST_UPDATE_TEST_FILE    = File.join(File.dirname(__FILE__), "test.update.digest")
-DIGEST_DELETE_TEST_FILE    = File.join(File.dirname(__FILE__), "test.delete.digest")
-DIGEST_COMMENTED_TEST_FILE = File.join(File.dirname(__FILE__), "test.comments.digest")
-
-require 'stringio'
-class ConsoleIO < StringIO
-  def noecho(&block)
-    yield self
-  end
-end
-require 'htauth'

data/spec/test.add.digest

@@ -1,3 +0,0 @@
-bob:htauth:fcbeab6821d2ab3b00934c958db0fd1e
-alice:htauth:2f361db93147d84831eb34f19d05bfbb
-charlie:htauth-new:1ec9da72c45d9140949f338dc537c089

data/spec/test.add.passwd

@@ -1,3 +0,0 @@
-alice:$apr1$DghnA...$CsPcgerfsI/Ryy0AOAJtb0
-bob:SFUkhjaJc18KA
-charlie:{SHA}Cqrkk2no+ly0vYClUp49OJQahSE=

data/spec/test.delete.digest

@@ -1 +0,0 @@
-bob:htauth:fcbeab6821d2ab3b00934c958db0fd1e

data/spec/test.delete.passwd

@@ -1 +0,0 @@
-alice:$apr1$DghnA...$CsPcgerfsI/Ryy0AOAJtb0

data/spec/test.original.digest

@@ -1,2 +0,0 @@
-bob:htauth:fcbeab6821d2ab3b00934c958db0fd1e
-alice:htauth:2f361db93147d84831eb34f19d05bfbb

data/spec/test.original.passwd

@@ -1,2 +0,0 @@
-alice:$apr1$DghnA...$CsPcgerfsI/Ryy0AOAJtb0
-bob:SFUkhjaJc18KA

data/spec/test.update.digest

@@ -1,2 +0,0 @@
-bob:htauth:fcbeab6821d2ab3b00934c958db0fd1e
-alice:htauth:c32a4df25c6ecf75f3eaeb96771520de

data/spec/test.update.passwd

@@ -1,2 +0,0 @@
-alice:{SHA}GnoUUjgrLF07/6L9lW2BcaDXxB0=
-bob:SFUkhjaJc18KA

data/tasks/default.rake

@@ -1,250 +0,0 @@
-# vim: syntax=ruby
-require 'rake/clean'
-require 'digest'
-#------------------------------------------------------------------------------
-# If you want to Develop on this project just run 'rake develop' and you'll
-# have all you need to get going. If you want to use bundler for development,
-# then run 'rake develop:using_bundler'
-#------------------------------------------------------------------------------
-namespace :develop do
-
-  # Install all the development and runtime dependencies of this gem using the
-  # gemspec.
-  task :default => 'Gemfile' do
-    require 'rubygems/dependency_installer'
-    installer = ::Gem::DependencyInstaller.new
-    puts "Installing bundler..."
-    installer.install 'bundler'
-    sh 'bundle install'
-    puts "\n\nNow run 'rake test'"
-  end
-
-  # Create a Gemfile that just references the gemspec
-  file 'Gemfile' => :gemspec do
-    File.open( "Gemfile", "w+" ) do |f|
-      f.puts "# DO NOT EDIT - This file is automatically generated"
-      f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
-      f.puts 'source "https://rubygems.org"'
-      f.puts 'gemspec'
-    end
-  end
-end
-desc "Bootstrap development"
-task :develop => "develop:default"
-
-#------------------------------------------------------------------------------
-# Minitest - standard TestTask
-#------------------------------------------------------------------------------
-begin
-  require 'minitest/test_task'
-  Minitest::TestTask.create( :test) do |t|
-    t.libs << "lib"
-    t.libs << "spec"
-    t.libs << "test"
-    t.warning = true
-    t.test_globs = "{test,spec}/**/{test_*,*_spec}.rb"
-  end
-
-  task :test_requirements
-  task :test => :test_requirements
-  task :default => :test
-rescue LoadError
-  This.task_warning( 'test' )
-end
-
-#------------------------------------------------------------------------------
-# RDoc - standard rdoc rake task, although we must make sure to use a more
-#        recent version of rdoc since it is the one that has 'tomdoc' markup
-#------------------------------------------------------------------------------
-begin
-  gem 'rdoc' # otherwise we get the wrong task from stdlib
-  require 'rdoc/task'
-  RDoc::Task.new do |t|
-    t.markup   = 'tomdoc'
-    t.rdoc_dir = 'doc'
-    t.main     = 'README.md'
-    t.title    = "#{This.name} #{This.version}"
-    t.rdoc_files.include( FileList['*.{rdoc,md,txt}'], FileList['ext/**/*.c'],
-                          FileList['lib/**/*.rb'] )
-  end
-rescue StandardError, LoadError
-  This.task_warning( 'rdoc' )
-end
-
-#------------------------------------------------------------------------------
-# Coverage - optional code coverage, rcov for 1.8 and simplecov for 1.9, so
-#            for the moment only rcov is listed.
-#------------------------------------------------------------------------------
-begin
-  require 'simplecov'
-  desc 'Run tests with code coverage'
-  task :coverage do
-    ENV['COVERAGE'] = 'true'
-    Rake::Task[:test].execute
-  end
-  CLOBBER << 'coverage' if File.directory?( 'coverage' )
-rescue LoadError
-  This.task_warning( 'simplecov' )
-end
-
-#------------------------------------------------------------------------------
-# Manifest - We want an explicit list of thos files that are to be packaged in
-#            the gem. Most of this is from Hoe.
-#------------------------------------------------------------------------------
-namespace 'manifest' do
-  desc "Check the manifest"
-  task :check => :clean do
-    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
-    files = files.select{ |f| File.file?( f ) }
-
-    tmp = "Manifest.tmp"
-    File.open( tmp, 'w' ) do |f|
-      f.puts files.join("\n")
-    end
-
-    begin
-      sh "diff -du Manifest.txt #{tmp}"
-    ensure
-      rm tmp
-    end
-    puts "Manifest looks good"
-  end
-
-  desc "Generate the manifest"
-  task :generate => :clean do
-    files = %x[ git ls-files ].split("\n").sort
-    files.reject! { |f| f =~ This.exclude_from_manifest }
-    File.open( "Manifest.txt", "w" ) do |f|
-      f.puts files.join("\n")
-    end
-  end
-end
-
-#------------------------------------------------------------------------------
-# Fixme - look for fixmes and report them
-#------------------------------------------------------------------------------
-namespace :fixme do
-  task :default => 'manifest:check' do
-    This.manifest.each do |file|
-      next if file == __FILE__
-      next unless file =~ %r/(txt|rb|md|rdoc|css|html|xml|css)\Z/
-      puts "FIXME: Rename #{file}" if file =~ /fixme/i
-      IO.readlines( file ).each_with_index do |line, idx|
-        prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
-        puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
-      end
-    end
-  end
-
-  def fixme_project_root
-    This.project_path( '../fixme' )
-  end
-
-  def fixme_project_path( subtree )
-    fixme_project_root.join( subtree )
-  end
-
-  def local_fixme_files
-    local_files = This.manifest.select { |p| p =~ %r|^tasks/| }
-    local_files << ".semaphore/semaphore.yml"
-  end
-
-  def outdated_fixme_files
-    local_fixme_files.select do |local|
-      upstream     = fixme_project_path( local )
-      if upstream.exist? then
-        if File.exist?( local ) then
-          ( Digest::SHA256.file( local ) != Digest::SHA256.file( upstream ) )
-        else
-          true
-        end
-      end
-    end
-  end
-
-  def fixme_up_to_date?
-    outdated_fixme_files.empty?
-  end
-
-  desc "See if the fixme tools are outdated"
-  task :outdated do
-    if fixme_up_to_date? then
-      puts "Fixme files are up to date."
-    else
-      outdated_fixme_files.each do |f|
-        puts "#{f} is outdated"
-      end
-    end
-  end
-
-  desc "Update outdated fixme files"
-  task :update do
-    if fixme_up_to_date? then
-      puts "Fixme files are already up to date."
-    else
-      puts "Updating fixme files:"
-      outdated_fixme_files.each do |local|
-        upstream = fixme_project_path( local )
-        puts "  * #{local}"
-        FileUtils.cp( upstream, local )
-      end
-      puts "Use your git commands as appropriate."
-    end
-  end
-end
-desc "Look for fixmes and report them"
-task :fixme => "fixme:default"
-
-#------------------------------------------------------------------------------
-# Gem Specification
-#------------------------------------------------------------------------------
-# Really this is only here to support those who use bundler
-desc "Build the #{This.name}.gemspec file"
-task :gemspec do
-  File.open( This.gemspec_file, "wb+" ) do |f|
-    f.puts "# DO NOT EDIT - This file is automatically generated"
-    f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
-    f.write This.platform_gemspec.to_ruby
-  end
-end
-
-# .rbc files from ruby 2.0
-CLOBBER << "**/*.rbc"
-
-# The standard gem packaging task, everyone has it.
-require 'rubygems/package_task'
-::Gem::PackageTask.new( This.platform_gemspec ) do
-  # nothing
-end
-
-#------------------------------------------------------------------------------
-# Release - the steps we go through to do a final release, this is pulled from
-#           a compbination of mojombo's rakegem, hoe and hoe-git
-#
-# 1) make sure we are on the main branch
-# 2) make sure there are no uncommitted items
-# 3) check the manifest and make sure all looks good
-# 4) build the gem
-# 5) do an empty commit to have the commit message of the version
-# 6) tag that commit as the version
-# 7) push main
-# 8) push the tag
-# 7) pus the gem
-#------------------------------------------------------------------------------
-task :release_check do
-  unless `git branch` =~ /^\* main/
-    abort "You must be on the main branch to release!"
-  end
-  unless `git status` =~ /^nothing to commit/m
-    abort "Nope, sorry, you have unfinished business"
-  end
-end
-
-desc "Create tag v#{This.version}, build and push #{This.platform_gemspec.full_name} to rubygems.org"
-task :release => [ :release_check, 'manifest:check', :gem ] do
-  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
-  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
-  sh "git push origin main"
-  sh "git push origin v#{This.version}"
-  sh "gem push pkg/#{This.platform_gemspec.full_name}.gem"
-end

data/tasks/this.rb

@@ -1,208 +0,0 @@
-require 'pathname'
-
-# Public: A Class containing all the metadata and utilities needed to manage a
-# ruby project.
-class ThisProject
-  # The name of this project
-  attr_accessor :name
-
-  # The author's name
-  attr_accessor :author
-
-  # The email address of the author(s)
-  attr_accessor :email
-
-  # The homepage of this project
-  attr_accessor :homepage
-
-  # The regex of files to exclude from the manifest
-  attr_accessor :exclude_from_manifest
-
-  # The hash of Gem::Specifications keyed' by platform
-  attr_accessor :gemspecs
-
-  # Public: Initialize ThisProject
-  #
-  # Yields self
-  def initialize(&block)
-    @exclude_from_manifest = Regexp.union(/\.(git|DS_Store|semaphore)/,
-                                          /^(doc|coverage|pkg|tmp|Gemfile(\.lock)?)/,
-                                          /^[^\/]+\.gemspec/,
-                                          /\.(swp|jar|bundle|so|rvmrc|travis.yml|byebug_history|fossa.yml|ruby-version)$/,
-                                          /~$/)
-    @gemspecs              = Hash.new
-    yield self if block_given?
-  end
-
-  # Public: return the version of ThisProject
-  #
-  # Search the ruby files in the project looking for the one that has the
-  # version string in it. This does not eval any code in the project, it parses
-  # the source code looking for the string.
-  #
-  # Returns a String version
-  def version
-    [ "lib/#{ name }.rb", "lib/#{ name }/version.rb" ].each do |v|
-      path = project_path( v )
-      line = path.read[/^\s*VERSION\s*=\s*.*/]
-      if line then
-        return line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
-      end
-    end
-  end
-
-  # Internal: Return a section of an RDoc file with the given section name
-  #
-  # path         - the relative path in the project of the file to parse
-  # section_name - the section out of the file from which to parse data
-  #
-  # Retuns the text of the section as an array of paragrphs.
-  def section_of( file, section_name )
-    re    = /^[=#]+ (.*)$/
-    sectional = project_path( file )
-    parts = sectional.read.split( re )[1..-1]
-    parts.map! { |p| p.strip }
-
-    sections = Hash.new
-    Hash[*parts].each do |k,v|
-      sections[k] = v.split("\n\n")
-    end
-    return sections[section_name]
-  end
-
-  # Internal: print out a warning about the give task
-  def task_warning( task )
-    warn "WARNING: '#{task}' tasks are not defined. Please run 'rake develop'"
-  end
-
-  # Internal: Return the full path to the file that is relative to the project
-  # root.
-  #
-  # path - the relative path of the file from the project root
-  #
-  # Returns the Pathname of the file
-  def project_path( *relative_path )
-    project_root.join( *relative_path )
-  end
-
-  # Internal: The absolute path of this file
-  #
-  # Returns the Pathname of this file.
-  def this_file_path
-    Pathname.new( __FILE__ ).expand_path
-  end
-
-  # Internal: The root directory of this project
-  #
-  # This is defined as being the directory that is in the path of this project
-  # that has the first Rakefile
-  #
-  # Returns the Pathname of the directory
-  def project_root
-    this_file_path.ascend do |p|
-      rakefile = p.join( 'Rakefile' )
-      return p if rakefile.exist?
-    end
-  end
-
-  # Internal: Returns the contents of the Manifest.txt file as an array
-  #
-  # Returns an Array of strings
-  def manifest
-    manifest_file = project_path( "Manifest.txt" )
-    abort "You need a Manifest.txt" unless manifest_file.readable?
-    manifest_file.readlines.map { |l| l.strip }
-  end
-
-  # Internal: Return the files that define the extensions
-  #
-  # Returns an Array
-  def extension_conf_files
-    manifest.grep( /extconf.rb\Z/ )
-  end
-
-  # Internal: Returns the gemspace associated with the current ruby platform
-  def platform_gemspec
-    gemspecs.fetch(platform) { This.ruby_gemspec }
-  end
-
-  def core_gemspec
-    Gem::Specification.new do |spec|
-      spec.name        = name
-      spec.version     = version
-      spec.author      = author
-      spec.email       = email
-      spec.homepage    = homepage
-
-      spec.summary     = summary
-      spec.description = description
-      spec.license     = license
-
-      spec.files       = manifest
-      spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
-      spec.test_files  = spec.files.grep(/^spec/)
-
-      spec.extra_rdoc_files += spec.files.grep(/(txt|rdoc|md)$/)
-      spec.rdoc_options = [ "--main"  , 'README.md',
-                            "--markup", "tomdoc" ]
-
-      spec.required_ruby_version = '>= 2.3.0'
-    end
-  end
-
-  # Internal: Return the gemspec for the ruby platform
-  def ruby_gemspec( core = core_gemspec, &block )
-    yielding_gemspec( 'ruby', core, &block )
-  end
-
-  # Internal: Return the gemspec for the jruby platform
-  def java_gemspec( core = core_gemspec, &block )
-    yielding_gemspec( 'java', core, &block )
-  end
-
-  # Internal: give an initial spec and a key, create a new gemspec based off of
-  # it.
-  #
-  # This will force the new gemspecs 'platform' to be that of the key, since the
-  # only reason you would have multiple gemspecs at this point is to deal with
-  # different platforms.
-  def yielding_gemspec( key, core )
-    spec = gemspecs[key] ||= core.dup
-    spec.platform = key
-    yield spec if block_given?
-    return spec
-  end
-
-  # Internal: Return the platform of ThisProject at the current moment in time.
-  def platform
-    (RUBY_PLATFORM == "java") ? 'java' : Gem::Platform::RUBY
-  end
-
-  # Internal: Return the DESCRIPTION section of the README.rdoc file
-  def description_section
-    section_of( 'README.md', 'DESCRIPTION')
-  end
-
-  # Internal: Return the summary text from the README
-  def summary
-    description_section.first
-  end
-
-  # Internal: Return the full description text from the README
-  def description
-    description_section.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc
-  end
-
-  def license
-    license_file = project_path("LICENSE")
-    line = license_file.readlines.first
-    line.split(/\s+/).first
-  end
-
-  # Internal: The path to the gemspec file
-  def gemspec_file
-    project_path( "#{ name }.gemspec" )
-  end
-end
-
-This = ThisProject.new