nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/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.7.4/lib/yard/server/commands/list_command.rb

@@ -0,0 +1,48 @@
+module YARD
+  module Server
+    module Commands
+      # Returns a list of objects of a specific type
+      class ListCommand < LibraryCommand
+        include Templates::Helpers::BaseHelper
+
+        def items; raise NotImplementedError end
+        def type; raise NotImplementedError end
+
+        def run
+          options.update(:items => items, :template => :doc_server,
+                         :list_type => request.path.split('/').last, :type => :full_list)
+          render
+        end
+      end
+
+      # Returns the list of classes / modules in a library
+      class ListClassesCommand < ListCommand
+        def type; :class end
+
+        def items
+          Registry.load_all
+          run_verifier(Registry.all(:class, :module))
+        end
+      end
+
+      # Returns the list of methods in a library
+      class ListMethodsCommand < ListCommand
+        include Templates::Helpers::ModuleHelper
+
+        def type; :methods end
+
+        def items
+          Registry.load_all
+          items = Registry.all(:method).sort_by {|m| m.name.to_s }
+          prune_method_listing(items)
+        end
+      end
+
+      # Returns the list of README/extra files in a library
+      class ListFilesCommand < ListCommand
+        def type; :files end
+        def items; options[:files] end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+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
+
+        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(serializer.serialized_path(found))
+          end
+          search_for_object
+          request.xhr? ? serve_xhr : serve_normal
+        end
+
+        def visible_results
+          results[0, 10]
+        end
+
+        private
+
+        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,
+             serializer.serialized_path(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.7.4/lib/yard/server/commands/static_file_command.rb

@@ -0,0 +1,50 @@
+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 = [
+          File.join(YARD::TEMPLATE_ROOT, 'default', 'fulldoc', 'html'),
+          File.join(File.dirname(__FILE__), '..', 'templates', 'default', 'fulldoc', 'html')
+        ]
+
+        def run
+          path = File.cleanpath(request.path).gsub(%r{^(../)+}, '')
+          ([adapter.document_root] + STATIC_PATHS.reverse).compact.each do |path_prefix|
+            file = File.join(path_prefix, path)
+            if File.exist?(file)
+              ext = "." + (request.path[/\.(\w+)$/, 1] || "html")
+              headers['Content-Type'] = mime_type(ext, DefaultMimeTypes)
+              self.body = File.read(file)
+              return
+            end
+          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.7.4/lib/yard/server/doc_server_helper.rb

@@ -0,0 +1,40 @@
+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 "/#{obj}" if String === obj
+        super(obj, anchor, false)
+      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
+
+      # @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)
+        path + (@single_library ? '' : "/#{@library}")
+      end
+
+      # @return [Router] convenience method for accessing the router
+      def router; @adapter.router end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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)
+        super(:command => command, :extension => '')
+      end
+
+      def serialized_path(object)
+        path = case object
+        when CodeObjects::RootObject
+          "toplevel"
+        when CodeObjects::MethodObject
+          return escape_path(serialized_path(object.namespace) + (object.scope == :instance ? ":" : ".") + object.name.to_s)
+        when CodeObjects::ConstantObject, CodeObjects::ClassVariableObject
+          return escape_path(serialized_path(object.namespace)) + "##{object.name}-#{object.type}"
+        else
+          object.path.gsub('::', '/')
+        end
+        command = options[:command]
+        library_path = command.single_library ? '' : '/' + command.library.to_s
+        return escape_path(File.join('', command.adapter.router.docs_prefix, library_path, path))
+      end
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/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)
+      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)
+      end
+    end
+  end
+end