dionysus 1.0.2 → 2.0.0

data/lib/dionysus/rdoc/markdown.rb

@@ -1,64 +0,0 @@
-require 'active_support/concern'
-begin
-  Markdown
-rescue NameError
-  require 'rdiscount'
-end
-
-module RDoc # :nodoc:
-  ##
-  # Extend RDoc to support Markdown files.  It will automatically use Markdown
-  # for any files with the `.md` or `.markdown` extension.  You may also specify
-  # files with `RDoc::Markdown.files`
-  #
-  # After RDoc is loaded:
-  #
-  #     require 'dionysus/rdoc/markdown'
-  #     RDoc::Markdown.files.include('README')
-  module Markdown
-    FILE_NAMES = Rake::FileList.new
-    
-    def self.files() FILE_NAMES; end
-    
-    def self.markdown_for_file?(file_name)
-      %w(.md .markdown).include?(File.extname(file_name)) or
-        self.files.resolve.to_a.include?(file_name)
-    end
-    
-    module Parser # :nodoc:
-      extend ActiveSupport::Concern
-      
-      included do
-        class << self
-          alias_method :can_parse_without_markdown, :can_parse
-          alias_method :can_parse, :can_parse_with_markdown
-        end
-      end
-      
-      module ClassMethods # :nodoc:
-        def can_parse_with_markdown(file_name)
-          result = can_parse_without_markdown(file_name)
-          if result.nil? and Markdown.markdown_for_file?(file_name)
-            ::RDoc::Parser::Simple
-          else
-            result
-          end
-        end
-      end
-    end
-    
-    module TopLevel # :nodoc:
-      extend ActiveSupport::Concern
-      
-      module InstanceMethods # :nodoc:
-        def description
-          return super unless Markdown.markdown_for_file?(full_name)
-          ::Markdown.new(File.read(::RDoc::RDoc.current.generator.basedir + full_name)).to_html
-        end
-      end
-    end
-  end
-end
-
-RDoc::TopLevel.send(:include, RDoc::Markdown::TopLevel)
-RDoc::Parser.send(:include, RDoc::Markdown::Parser)

data/lib/dionysus/rdoc/no_markup.rb

@@ -1,56 +0,0 @@
-require 'active_support/concern'
-
-module RDoc # :nodoc:
-  ##
-  # Extend RDoc to support plaintext files that will be displayed inside a <pre> block.
-  #
-  # After RDoc is loaded:
-  #
-  #     require 'dionysus/rdoc/no_markup'
-  #     RDoc::NoMarkup.files.include('LICENSE','VERSION')
-  module NoMarkup
-    FILE_NAMES = Rake::FileList.new
-    
-    def self.files() FILE_NAMES; end
-    
-    def self.no_markup_for_file?(file_name)
-      self.files.resolve.to_a.include?(file_name)
-    end
-    
-    module Parser # :nodoc:
-      extend ActiveSupport::Concern
-      
-      included do
-        class << self
-          alias_method :can_parse_with_markup, :can_parse
-          alias_method :can_parse, :can_parse_without_markup
-        end
-      end
-      
-      module ClassMethods # :nodoc:
-        def can_parse_without_markup(file_name)
-          if NoMarkup.no_markup_for_file?(file_name)
-            ::RDoc::Parser::Simple
-          else
-            can_parse_with_markup(file_name)
-          end
-        end
-      end
-    end
-    
-    module TopLevel # :nodoc:
-      extend ActiveSupport::Concern
-      
-      module InstanceMethods # :nodoc:
-        def description
-          return super unless NoMarkup.no_markup_for_file?(full_name)
-          txt = File.read(::RDoc::RDoc.current.generator.basedir + full_name)
-          %(<pre>#{txt}</pre>)
-        end
-      end
-    end
-  end
-end
-
-RDoc::TopLevel.send(:include, RDoc::NoMarkup::TopLevel)
-RDoc::Parser.send(:include, RDoc::NoMarkup::Parser)

data/lib/dionysus/security.rb

@@ -1,3 +0,0 @@
-require 'dionysus'
-require 'dionysus/security/string'
-require 'dionysus/security/password_salt'

data/lib/dionysus/security/password_salt.rb

@@ -1,138 +0,0 @@
-require 'dionysus'
-require 'active_support/secure_random'
-
-##
-# Encapsulates a password salt.  This is usually not required specifically, 
-# instead it's required as a part of the security module:
-#
-#     require 'dionysus/security'
-#
-# However, you may require it specifically:
-#
-#     require 'dionysus/security/password_salt'
-#
-# Examples
-#
-#     salt = PasswordSalt.new
-#     #=> generates random salt of 8 characters
-#     salt.salt_password('foobar') #=> 'foobar0PD0oKAj'
-#
-#     salt = PasswordSalt.new(:length => 20)
-#     #=> generates random salt of 20 characters
-#     salt.salt_password('foobar') #=> 'foobar7qvFpfi+3jGVFaA5TaE7'
-#
-#     salt = PasswordSalt.new('ABCDEFG', :beginning)
-#     #=> generates salt 'abcdef' with beginning placement
-#     salt.salt_password('foobar')
-#     #=> 'ABCDEFGfoobar'
-#
-#     salt = PasswordSalt.new(:split, :length => 10)
-#     #=> generates random salt of 10 characters with split placement
-#     salt.salt_password('foobar')
-#     #=> 'WyVjpfoobarjGYXJ'
-class PasswordSalt
-  PLACEMENTS = [:before, :after, :split]
-  DEFAULT_LENGTH = 8
-  DEFAULT_PLACEMENT = :after
-  
-  @@secure_random = SecureRandom
-  cattr_accessor :secure_random
-  
-  attr_accessor :string
-  attr_reader   :placement
-  
-  ##
-  # Generate a salt string of the given length (Default: 8) with the base64 
-  # character set.  Optionally, you may pass the format as <tt>:binary</tt> to generate
-  # a binary salt.
-  def self.generate( length = DEFAULT_LENGTH, format = :base64 )
-    if length < 0
-      raise ArgumentError, "Invalid length: #{length}"
-    end
-    
-    case format.to_sym
-    when :base64
-      self.secure_random.base64(length)[0...length]
-    when :binary
-      self.secure_random.random_bytes(length)
-    else
-      raise ArgumentError, "Invalid format: #{format}"
-    end
-  end
-  
-  ##
-  # Initialize a new PasswordSalt
-  #
-  # If you pass the first argument as a string, the string will be set as 
-  # the salt:
-  #     PasswordSalt.new('ABCDEFG')
-  #
-  # If the first argument is <tt>:new</tt> or is an option hash, a random salt
-  # will be generated:
-  #     PasswordSalt.new(:new)
-  #     PasswordSalt.new(:length => 20)
-  #     PasswordSalt.new
-  #
-  # If the first or second argument is a Symbol (other than <tt>:new</tt>), it 
-  # will be interpreted as the placement:
-  #     PasswordSalt.new(:before)
-  #     PasswordSalt.new(:new, :before)
-  #     PasswordSalt.new('ABCDEFG', :before)
-  #
-  # You may always pass in an options hash as the last argument.
-  # [length]    Length of salt to be generated.
-  #             Default: 8
-  def initialize( *args )
-    options = args.extract_options!
-    
-    self.string = args.detect { |val| val.is_a?(String) or val == :new }
-    self.placement = args.detect { |val| PLACEMENTS.include?(val) } || DEFAULT_PLACEMENT
-    
-    if self.string == :new or self.string.nil?
-      self.string = self.class.generate(options[:length] || DEFAULT_LENGTH)
-    end
-  end
-  
-  ##
-  # Returns the given password, but salted.
-  def salt_password( password )
-    case self.placement
-    when :after
-      password.to_s + string
-    when :before
-      string + password.to_s
-    when :split
-      string[0...(string.length/2).floor] + 
-        password.to_s + 
-        string[(string.length/2).floor...string.length]
-    else
-      raise "Invalid salt placement: #{self.placement}"
-    end
-  end
-  
-  ##
-  # Set the salt's placement
-  # 
-  # [after]   Place the salt after the password.
-  # [before]  Place the salt before the password.
-  # [split]   Place half of the salt before and half after the password.  For
-  #           salts of odd length, the shorter half will be in front.
-  def placement=( sym )
-    unless PLACEMENTS.include?(sym.to_sym)
-      raise ArgumentError, "Invalid salt placement: #{sym}"
-    end
-    @placement = sym.to_sym
-  end
-  
-  ##
-  # Returns the salt string.
-  def to_s
-    self.string
-  end
-  
-  ##
-  # Returns +true+ if the given salt is equivilent to this salt, +false+ otherwise
-  def eql?( salt )
-    self.to_s.eql?(salt.to_s) && self.placement.eql?(salt.placement)
-  end
-end

data/lib/dionysus/security/string.rb

@@ -1,126 +0,0 @@
-require 'dionysus'
-require 'dionysus/digest'
-require 'dionysus/string'
-require 'dionysus/security/password_salt'
-require 'dionysus/version_string'
-
-##
-# Adds String hashing and salting convenience methods.
-#
-#   require 'dionysus/security/string'
-#
-# The hash methods may be accessed by the <tt>digest</tt> method or by the 
-# dynamic convenience methods.
-#
-# Examples:
-# 
-#     'my password'.digest(:sha1)
-#     'my password'.sha1
-class String
-  ##
-  # Generate a random, binary salt with the given length (default 16)
-  def self.salt( length = 16 )
-    PasswordSalt.generate(length, :binary).to_s
-  end
-  
-  ##
-  # Sanitize the String from memory.  This is non-reversible.  Runs 7 passes 
-  # by default.
-  #
-  # NOTE: In Ruby 1.9, this uses the String#setbyte(index, int) method.  In Ruby < 1.9, this 
-  # uses String#[]=(int)
-  #
-  def sanitize( passes = 7 )
-    if RUBY_VERSION.satisfies?('< 1.9')
-      passes.times do
-        (0...self.length).each { |i| self[i] = rand(256) }
-      end
-      (0...self.length).each { |i| self[i] = 0 }
-      self.delete!("\000")
-    elsif RUBY_VERSION.satisfies?('>= 1.9')
-      passes.times do
-        (0...self.length).each { |i| self.setbyte(i, rand(256)) }
-      end
-      (0...self.length).each { |i| self.setbyte(i, 0) }
-      self.clear
-    end
-  end
-  
-  ##
-  # Generate the given digest hash.
-  # 
-  # Options:
-  # [salt]      Salt to append to the string. (This may be a String or a 
-  #             PasswordSalt object) Default: ''
-  # [encoding]  Encoding for the hash: <tt>:binary</tt>, <tt>:hex</tt>, 
-  #             <tt>:hexidecimal</tt>, <tt>:base64</tt>
-  #             Default: <tt>:base64</tt>
-  def digest( klass, options = {} )
-    digest = Digest.digest(klass, _salted(options[:salt]))
-    _encode(digest, options[:encoding] || :base64)
-  end
-  
-  ##
-  # Call the appropriate digest method.
-  def method_missing( method, *args )
-    super if block_given?
-    
-    if Digest.available_digests.include?(method)
-      self.digest(method, *args)
-    else
-      super
-    end
-  end
-  
-  ##
-  # Detect the digest of the string.  Returns nil if the digest cannot be 
-  # determined.
-  #
-  # Example:
-  #     "wxeCFXPVXePFcpwuFDjonyn1G/w=".detect_digest(:base64) #=> :sha1
-  #     "foobar".detect_digest(:hex) #=> nil
-  def detect_digest( encoding )
-    Digest.detect_digest(self, encoding)
-  end
-  
-  ##
-  # Detect the digest of the string.  Raises "Unknown digest" if the digest
-  # cannot be determined.
-  #
-  # Example:
-  #     "wxeCFXPVXePFcpwuFDjonyn1G/w=".detect_digest!(:base64) #=> :sha1
-  #     "foobar".detect_digest!(:hex) #=> RuntimeError
-  def detect_digest!( encoding )
-    Digest.detect_digest!(self, encoding)
-  end
-  
-  private
-  
-  ##
-  # Salt the string by appending it to the end or utilizing the 
-  # PasswordSalt's salt_password method
-  def _salted( salt )
-    return self if salt.blank?
-    
-    unless salt.is_a?(PasswordSalt)
-      salt = PasswordSalt.new(salt)
-    end
-    
-    salt.salt_password(self)
-  end
-  
-  ##
-  # Encode the value to the given encoding
-  def _encode( value, encoding )
-    case encoding
-    when :binary
-      value
-    when :base64
-      value.encode64s
-    when :hex, :hexidecimal
-      value.encode_hex
-    else
-      raise ArgumentError, "Invalid encoding: #{encoding}"
-    end
-  end
-end

data/lib/dionysus/string.rb

@@ -1,48 +0,0 @@
-require 'dionysus'
-require 'active_support/base64'
-
-##
-# Adds string encoding convenience methods.
-#
-#     require 'dionysus/string'
-class String
-  HEX_REGEXP = /^[a-f0-9]+$/
-  BASE64_REGEXP = /^[A-Za-z0-9\+\/\=]+$/
-  ENCODING_BITS_PER_CHAR = {:binary => 8, :base64 => 6, :hex => 4, :hexidecimal => 4}
-  
-  ##
-  # Encode the Base64 (without newlines)
-  def encode64s() Base64.encode64s(self); end
-  
-  ##
-  # Encode to Base 64
-  def encode64() Base64.encode64(self); end
-  
-  ##
-  # Decode from Base 64
-  def decode64() Base64.decode64(self); end
-  
-  ##
-  # Encode to hexidecimal
-  def encode_hexidecimal() self.unpack('H*').first; end
-  alias_method :encode_hex, :encode_hexidecimal
-  
-  ##
-  # Decode from hexidecimal
-  def decode_hexidecimal() [self].pack('H*'); end
-  alias_method :decode_hex, :decode_hexidecimal
-  
-  ##
-  # Detect the encoding of the string
-  def detect_encoding
-    return nil if blank?
-
-    if match(HEX_REGEXP)
-      :hex
-    elsif match(BASE64_REGEXP)
-      :base64
-    else
-      :binary
-    end
-  end
-end

data/lib/dionysus/version_string.rb

@@ -1,96 +0,0 @@
-require 'dionysus'
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/core_ext/module/delegation'
-
-module Dionysus
-  ##
-  # = VersonString
-  #
-  #     require 'dionysus/version_string'
-  #
-  # VersionString is a proxy to Gem::Version that modifies the comparable 
-  # interface on String to compare based on the Gem::Version comparator.  
-  # It also adds a +satisfies?+ method to check for a Gem::Requirement.
-  #
-  # In addition, requiring VersionString changes the +RUBY_VERSION+ constant 
-  # into a VersionString. Because VersionString "is a" String, there should be
-  # no ill-effects with this change since only the Comparable interface is 
-  # overriden and this does not change the original operation of the == method.
-  #
-  # The comparator works by converting strings into Gem::Version objects, so 
-  # this still works as you would expect:
-  #
-  #     RUBY_VERSION < '1.9'
-  class VersionString < String
-    include Comparable
-
-    ##
-    # Initializes a VersionString and freezes itself.
-    def initialize(*args)
-      super(*args)
-      to_rubygem_version
-      freeze
-    end
-
-    ##
-    # Compares this VersionString to another String, VersionString, or 
-    # Gem::Version.
-    #
-    # Examples:
-    #
-    #     Dionysus::VersionString.new('1.0') > '1.0' => false
-    #     Dionysus::VersionString.new('1.0') == Gem::Version('1.0') => true
-    #     Dionysus::VersionString.new('1.0') <=> Dionysus::VersionString.new('1.0') => 0
-    #
-    # See http://rubygems.rubyforge.org/rubygems-update/Gem/Version.html
-    def <=>( obj )
-      obj = obj.dup
-      if obj.is_a?(String) or obj.is_a?(Gem::Version)
-        obj = Gem::Version.create(obj)
-      else
-        raise ArgumentError, "Can only compare to a Dionysus::VersionString/String or Gem::Version"
-      end
-
-      self.to_rubygem_version <=> obj
-    end
-    alias_method :"eql?", :"=="
-
-    ##
-    # Determines if the given requirement String or Gem::Requirement is 
-    # satisfied by this version.
-    #
-    # Examples:
-    #
-    #   Dionysus::VersionString.new('1.6.7').satisfies? '~> 1.6.0' => true
-    #   Dionysus::VersionString.new('1.6.7').satisfies? Gem::Requirement('< 1.6') => false
-    #
-    # See http://rubygems.rubyforge.org/rubygems-update/Gem/Requirement.html
-    def satisfies?( requirement )
-      requirement = requirement.dup
-      if requirement.is_a?(String) or requirement.is_a?(Gem::Requirement)
-        requirement = Gem::Requirement.create(requirement)
-      else
-        raise ArgumentError, "Can only compare to a String or Gem::Requirement"
-      end
-
-      requirement.satisfied_by?(to_rubygem_version)
-    end
-
-    ##
-    # Converts this VersionString into a Gem::Version
-    def to_rubygem_version
-      @rubygem_version ||= Gem::Version.create(self)
-    end
-    alias_method :to_gem_version, :to_rubygem_version
-
-    ##
-    # Indicates whether this VersionString is a prerelease.
-    #
-    # See http://rubygems.rubyforge.org/rubygems-update/Gem/Version.html#method-i-prerelease%3F
-    def prerelease?() to_rubygem_version.prerelease?; end
-  end
-end
-
-silence_warnings do
-  RUBY_VERSION = Dionysus::VersionString.new(RUBY_VERSION)
-end