challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/commands/library_index_command.rb

@@ -0,0 +1,24 @@
+module YARD
+  module Server
+    module Commands
+      # Returns the index of libraries served by the server.
+      class LibraryIndexCommand < Base
+        attr_accessor :options
+
+        def run
+          return unless path.empty?
+
+          self.options = SymbolHash.new(false).update(
+            :markup => :rdoc,
+            :format => :html,
+            :libraries => adapter.libraries,
+            :adapter => adapter,
+            :template => :doc_server,
+            :type => :library_list
+          )
+          render
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/commands/list_command.rb

@@ -0,0 +1,24 @@
+module YARD
+  module Server
+    module Commands
+      # Returns a list of objects of a specific type
+      class ListCommand < LibraryCommand
+        include Templates::Helpers::BaseHelper
+
+        def run
+          Registry.load_all
+          options.update(:objects => run_verifier(Registry.all(:class, :module)))
+          list_type = request.path.split('/').last
+          meth = "generate_#{list_type}_list"
+          tpl = fulldoc_template
+          if tpl.respond_to?(meth)
+            tpl.send(meth)
+            cache(tpl.contents)
+          else
+            not_found
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/commands/search_command.rb

@@ -0,0 +1,78 @@
+module YARD
+  module Server
+    module Commands
+      # Performs a search over the objects inside of a library and returns
+      # the results as HTML or plaintext
+      class SearchCommand < LibraryCommand
+        include Templates::Helpers::BaseHelper
+        include Templates::Helpers::ModuleHelper
+        include DocServerHelper
+
+        attr_accessor :results, :query
+
+        def run
+          Registry.load_all
+          self.query = request.query['q']
+          redirect("/#{adapter.router.docs_prefix}/#{single_library ? library : ''}") if query.nil? || query =~ /\A\s*\Z/
+          if found = Registry.at(query)
+            redirect(url_for(found))
+          end
+          search_for_object
+          request.xhr? ? serve_xhr : serve_normal
+        end
+
+        def visible_results
+          results[0, 10]
+        end
+
+        private
+
+        def url_for(object)
+          File.join('', base_path(router.docs_prefix),
+            serializer.serialized_path(object))
+        end
+
+        def serve_xhr
+          self.headers['Content-Type'] = 'text/plain'
+          self.body = visible_results.map {|o|
+            [(o.type == :method ? o.name(true) : o.name).to_s,
+             o.path,
+             o.namespace.root? ? '' : o.namespace.path,
+             url_for(o)
+            ].join(",")
+          }.join("\n")
+        end
+
+        def serve_normal
+          options.update(
+            :visible_results => visible_results,
+            :query => query,
+            :results => results,
+            :template => :doc_server,
+            :type => :search
+          )
+          self.body = Templates::Engine.render(options)
+        end
+
+        def search_for_object
+          splitquery = query.split(/\s+/).map {|c| c.downcase }.reject {|m| m.empty? }
+          self.results = run_verifier(Registry.all).select {|o|
+              o.path.downcase.include?(query.downcase)
+            }.reject {|o|
+              name = (o.type == :method ? o.name(true) : o.name).to_s.downcase
+              !name.include?(query.downcase) ||
+              case o.type
+              when :method
+                !(query =~ /[#.]/) && query.include?("::")
+              when :class, :module, :constant, :class_variable
+                query =~ /[#.]/
+              end
+            }.sort_by {|o|
+              name = (o.type == :method ? o.name(true) : o.name).to_s
+              name.length.to_f / query.length.to_f
+            }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/commands/static_file_command.rb

@@ -0,0 +1,57 @@
+require 'webrick/httputils'
+
+module YARD
+  module Server
+    module Commands
+      # Serves static content when no other router matches a request
+      class StaticFileCommand < Base
+        include WEBrick::HTTPUtils
+
+        DefaultMimeTypes['js'] = 'text/javascript'
+
+        # Defines the paths used to search for static assets. To define an
+        # extra path, use {YARD::Server.register_static_path} rather than
+        # modifying this constant directly. Also note that files in the
+        # document root will always take precedence over these paths.
+        STATIC_PATHS = []
+
+        def run
+          assets_template = Templates::Engine.template(:default, :fulldoc, :html)
+          path = File.cleanpath(request.path).gsub(%r{^(../)+}, '')
+
+          file = nil
+          ([adapter.document_root] + STATIC_PATHS.reverse).compact.each do |path_prefix|
+            file = File.join(path_prefix, path)
+            break if File.exist?(file)
+            file = nil
+          end
+
+          # Search in default/fulldoc/html template if nothing in static asset paths
+          file ||= assets_template.find_file(path)
+
+          if file
+            ext = "." + (request.path[/\.(\w+)$/, 1] || "html")
+            headers['Content-Type'] = mime_type(ext, DefaultMimeTypes)
+            self.body = File.read(file)
+            return
+          end
+
+          favicon?
+          self.status = 404
+        end
+
+        private
+
+        # Return an empty favicon.ico if it does not exist so that
+        # browsers don't complain.
+        def favicon?
+          return unless request.path == '/favicon.ico'
+          self.headers['Content-Type'] = 'image/png'
+          self.status = 200
+          self.body = ''
+          raise FinishRequest
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/doc_server_helper.rb

@@ -0,0 +1,76 @@
+module YARD
+  module Server
+    # A module that is mixed into {Templates::Template} in order to customize
+    # certain template methods.
+    module DocServerHelper
+      # Modifies {Templates::Helpers::HtmlHelper#url_for} to return a URL instead
+      # of a disk location.
+      # @param (see Templates::Helpers::HtmlHelper#url_for)
+      # @return (see Templates::Helpers::HtmlHelper#url_for)
+      def url_for(obj, anchor = nil, relative = false)
+        return '' if obj.nil?
+        return url_for_index if obj == '_index.html'
+        return "/#{obj}" if String === obj
+        url = super(obj, anchor, false)
+        return unless url
+        File.join('', base_path(router.docs_prefix), url)
+      end
+
+      # Modifies {Templates::Helpers::HtmlHelper#url_for_file} to return a URL instead
+      # of a disk location.
+      # @param (see Templates::Helpers::HtmlHelper#url_for_file)
+      # @return (see Templates::Helpers::HtmlHelper#url_for_file)
+      def url_for_file(filename, anchor = nil)
+        if filename.is_a?(CodeObjects::ExtraFileObject)
+          filename = filename.filename
+        end
+        "/#{base_path(router.docs_prefix)}/file/" + filename.sub(%r{^#{@library.source_path.to_s}/}, '') +
+          (anchor ? "##{anchor}" : "")
+      end
+
+      # Modifies {Templates::Helpers::HtmlHelper#url_for_list} to return a URL
+      # based on the list prefix instead of a HTML filename.
+      # @param (see Templates::Helpers::HtmlHelper#url_for_list)
+      # @return (see Templates::Helpers::HtmlHelper#url_for_list)
+      def url_for_list(type)
+        File.join('', base_path(router.list_prefix), type.to_s)
+      end
+
+      # Returns the frames URL for the page
+      # @return (see Templates::Helpers::HtmlHelper#url_for_frameset)
+      def url_for_frameset
+        url = options.file ? url_for_file(options.file) : url_for(object)
+        url = url.gsub(%r{^/#{base_path(router.docs_prefix)}/}, '')
+        File.join('', base_path(router.docs_prefix), "frames", url)
+      end
+
+      # Returns the main URL, first checking a readme and then linking to the index
+      # @return (see Templates::Helpers::HtmlHelper#url_for_main)
+      def url_for_main
+        if options.frames && !options.command.path.empty?
+          File.join('', base_path(router.docs_prefix), options.command.path)
+        else
+          options.readme ? url_for_file(options.readme) : url_for_index
+        end
+      end
+
+      # Returns the URL for the alphabetic index page
+      # @return (see Templates::Helpers::HtmlHelper#url_for_index)
+      def url_for_index
+        File.join('', base_path(router.docs_prefix), 'index')
+      end
+
+      # @example The base path for a library 'foo'
+      #   base_path('docs') # => 'docs/foo'
+      # @param [String] path the path prefix for a base path URI
+      # @return [String] the base URI for a library with an extra +path+ prefix
+      def base_path(path)
+        libname = router.request.version_supplied ? @library.to_s : @library.name
+        path + (@single_library ? '' : "/#{libname}")
+      end
+
+      # @return [Router] convenience method for accessing the router
+      def router; @adapter.router end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/doc_server_serializer.rb

@@ -0,0 +1,33 @@
+require 'webrick/httputils'
+
+module YARD
+  module Server
+    # A custom {Serializers::Base serializer} which returns resource URLs instead of
+    # static relative paths to files on disk.
+    class DocServerSerializer < Serializers::FileSystemSerializer
+      include WEBrick::HTTPUtils
+
+      def initialize(command = nil)
+        super(:basepath => '', :extension => '')
+      end
+
+      def serialized_path(object)
+        case object
+        when CodeObjects::RootObject
+          "toplevel"
+        when CodeObjects::ExtendedMethodObject
+          serialized_path(object.namespace) + ':' + escape(object.name.to_s)
+        when CodeObjects::MethodObject
+          serialized_path(object.namespace) +
+            (object.scope == :instance ? ":" : ".") + escape(object.name.to_s)
+        when CodeObjects::ConstantObject, CodeObjects::ClassVariableObject
+          serialized_path(object.namespace) + "##{object.name}-#{object.type}"
+        when CodeObjects::ExtraFileObject
+          super(object).gsub(/^file./, 'file/')
+        else
+          super(object)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/library_version.rb

@@ -0,0 +1,227 @@
+require 'fileutils'
+
+module YARD
+  module Server
+    # This exception is raised when {LibraryVersion#prepare!} fails, or discovers
+    # that the library is not "prepared" to be served by
+    class LibraryNotPreparedError < RuntimeError; end
+
+    # A library version encapsulates a library's documentation at a specific version.
+    # Although the version is optional, this allows for creating multiple documentation
+    # points for a specific library, each representing a unique version. The term
+    # "library" used in other parts of the YARD::Server documentation refers to
+    # objects of this class unless otherwise noted.
+    #
+    # A library points to a location where a {#yardoc_file} is located so that
+    # its documentation may be loaded and served. Optionally, a {#source_path} is
+    # given to point to a location where any extra files (and {YARD::CLI::Yardoc .yardopts})
+    # should be loaded from. Both of these methods may not be known immediately,
+    # since the yardoc file may not be built until later. Resolving the yardoc
+    # file and source path are dependent on the specific library "source type" used.
+    # Source types (known as "library source") are discussed in detail below.
+    #
+    # == Using with Adapters
+    # A list of libraries need to be passed into adapters upon creation. In
+    # most cases, you will never do this manually, but if you use a {RackMiddleware},
+    # you will need to pass in this list yourself. To build this list of libraries,
+    # you should create a hash of library names mapped to an *Array* of LibraryVersion
+    # objects. For example:
+    #
+    #   {'mylib' => [LibraryVersion.new('mylib', '1.0', ...),
+    #                LibraryVersion.new('mylib', '2.0', ...)]}
+    #
+    # Note that you can also use {Adapter#add_library} for convenience.
+    #
+    # The "array" part is required, even for just one library version.
+    #
+    # == Library Sources
+    # The {#source} method represents the library source type, ie. where the
+    # library "comes from". It might come from "disk", or it might come from a
+    # "gem" (technically the disk, but a separate type nonetheless). In these
+    # two cases, the yardoc file sits somewhere on your filesystem, though
+    # it may also be built dynamically if it does not yet exist. This behaviour
+    # is controlled through the {#prepare!} method, which prepares the yardoc file
+    # given a specific library source. We will see how this works in detail in
+    # the following section.
+    #
+    # == Implementing a Custom Library Source
+    # YARD can be extended to support custom library sources in order to
+    # build or retrieve a yardoc file at runtime from many different locations.
+    #
+    # To implement this behaviour, two methods must be added to the +LibraryVersion+
+    # class, +#load_yardoc_from_SOURCE+ and +#source_path_for_SOURCE+. In both
+    # cases, "SOURCE" represents the source type used in {#source} when creating
+    # the library object. The +#source_path_for_SOURCE+ method is called upon
+    # creation and should return the location where the source code for the library
+    # lives. The load method is called from {#prepare!} if there is no yardoc file
+    # and should set {#yardoc_file}. Below is a full example for
+    # implementing a custom library source, +:http+, which reads packaged .yardoc
+    # databases from zipped archives off of an HTTP server.
+    #
+    # @example Implementing a Custom Library Source
+    #   # Adds the source type "http" for .yardoc files zipped on HTTP servers
+    #   class LibraryVersion
+    #     def load_yardoc_from_http
+    #       return if yardoc_file # we have the library
+    #
+    #       # otherwise download it in a thread and return immediately
+    #       Thread.new do
+    #         # zip/unzip method implementations are not shown
+    #         download_zip_file("http://mysite.com/yardocs/#{self}.zip")
+    #         unzip_file_to("/path/to/yardocs/#{self}")
+    #         self.yardoc_file = "/path/to/yardocs/#{self}/.yardoc"
+    #         self.source_path = self.yardoc_file
+    #       end
+    #
+    #       # tell the server it's not ready yet (but it might be next time)
+    #       raise LibraryNotPreparedError
+    #     end
+    #
+    #     # we set this later
+    #     def source_path_for_http; nil end
+    #   end
+    #
+    #   # Creating a library of this source type:
+    #   LibraryVersion.new('name', '1.0', nil, :http)
+    #
+    class LibraryVersion
+      # @return [String] the name of the library
+      attr_accessor :name
+
+      # @return [String] the version of the specific library
+      attr_accessor :version
+
+      # @return [String] the location of the yardoc file used to load the object
+      #   information from.
+      # @return [nil] if no yardoc file exists yet. In this case, {#prepare!} will
+      #   be called on this library to build the yardoc file.
+      attr_accessor :yardoc_file
+
+      # @return [Symbol] the source type representing where the yardoc should be
+      #   loaded from. Defaults are +:disk+ and +:gem+, though custom sources
+      #   may be implemented. This value is used to inform {#prepare!} about how
+      #   to load the necessary data in order to display documentation for an object.
+      # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source"
+      attr_accessor :source
+
+      # @return [String] the location of the source code for a library. This
+      #   value is filled by calling +#source_path_for_SOURCE+ on this class.
+      # @return [nil] if there is no source code
+      # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source"
+      attr_accessor :source_path
+
+      # @param [String] name the name of the library
+      # @param [String] version the specific (usually, but not always, numeric) library
+      #   version
+      # @param [String] yardoc the location of the yardoc file, or nil if it is
+      #   generated later
+      # @param [Symbol] source the location of the files used to build the yardoc.
+      #   Builtin source types are +:disk+ or +:gem+.
+      def initialize(name, version = nil, yardoc = nil, source = :disk)
+        self.name = name
+        self.yardoc_file = yardoc
+        self.version = version
+        self.source = source
+        self.source_path = load_source_path
+      end
+
+      # @param [Boolean] url_format if true, returns the string in a URI-compatible
+      #   format (for appending to a URL). Otherwise, it is given in a more human
+      #   readable format.
+      # @return [String] the string representation of the library.
+      def to_s(url_format = true)
+        version ? "#{name}#{url_format ? '/' : '-'}#{version}" : "#{name}"
+      end
+
+      # @return [Fixnum] used for Hash mapping.
+      def hash; to_s.hash end
+
+      # @return [Boolean] whether another LibraryVersion is equal to this one
+      def eql?(other)
+        other.is_a?(LibraryVersion) && other.name == name &&
+          other.version == version && other.yardoc_file == yardoc_file
+      end
+      alias == eql?
+      alias equal? eql?
+
+      # @note You should not directly override this method. Instead, implement
+      #   +load_yardoc_from_SOURCENAME+ when implementing loading for a specific
+      #   source type. See the {LibraryVersion} documentation for "Implementing
+      #   a Custom Library Source"
+      #
+      # Prepares a library to be displayed by the server. This callback is
+      # performed before each request on a library to ensure that it is loaded
+      # and ready to be viewed. If any steps need to be performed prior to loading,
+      # they are performed through this method (though they should be implemented
+      # through the +load_yardoc_from_SOURCE+ method).
+      #
+      # @raise [LibraryNotPreparedError] if the library is not ready to be
+      #   displayed. Usually when raising this error, you would simultaneously
+      #   begin preparing the library for subsequent requests, although this
+      #   is not necessary.
+      def prepare!
+        return if yardoc_file
+        meth = "load_yardoc_from_#{source}"
+        send(meth) if respond_to?(meth, true)
+      end
+
+      # @return [Gem::Specification] a gemspec object for a given library. Used
+      #   for :gem source types.
+      # @return [nil] if there is no installed gem for the library
+      def gemspec
+        ver = version ? "= #{version}" : ">= 0"
+        Gem.source_index.find_name(name, ver).first
+      end
+
+      protected
+
+      # Called when a library of source type "disk" is to be prepared. In this
+      # case, the {#yardoc_file} should already be set, so nothing needs to be
+      # done.
+      def load_yardoc_from_disk
+        nil
+      end
+
+      # Called when a library of source type "gem" is to be prepared. In this
+      # case, the {#yardoc_file} needs to point to the correct location for
+      # the installed gem. The yardoc file is built if it has not been done.
+      #
+      # @raise [LibraryNotPreparedError] if the gem does not have an existing
+      #   yardoc file.
+      def load_yardoc_from_gem
+        require 'rubygems'
+        ver = version ? "= #{version}" : ">= 0"
+        self.yardoc_file = Registry.yardoc_file_for_gem(name, ver)
+        unless yardoc_file && File.directory?(yardoc_file)
+          Thread.new do
+            # Build gem docs on demand
+            log.debug "Building gem docs for #{to_s(false)}"
+            CLI::Gems.run(name, ver)
+            self.yardoc_file = Registry.yardoc_file_for_gem(name, ver)
+            FileUtils.touch(File.join(yardoc_file, 'complete'))
+          end
+        end
+        unless yardoc_file && File.exist?(File.join(yardoc_file, 'complete'))
+          raise LibraryNotPreparedError
+        end
+      end
+
+      # @return [String] the source path for a disk source
+      def source_path_for_disk
+        File.dirname(yardoc_file) if yardoc_file
+      end
+
+      # @return [String] the source path for a gem source
+      def source_path_for_gem
+        gemspec.full_gem_path if gemspec
+      end
+
+      private
+
+      def load_source_path
+        meth = "source_path_for_#{source}"
+        send(meth) if respond_to?(meth, true)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.8.6.1/lib/yard/server/rack_adapter.rb

@@ -0,0 +1,88 @@
+require 'rack'
+require 'webrick/httputils'
+
+module YARD
+  module Server
+    # This class wraps the {RackAdapter} into a Rack-compatible middleware.
+    # See {#initialize} for a list of options to pass via Rack's +#use+ method.
+    #
+    # @note You must pass a +:libraries+ option to the RackMiddleware via +#use+. To
+    #   read about how to return a list of libraries, see {LibraryVersion} or look
+    #   at the example below.
+    # @example Using the RackMiddleware in a Rack application
+    #   libraries = {:mylib => [YARD::Server::LibraryVersion.new('mylib', nil, '/path/to/.yardoc')]}
+    #   use YARD::Server::RackMiddleware, :libraries => libraries
+    #
+    class RackMiddleware
+      # Creates a new Rack-based middleware for serving YARD documentation.
+      #
+      # @param app the next Rack middleware in the stack
+      # @option opts [Hash{String=>Array<LibraryVersion>}] :libraries ({})
+      #   the map of libraries to serve through the adapter. This option is *required*.
+      # @option opts [Hash] :options ({}) a list of options to pass to the adapter.
+      #   See {Adapter#options} for a list.
+      # @option opts [Hash] :server_options ({}) a list of options to pass to the server.
+      #   See {Adapter#server_options} for a list.
+      def initialize(app, opts = {})
+        args = [opts[:libraries] || {}, opts[:options] || {}, opts[:server_options] || {}]
+        @app = app
+        @adapter = RackAdapter.new(*args)
+      end
+
+      def call(env)
+        status, headers, body = *@adapter.call(env)
+        if status == 404
+          @app.call(env)
+        else
+          [status, headers, body]
+        end
+      end
+    end
+
+    # A server adapter to respond to requests using the Rack server infrastructure.
+    class RackAdapter < Adapter
+      include WEBrick::HTTPUtils
+
+      # Responds to Rack requests and builds a response with the {Router}.
+      # @return [Array(Numeric,Hash,Array)] the Rack-style response
+      def call(env)
+        request = Rack::Request.new(env)
+        request.path_info = unescape(request.path_info) # unescape things like %3F
+        router.call(request)
+      rescue StandardError => ex
+        log.backtrace(ex)
+        [500, {'Content-Type' => 'text/plain'},
+          [ex.message + "\n" + ex.backtrace.join("\n")]]
+      end
+
+      # Starts the +Rack::Server+. This method will pass control to the server and
+      # block.
+      # @return [void]
+      def start
+        server = Rack::Server.new(server_options)
+        server.instance_variable_set("@app", self)
+        print_start_message(server)
+        server.start
+      end
+
+      private
+
+      def print_start_message(server)
+        opts = server.default_options.merge(server.options)
+        log.puts ">> YARD #{YARD::VERSION} documentation server at http://#{opts[:Host]}:#{opts[:Port]}"
+
+        # Only happens for Mongrel
+        return unless server.server.to_s == "Rack::Handler::Mongrel"
+        log.puts ">> #{server.server.class_name} web server (running on Rack)"
+        log.puts ">> Listening on #{opts[:Host]}:#{opts[:Port]}, CTRL+C to stop"
+      end
+    end
+  end
+end
+
+# @private
+class Rack::Request
+  attr_accessor :version_supplied
+  alias query params
+  def xhr?; (env['HTTP_X_REQUESTED_WITH'] || "").downcase == "xmlhttprequest" end
+end