challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/rubygems/backports/source_index.rb

@@ -0,0 +1,370 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'rubygems/specification'
+
+##
+# The SourceIndex object indexes all the gems available from a
+# particular source (e.g. a list of gem directories, or a remote
+# source).  A SourceIndex maps a gem full name to a gem
+# specification.
+#
+# NOTE:: The class used to be named Cache, but that became
+#        confusing when cached source fetchers where introduced. The
+#        constant Gem::Cache is an alias for this class to allow old
+#        YAMLized source index objects to load properly.
+
+class Gem::SourceIndex
+  # Undef old methods
+  alias old_initialize initialize
+  undef old_initialize
+  %w(all_gems prerelease_gems load_gems_in latest_specs prerelease_specs
+      released_specs add_spec add_specs remove_spec each specification
+      index_signature gem_signature size length find_name search released_gems
+      refresh! outdated == dump gems spec_dirs spec_dirs=).each do |meth|
+    undef_method(meth) if method_defined?(meth)
+  end
+
+  include Enumerable
+
+  attr_reader :gems # :nodoc:
+
+  ##
+  # Directories to use to refresh this SourceIndex when calling refresh!
+
+  attr_accessor :spec_dirs
+
+  class << self
+    # Undef old methods
+    %w(from_installed_gems installed_spec_directories
+        from_gems_in load_specification).each do |meth|
+      if instance_methods(true).find {|m| m.to_s == meth }
+        undef_method(meth)
+      end
+    end
+
+    ##
+    # Factory method to construct a source index instance for a given
+    # path.
+    #
+    # deprecated::
+    #   If supplied, from_installed_gems will act just like
+    #   +from_gems_in+.  This argument is deprecated and is provided
+    #   just for backwards compatibility, and should not generally
+    #   be used.
+    #
+    # return::
+    #   SourceIndex instance
+
+    def from_installed_gems(*deprecated)
+      if deprecated.empty?
+        from_gems_in(*installed_spec_directories)
+      else
+        from_gems_in(*deprecated) # HACK warn
+      end
+    end
+
+    ##
+    # Returns a list of directories from Gem.path that contain specifications.
+
+    def installed_spec_directories
+      Gem.path.collect { |dir| File.join(dir, "specifications") }
+    end
+
+    ##
+    # Creates a new SourceIndex from the ruby format gem specifications in
+    # +spec_dirs+.
+
+    def from_gems_in(*spec_dirs)
+      source_index = new
+      source_index.spec_dirs = spec_dirs
+      source_index.refresh!
+    end
+
+    ##
+    # Loads a ruby-format specification from +file_name+ and returns the
+    # loaded spec.
+
+    def load_specification(file_name)
+      Gem::Specification.load file_name
+    end
+
+  end
+
+  ##
+  # Constructs a source index instance from the provided specifications, which
+  # is a Hash of gem full names and Gem::Specifications.
+  #--
+  # TODO merge @gems and @prerelease_gems and provide a separate method
+  # #prerelease_gems
+
+  def initialize(specifications={})
+    @gems = {}
+    specifications.each{ |full_name, spec| add_spec spec }
+    @spec_dirs = nil
+  end
+
+  # TODO: remove method
+  def all_gems
+    @gems
+  end
+
+  def prerelease_gems
+    @gems.reject{ |name, gem| !gem.version.prerelease? }
+  end
+
+  def released_gems
+    @gems.reject{ |name, gem| gem.version.prerelease? }
+  end
+
+  ##
+  # Reconstruct the source index from the specifications in +spec_dirs+.
+
+  def load_gems_in(*spec_dirs)
+    @gems.clear
+
+    spec_dirs.reverse_each do |spec_dir|
+      spec_files = Dir.glob File.join(spec_dir, '*.gemspec')
+
+      spec_files.each do |spec_file|
+        gemspec = Gem::Specification.load spec_file
+        add_spec gemspec if gemspec
+      end
+    end
+
+    self
+  end
+
+  ##
+  # Returns an Array specifications for the latest released versions
+  # of each gem in this index.
+
+  def latest_specs(include_prerelease=false)
+    result = Hash.new { |h,k| h[k] = [] }
+    latest = {}
+
+    sort.each do |_, spec|
+      name = spec.name
+      curr_ver = spec.version
+      prev_ver = latest.key?(name) ? latest[name].version : nil
+
+      next if !include_prerelease && curr_ver.prerelease?
+      next unless prev_ver.nil? or curr_ver >= prev_ver or
+                  latest[name].platform != Gem::Platform::RUBY
+
+      if prev_ver.nil? or
+         (curr_ver > prev_ver and spec.platform == Gem::Platform::RUBY) then
+        result[name].clear
+        latest[name] = spec
+      end
+
+      if spec.platform != Gem::Platform::RUBY then
+        result[name].delete_if do |result_spec|
+          result_spec.platform == spec.platform
+        end
+      end
+
+      result[name] << spec
+    end
+
+    # TODO: why is this a hash while @gems is an array? Seems like
+    # structural similarity would be good.
+    result.values.flatten
+  end
+
+  ##
+  # An array including only the prerelease gemspecs
+
+  def prerelease_specs
+    prerelease_gems.values
+  end
+
+  ##
+  # An array including only the released gemspecs
+
+  def released_specs
+    released_gems.values
+  end
+
+  ##
+  # Add a gem specification to the source index.
+
+  def add_spec(gem_spec, name = gem_spec.full_name)
+    # No idea why, but the Indexer wants to insert them using original_name
+    # instead of full_name. So we make it an optional arg.
+    @gems[name] = gem_spec
+  end
+
+  ##
+  # Add gem specifications to the source index.
+
+  def add_specs(*gem_specs)
+    gem_specs.each do |spec|
+      add_spec spec
+    end
+  end
+
+  ##
+  # Remove a gem specification named +full_name+.
+
+  def remove_spec(full_name)
+    @gems.delete full_name
+  end
+
+  ##
+  # Iterate over the specifications in the source index.
+
+  def each(&block) # :yields: gem.full_name, gem
+    @gems.each(&block)
+  end
+
+  ##
+  # The gem specification given a full gem spec name.
+
+  def specification(full_name)
+    @gems[full_name]
+  end
+
+  ##
+  # The signature for the source index.  Changes in the signature indicate a
+  # change in the index.
+
+  def index_signature
+    require 'digest'
+
+    Digest::SHA256.new.hexdigest(@gems.keys.sort.join(',')).to_s
+  end
+
+  ##
+  # The signature for the given gem specification.
+
+  def gem_signature(gem_full_name)
+    require 'digest'
+
+    Digest::SHA256.new.hexdigest(@gems[gem_full_name].to_yaml).to_s
+  end
+
+  def size
+    @gems.size
+  end
+  alias length size
+
+  ##
+  # Find a gem by an exact match on the short name.
+
+  def find_name(gem_name, requirement = Gem::Requirement.default)
+    dep = Gem::Dependency.new gem_name, requirement
+    search dep
+  end
+
+  ##
+  # Search for a gem by Gem::Dependency +gem_pattern+.  If +only_platform+
+  # is true, only gems matching Gem::Platform.local will be returned.  An
+  # Array of matching Gem::Specification objects is returned.
+  #
+  # For backwards compatibility, a String or Regexp pattern may be passed as
+  # +gem_pattern+, and a Gem::Requirement for +platform_only+.  This
+  # behavior is deprecated and will be removed.
+
+  def search(gem_pattern, platform_only = false)
+    requirement = nil
+    only_platform = false
+
+    # TODO - Remove support and warning for legacy arguments after 2008/11
+    unless Gem::Dependency === gem_pattern
+      warn "#{Gem.location_of_caller.join ':'}:Warning: Gem::SourceIndex#search support for #{gem_pattern.class} patterns is deprecated, use #find_name"
+    end
+
+    case gem_pattern
+    when Regexp then
+      requirement = platform_only || Gem::Requirement.default
+    when Gem::Dependency then
+      only_platform = platform_only
+      requirement = gem_pattern.requirement
+
+      gem_pattern = if Regexp === gem_pattern.name then
+                      gem_pattern.name
+                    elsif gem_pattern.name.empty? then
+                      //
+                    else
+                      /^#{Regexp.escape gem_pattern.name}$/
+                    end
+    else
+      requirement = platform_only || Gem::Requirement.default
+      gem_pattern = /#{gem_pattern}/i
+    end
+
+    unless Gem::Requirement === requirement then
+      requirement = Gem::Requirement.create requirement
+    end
+
+    specs = all_gems.values.select do |spec|
+      spec.name =~ gem_pattern and
+        requirement.satisfied_by? spec.version
+    end
+
+    if only_platform then
+      specs = specs.select do |spec|
+        Gem::Platform.match spec.platform
+      end
+    end
+
+    specs.sort_by { |s| s.sort_obj }
+  end
+
+  ##
+  # Replaces the gems in the source index from specifications in the
+  # directories this source index was created from.  Raises an exception if
+  # this source index wasn't created from a directory (via from_gems_in or
+  # from_installed_gems, or having spec_dirs set).
+
+  def refresh!
+    raise 'source index not created from disk' if @spec_dirs.nil?
+    load_gems_in(*@spec_dirs)
+  end
+
+  ##
+  # Returns an Array of Gem::Specifications that are not up to date.
+
+  def outdated
+    outdateds = []
+
+    latest_specs.each do |local|
+      dependency = Gem::Dependency.new local.name, ">= #{local.version}"
+
+      fetcher = Gem::SpecFetcher.fetcher
+      remotes = fetcher.find_matching dependency
+      remotes = remotes.map { |(_, version, _), _| version }
+
+      latest = remotes.sort.last
+
+      outdateds << local.name if latest and local.version < latest
+    end
+
+    outdateds
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other and @gems == other.gems
+  end
+
+  def dump
+    Marshal.dump(self)
+  end
+
+end
+
+# :stopdoc:
+module Gem
+
+  ##
+  # Cache is an alias for SourceIndex to allow older YAMLized source index
+  # objects to load properly.
+
+  Cache = SourceIndex unless defined?(Cache)
+
+end
+# :startdoc:

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/rubygems/backports.rb

@@ -0,0 +1,8 @@
+begin
+  require 'rubygems'
+  if defined?(Gem::VERSION) && Gem::VERSION >= '1.8.0'
+    require File.dirname(__FILE__) + '/backports/gem'
+    require File.dirname(__FILE__) + '/backports/source_index'
+  end
+rescue LoadError
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/rubygems/doc_manager.rb

@@ -0,0 +1,88 @@
+begin
+  require 'rubygems/user_interaction'
+  require 'rubygems/doc_manager'
+rescue LoadError
+end
+
+class Gem::DocManager
+  def self.load_yardoc
+    require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. .. yard)))
+  end
+
+  def run_yardoc(*args)
+    args << '--quiet'
+    args << '--backtrace' if Gem.configuration.backtrace
+    unless File.file?(File.join(@spec.full_gem_path, '.yardopts'))
+      args << @spec.require_paths
+      if @spec.extra_rdoc_files.size > 0
+        args << '-'
+        args += @spec.extra_rdoc_files
+      end
+    end
+    args = args.flatten.map {|arg| arg.to_s }
+
+    old_pwd = Dir.pwd
+    Dir.chdir(@spec.full_gem_path)
+    YARD::CLI::Yardoc.run(*args)
+  rescue Errno::EACCES => e
+    dirname = File.dirname e.message.split("-")[1].strip
+    raise Gem::FilePermissionError.new(dirname)
+  rescue => ex
+    alert_error "While generating documentation for #{@spec.full_name}"
+    ui.errs.puts "... MESSAGE:   #{ex}"
+    ui.errs.puts "... YARDOC args: #{args.join(' ')}"
+    ui.errs.puts "\t#{ex.backtrace.join("\n\t")}" if Gem.configuration.backtrace
+    ui.errs.puts "(continuing with the rest of the installation)"
+  ensure
+    Dir.chdir(old_pwd)
+  end
+
+  begin undef setup_rdoc; rescue NameError; end
+  def setup_rdoc
+    if File.exist?(@doc_dir) && !File.writable?(@doc_dir) then
+      raise Gem::FilePermissionError.new(@doc_dir)
+    end
+
+    FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
+
+    self.class.load_rdoc if @spec.has_rdoc?
+    self.class.load_yardoc if @spec.has_yardoc?
+  end
+
+  def install_yardoc
+    rdoc_dir = File.join(@doc_dir, 'rdoc')
+
+    FileUtils.rm_rf rdoc_dir
+
+    say "Installing YARD documentation for #{@spec.full_name}..."
+    run_yardoc '-o', rdoc_dir
+  end
+
+  def install_ri_yard
+    install_ri_yard_orig if @spec.has_rdoc?
+    return if @spec.has_rdoc? == false
+    return if @spec.has_yardoc?
+
+    self.class.load_yardoc
+    say "Building YARD (yri) index for #{@spec.full_name}..."
+    run_yardoc '-c', '-n'
+  end
+
+  begin
+    alias install_ri_yard_orig install_ri
+    alias install_ri install_ri_yard
+  rescue NameError; end
+
+  def install_rdoc_yard
+    if @spec.has_rdoc?
+      install_rdoc_yard_orig
+    elsif @spec.has_yardoc?
+      install_yardoc
+    end
+  end
+
+  begin
+    alias install_rdoc_yard_orig install_rdoc
+    alias install_rdoc install_rdoc_yard
+  rescue NameError; end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/rubygems/specification.rb

@@ -0,0 +1,41 @@
+require 'rubygems/specification'
+
+class Gem::Specification
+  # @since 0.5.3
+  def has_yardoc=(value)
+    @has_rdoc = value ? 'yard' : false
+  end
+
+  def has_yardoc
+    @has_rdoc == 'yard'
+  end
+
+  undef has_rdoc?
+  def has_rdoc?
+    (@has_rdoc ||= true) && @has_rdoc != 'yard'
+  end
+
+  alias has_yardoc? has_yardoc
+
+  # has_rdoc should not be ignored!
+  if respond_to?(:overwrite_accessor)
+    overwrite_accessor(:has_rdoc) { @has_rdoc ||= true }
+    overwrite_accessor(:has_rdoc=) {|v| @has_rdoc = v }
+  else
+    attr_accessor :has_rdoc
+  end
+
+  if defined?(Gem::VERSION) && Gem::VERSION >= '1.7.'
+    def _dump_with_rdoc(limit)
+      dmp = _dump_without_rdoc(limit)
+      dmp[15] = @has_rdoc if dmp[15] == true
+      dmp
+    end
+    alias _dump_without_rdoc _dump
+    alias _dump _dump_with_rdoc
+
+    @@default_value[:has_rdoc] = true if defined?(@@default_value)
+    @@attributes << 'has_rdoc' if defined?(@@attributes)
+    @@nil_attributes << 'has_rdoc' if defined?(@@nil_attributes)
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/serializers/base.rb

@@ -0,0 +1,80 @@
+module YARD
+  module Serializers
+    # The abstract base serializer. Serializers allow templates to be
+    # rendered to various endpoints. For instance, a {FileSystemSerializer}
+    # would allow template contents to be written to the filesystem
+    #
+    # To implement a custom serializer, override the following methods:
+    # * {#serialize}
+    # * {#serialized_path}
+    #
+    # Optionally, a serializer can implement before and after filters:
+    # * {#before_serialize}
+    # * {#after_serialize}
+    #
+    # @abstract Override this class to implement a custom serializer.
+    class Base
+      # All serializer options are saved so they can be passed to other serializers.
+      #
+      # @return [SymbolHash] the serializer options
+      attr_reader :options
+
+      # @group Creating a New Serializer
+
+      # Creates a new serializer with options
+      #
+      # @param [Hash] opts the options to assign to {#options}
+      def initialize(opts = {})
+        @options = SymbolHash.new(false).update(opts)
+      end
+
+      # @group Serializing an Object
+
+      # Serializes an object.
+      #
+      # @abstract This method should implement the logic that serializes
+      #   +data+ to the respective endpoint. This method should also call
+      #   the before and after callbacks {#before_serialize} and {#after_serialize}
+      # @param [CodeObjects::Base, String] object the object to serialize the
+      #   data for. The object can also be a string (for non-object serialization)
+      # @param [String] data the contents that should be serialized
+      def serialize(object, data) end
+
+      # The serialized path of an object
+      #
+      # @abstract This method should return the path of the object on the
+      #   endpoint. For instance, for a file serializer, this should return
+      #   the filename that represents the object on disk.
+      # @param [CodeObjects::Base] object the object to return a path for
+      # @return [String] the serialized path of an object
+      def serialized_path(object) end
+
+      # Returns whether an object has been serialized
+      #
+      # @abstract This method should return whether the endpoint already exists.
+      #   For instance, a file system serializer would check if the file exists
+      #   on disk. You will most likely use +#basepath+ and {#serialized_path} to
+      #   get the endpoint's location.
+      # @param [CodeObjects::Base] object the object to check existence of
+      # @return [Boolean] whether the endpoint exists.
+      # @since 0.6.0
+      def exists?(object) false end
+
+      # @group Callbacks
+
+      # Called before serialization.
+      #
+      # @abstract Should run code before serialization. Should return false
+      #   if serialization should not occur.
+      # @return [Boolean] whether or not serialization should occur
+      def before_serialize; end
+
+      # Called after serialization.
+      #
+      # @abstract Should run code after serialization.
+      # @param [String] data the data that was serialized.
+      # @return [void]
+      def after_serialize(data); end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/serializers/file_system_serializer.rb

@@ -0,0 +1,90 @@
+module YARD
+  module Serializers
+    # Implements a serializer that reads from and writes to the filesystem.
+    class FileSystemSerializer < Base
+      # The base path to write data to.
+      # @return [String] a base path
+      attr_reader :basepath
+
+      def basepath=(value)
+        @basepath = options[:basepath] = value
+      end
+
+      # The extension of the filename (defaults to +html+)
+      #
+      # @return [String] the extension of the file. Empty string for no extension.
+      attr_reader :extension
+
+      def extension=(value)
+        @extension = options[:extension] = value
+      end
+
+      # Creates a new FileSystemSerializer with options
+      #
+      # @option opts [String] :basepath ('doc') the base path to write data to
+      # @option opts [String] :extension ('html') the extension of the serialized
+      #   path filename. If this is set to the empty string, no extension is used.
+      def initialize(opts = {})
+        super
+        @basepath = (options[:basepath] || 'doc').to_s
+        @extension = (options.has_key?(:extension) ? options[:extension] : 'html').to_s
+      end
+
+      # Serializes object with data to its serialized path (prefixed by the +#basepath+).
+      #
+      # @return [String] the written data (for chaining)
+      def serialize(object, data)
+        path = File.join(basepath, serialized_path(object))
+        log.debug "Serializing to #{path}"
+        File.open!(path, "wb") {|f| f.write data }
+      end
+
+      # Implements the serialized path of a code object.
+      #
+      # @param [CodeObjects::Base, CodeObjects::ExtraFileObject, String] object
+      #   the object to get a path for. The path of a string is the string itself.
+      # @return [String] if object is a String, returns
+      #   object, otherwise the path on disk (without the basepath).
+      def serialized_path(object)
+        return object if object.is_a?(String)
+
+        if object.is_a?(CodeObjects::ExtraFileObject)
+          fspath = ['file.' + object.name + (extension.empty? ? '' : ".#{extension}")]
+        else
+          objname = object != YARD::Registry.root ? object.name.to_s : "top-level-namespace"
+          objname += '_' + object.scope.to_s[0,1] if object.is_a?(CodeObjects::MethodObject)
+          fspath = [objname + (extension.empty? ? '' : ".#{extension}")]
+          if object.namespace && object.namespace.path != ""
+            fspath.unshift(*object.namespace.path.split(CodeObjects::NSEP))
+          end
+        end
+
+        File.join(encode_path_components(*fspath))
+      end
+
+      # Checks the disk for an object and returns whether it was serialized.
+      #
+      # @param [CodeObjects::Base] object the object to check
+      # @return [Boolean] whether an object has been serialized to disk
+      def exists?(object)
+        File.exist?(File.join(basepath, serialized_path(object)))
+      end
+
+      private
+
+      # Remove special chars from filenames.
+      # Windows disallows \ / : * ? " < > | but we will just remove any
+      # non alphanumeric (plus period, underscore and dash).
+      def encode_path_components(*components)
+        components.map! do |p|
+          p.gsub(/[^\w\.-]/) do |x|
+            encoded = '_'
+
+            x.each_byte { |b| encoded << ("%X" % b) }
+            encoded
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/serializers/process_serializer.rb

@@ -0,0 +1,24 @@
+module YARD
+  module Serializers
+    # Serializes an object to a process (like less)
+    #
+    # @example Serializing to a pager (less)
+    #   serializer = ProcessSerializer.new('less')
+    #   serializer.serialize(object, "data!")
+    class ProcessSerializer < Base
+      # Creates a new ProcessSerializer for the shell command +cmd+
+      #
+      # @param [String] cmd the command that will accept data on stdin
+      def initialize(cmd)
+        @cmd = cmd
+      end
+
+      # Overrides serialize behaviour and writes data to standard input
+      # of the associated command
+      def serialize(object, data)
+        IO.popen(@cmd, 'w') {|io| io.write(data) }
+      end
+    end
+  end
+end
+