docter 1.0.0

data/lib/docter/server.rb

@@ -0,0 +1,109 @@
+module Docter
+
+  class MongrelHandler < Mongrel::HttpHandler
+
+    attr_reader :collection, :template, :options
+
+    def initialize(collection, template, options = {})
+      @collection, @template, @options = collection, template, options || {}
+    end
+
+    def resources()
+      @resources ||= Resources.new
+    end
+
+    def process(request, response)
+      # Absolute path to relative path, default index.
+      path = request.params[Mongrel::Const::PATH_INFO].sub(/^\//, "")
+      path = "index.html" if path.empty?
+
+      begin
+        if file = template.find(path)
+          # Files served directly from disk (CSS, images, RDoc, etc).
+          since = request.params[Mongrel::Const::HTTP_IF_MODIFIED_SINCE]
+          if since && Time.parse(since) >= File.stat(file).mtime
+            response.status = 304
+            response.finished
+          else
+            puts "Serving #{path}" if verbose
+            response.start(200) do |head,out|
+              head[Mongrel::Const::LAST_MODIFIED] = CGI.rfc1123_date(File.stat(file).mtime)
+              out.write File.read(file)
+            end
+          end
+        elsif options[:one_page] && path == "index.html"
+          puts "Serving #{path}" if verbose
+          response.start(200) do |head,out|
+            head[Mongrel::Const::CONTENT_TYPE] = "text/html"
+            out.write collection.render(template, options)
+          end
+        elsif page = collection.page(path)
+          puts "Serving #{path}" if verbose
+          response.start(200) do |head,out|
+            head[Mongrel::Const::CONTENT_TYPE] = "text/html"
+            out.write collection.render(template, page, options)
+          end
+        else
+          response.start 404 do |head, out|
+            head[Mongrel::Const::CONTENT_TYPE] = "text/html"
+            out.write "<h1>Did you accidentally rm #{path}, or did you forget to :w it?</h1>"
+          end
+        end
+      rescue Exception=>error
+        response.start(500) do |head, out|
+          head["Content-Type"] = "text/plain"
+          error = ["#{error.class}: #{error}", error.backtrace.join("\n")]
+          out.puts *error
+          puts *error
+        end
+      end
+    end
+
+  end
+
+
+  class Server
+
+    PORT = 3000
+
+    attr_reader :collection, :template
+    attr_accessor :port, :options
+
+    def initialize(collection, template, *args)
+      @collection, @template = collection, template
+      @options = Hash === args.last ? args.pop.clone : {}
+      args.each { |arg| @options[arg.to_sym] = true }
+      @port = @options[:port] || PORT
+    end
+
+    def start(wait = true)
+      puts "Starting Mongrel on port #{port}"
+      @mongrel = Mongrel::HttpServer.new("0.0.0.0", port, 4)
+      @mongrel.register("/", MongrelHandler.new(collection, template, options))
+      if wait
+        @mongrel.run.join rescue nil
+      else
+        @mongrel.run
+      end
+    end
+
+    def stop()
+      puts "Stopping Mongrel"
+      @mongrel.stop if @mongrel
+    end
+
+  end
+
+
+  class Collection
+
+    def serve(template, *args)
+      options = Hash === args.last ? args.pop.clone : {}
+      options[:port] = args.shift if Integer === args.first
+      args.each { |arg| options[arg.to_sym] = true }
+      Server.new(self, template, options).start
+    end
+
+  end
+
+end

data/lib/docter/template.rb

@@ -0,0 +1,183 @@
+module Docter
+
+  # A template for formatting pages. The template is parsed once and processed using each Page to
+  # produce an HTML document. Processing can rely on various attributes of the Scope.
+  #
+  # A template will require additional files like CSS stylesheets, images, JavaScript, etc.
+  # You can associate additional resources with the template using #include and #exclude.
+  # These resources are copied to the destination directory when generating output, and
+  # served from the integrated Web server.
+  class Template < Resource::Base
+
+    module ContextMethods
+
+      include HTML
+
+      def collect_links(content, mark = false)
+        @links ||= []
+        content.gsub(regexp_element("a")) do |link|
+          url = $3 if link =~ regexp_attribute("href")
+          if url =~ /^\w+:/
+            unless index = @links.index(url)
+              index = @links.size
+              @links << [inner_text_from(link), url]
+            end
+            mark ? "#{link}<sup>[#{index + 1}]</sup>" : link
+          else
+            link
+          end
+        end
+      end
+
+      def footnote_links(cls = nil)
+        list = @links.map { |link| %{<dt>#{link.first}</dt><dd><a href="#{link.last}">#{link.last}</a></dd>} }
+        %{<dl class="#{cls}">#{list.join}</dl>}
+      end
+
+    end
+
+    # Options passed when creating the template.
+    attr_reader :options
+
+    def initialize(*args)
+      super
+      @sources = FileList[]
+    end
+
+    # :call-seq:
+    #   render(context) => html
+    #
+    # Renders this template. The template is processed using a context that provides the template
+    # with access to various methods and variables, e.g. the page being rendered, or the ToC.
+    #
+    # There are two ways to supply a context:
+    # * Hash -- Each key becomes a method you can call on the hash to obtain it's value.
+    #   The hash will include a method called template that returns the template itself.
+    # * Object -- Creates a context object that delegates all method calls to this object,
+    #   and adds the method template that returns the template itself. 
+    def render(context)
+      load
+      if Hash === context
+        hash = context.merge(:template=>self)
+        struct = Struct.new(*hash.keys).new(*hash.values)
+        struct.class.send :include, ContextMethods
+        @process.call struct
+      else
+        delegate = Class.new
+        context.class.instance_methods.each { |method| delegate.send :define_method, method, &context.method(method) }
+        context.class.send :include, ContextMethods
+        delegate.send(:define_method, :template) { self }
+        @process.call delegate.new
+      end
+    end
+
+    # :call-seq:
+    #   include(*paths) => self
+    #
+    # Adds files and directories included in the generated output.
+    def include(*paths)
+      @sources.include *paths.flatten
+      self
+    end
+
+    alias :add :include
+
+    # :call-seq:
+    #   exclude(*paths) => self
+    #
+    # Excludes files or directories from the generated output.
+    def exclude(*paths)
+      @sources.exclude *paths.flatten
+      self
+    end
+
+    # :call-seq:
+    #   find(path) => file
+    #
+    # Returns the location of a file on disk based on the request path.
+    #
+    # For example:
+    #   template.include("html/index.html", "images", "css/*")
+    #   map.find("index.html") => "html/index.html"
+    #   map.find("images/logo.png") => "images/logo.png"
+    #   map.find("fancy.css") => "css/fancy.css"
+    def find(path)
+      @sources.inject(nil) do |found, file|
+        break found if found
+        if File.directory?(file)
+          base = File.dirname(file) + "/"
+          FileList["#{file}/**/*"].find { |file| file.sub(base, "") == path }
+        else
+          file if File.basename(file) == path
+        end 
+      end
+    end
+
+    # :call-seq:
+    #   copy_resources(to_dir)
+    #
+    # Copy resource files to the destination directory.
+    def copy_resources(to_dir)
+      mkpath to_dir
+      @sources.each do |file|
+        if File.directory?(file)
+          base = File.dirname(file) + "/"
+          FileList[File.join(file, "**/*")].each do |file|
+            target = File.join(to_dir, file.sub(base, ""))
+            mkpath File.dirname(target)
+            cp file, target
+          end
+        else
+          cp file, to_dir
+        end 
+      end
+      touch to_dir # For Rake dependency management.
+    end
+
+    # :call-seq:
+    #
+    # Returns a list of dependencies (resource files, the template file, etc). Useful when creating
+    # a Rake task based on this template.
+    def dependencies()
+      @sources.map { |path| File.directory?(path) ? FileList[path, File.join(path, "**/*")] : path }.flatten +
+        [@filename].compact
+    end
+
+  protected
+
+    if defined?(::Haml)
+      def create_from_haml(content, options)
+        @options = options
+        template = Haml::Engine.new(content, :filename=>@filename)
+        @process = lambda { |context| template.render(context) }
+      end
+    else
+      def create_from_haml(content, options)
+        fail "You need to install HAML first:\n  gem install haml"
+      end
+    end
+
+    def create_from_erb(content, options)
+      @options = options
+      template = ERB.new(content)
+      @process = lambda { |context| template.result(context.instance_eval { binding }) }
+    end
+
+  end
+
+
+  class << self
+
+    # :call-seq:
+    #   template(filename, options?)
+    #   template(format, content, options?)
+    #
+    # The first form loads the template from the specified filename. The second creates the template from
+    # the content string based on the specified format.
+    def template(*args)
+      Template.new(*args)
+    end
+
+  end
+
+end

data/lib/docter/ultraviolet.rb

@@ -0,0 +1,26 @@
+module Docter
+
+  SYNTAX_THEME = "eiffel"
+  SYNTAX_STYLESHEET = "css/#{SYNTAX_THEME}.css"
+  SYNTAX_MAP = { "sh"=>"shell-unix-generic" }
+
+  filter_for :syntax do |html|
+    html.gsub(HTML.regexp_element("pre")) do |pre|
+      attributes, code = $2, $3
+      if attributes[HTML.regexp_attribute("class")]
+        classes = $3.split(/\s+/)
+        lang = classes.first
+      end
+      if lang == "text"
+        Uv.parse(CGI.unescapeHTML(code), "xhtml", "plain_text", false, SYNTAX_THEME).
+          gsub(URI.regexp) { |uri| uri =~ /^http(s?):\/\// ? %{<a href="#{uri}">#{uri}</a>} : uri }
+      elsif lang
+        syntax = SYNTAX_MAP[lang] || (Uv.syntaxes.include?(lang) ? lang : "plain_text")
+        Uv.parse(CGI.unescapeHTML(code), "xhtml", syntax || "plain_text", classes.include?("lines"), SYNTAX_THEME)
+      else
+        Uv.parse(CGI.unescapeHTML(code), "xhtml", "plain_text", false, SYNTAX_THEME)
+      end
+    end
+  end
+
+end

data/lib/docter.rb

@@ -0,0 +1,33 @@
+# &:symbol goodness.
+require "facet/symbol/to_proc"
+# blank? on string and nil
+require "facet/string/blank"
+require "facet/nilclass/blank"
+# x.in?(y) is better than y.include?(x)
+require "facet/string/starts_with"
+require "facets/core/kernel/tap"
+require "facet/kernel/__DIR__"
+
+module Docter
+  VERSION = "1.0.0".freeze
+end
+
+$LOAD_PATH.unshift __DIR__
+
+require "cgi"
+require "erb"
+# All these Gems are optional.
+["redcloth", "haml", "mongrel", "uv"].each do |gem|
+  begin
+    require gem
+  rescue LoadError
+  end
+end
+
+require "docter/common.rb"
+require "docter/page.rb"
+require "docter/template.rb"
+require "docter/collection.rb"
+require "docter/server.rb" if defined?(Mongrel)
+require "docter/rake.rb" if defined?(Rake)
+require "docter/ultraviolet.rb" if defined?(Uv)

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: docter
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-07-03 00:00:00 -07:00
+summary: We has docs
+require_paths: 
+- lib
+email: arkin@intalio.com
+homepage: http://docter.rubyforge.org
+rubyforge_project: buildr
+description: 
+autorequire: docter.rb
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Assaf Arkin
+files: 
+- lib/docter
+- lib/docter/server.rb
+- lib/docter/template.rb
+- lib/docter/collection.rb
+- lib/docter/rake.rb
+- lib/docter/ultraviolet.rb
+- lib/docter/page.rb
+- lib/docter/common.rb
+- lib/docter.rb
+- CHANGELOG
+- README
+- LICENSE
+test_files: []
+
+rdoc_options: 
+- --title
+- Docter -- We has docs
+- --main
+- README
+- --line-numbers
+- -inline-source
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.8"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: RedCloth
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: haml
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.5"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mongrel
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: