brite 0.6.0 → 0.7.0

data/lib/brite/server.rb

@@ -1,144 +1,139 @@
 require 'fileutils'
+require 'tmpdir'
 require 'optparse'
+
+require 'rack'
 require 'rack/server'
 require 'rack/handler'
 require 'rack/builder'
 require 'rack/directory'
 require 'rack/file'
 
+require 'brite/config'
+
 module Brite
 
   # Brite::Server is a Rack-based server useful for testing sites locally.
-  # not all sites --in fact, most sites, can not be fully previewed via
-  # static files. A webserver is required to render and navigate a site
-  # completely. So this light server is provided to facilitate this.
-  class Server < ::Rack::Server
-
-    class Options
-      def parse!(args)
-        args, options = args.dup, {}
-
-        opt_parser = OptionParser.new do |opts|
-          opts.banner = "Usage: brite-server [options]"
-
-          opts.on("-p", "--port=port", Integer,
-                  "Runs server on the specified port.", "Default: 3000") { |v| options[:Port] = v }
-
-          opts.on("-b", "--binding=ip", String,
-                  "Binds server to the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
-
-          opts.on("-c", "--config=file", String,
-                  "Use custom rackup configuration file.") { |v| options[:config] = v }
-
-          opts.on("-d", "--daemon", "Make server run as a Daemon.") { options[:daemonize] = true }
-
-          opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { options[:debugger] = true }
+  # Most sites cannot be fully previewed by loading static files into a browser.
+  # Rather, a webserver is required to render and navigate a site completely. 
+  # So this light server is provided to facilitate this.
+  #
+  class Server 
 
-          opts.on("-e", "--environment=name", String,
-                  "Specifies the environment to run this server under (test/development/production).",
-                  "Default: development") { |v| options[:environment] = v }
+    # Rack configuration file.
+    RACK_FILE = 'brite.ru'
 
-          opts.separator ""
+    #
+    def self.start(argv)
+      new(argv).start
+    end
 
-          opts.on_tail("-h", "--help", "Show this help message.") { puts opts; exit }
-        end
+    # Server options, parsed from command line.
+    attr :options
 
-        opt_parser.parse!(args)
+    # Setup new instance of Brite::Server.
+    def initialize(argv)
+      @options = ::Rack::Server::Options.new.parse!(argv)
 
-        options[:server] = args.shift
+      @root = argv.first || Dir.pwd
 
-        return options
-      end
-    end
+      @options[:app] = app
+      @options[:pid] = "#{tmp_dir}/pids/server.pid"
 
-    #
-    def initialize(*)
-      super
-      set_environment
+      @options[:Port] ||= '4444'
     end
 
-    #
-    def opt_parser
-      Options.new
-    end
+    # THINK: Should we be using a local tmp directory instead?
+    #        Then again, why do we need them at all, really?
 
-    #
-    def set_environment
-      ENV["BRITE_ENV"] ||= options[:environment]
+    # Temporary directory used by the rack server.
+    def tmp_dir
+      @tmp_dir ||= File.join(Dir.tmpdir, 'brite', root)
     end
 
-    #
+    # Start the server.
     def start
-      puts "=> Booting #{server}"
-      puts "=> On http://#{options[:Host]}:#{options[:Port]}"
-      puts "=> Call with -d to detach" unless options[:daemonize]
-      trap(:INT) { exit }
-      puts "=> Ctrl-C to shutdown server" unless options[:daemonize]
+      ensure_brite_site
 
-      #Create required tmp directories if not found
+      # create required tmp directories if not found
       %w(cache pids sessions sockets).each do |dir_to_make|
-        FileUtils.mkdir_p(File.join('.cache', dir_to_make))
+        FileUtils.mkdir_p(File.join(tmp_dir, dir_to_make))
       end
 
-      super
-    ensure
-      # The '-h' option calls exit before @options is set.
-      # If we call 'options' with it unset, we get double help banners.
-      puts 'Exiting' unless @options && options[:daemonize]
+      ::Rack::Server.start(options)
     end
 
-    def middleware
-      middlewares = []
-      #middlewares << [Rails::Rack::LogTailer, log_path] unless options[:daemonize]
-      #middlewares << [Rails::Rack::Debugger]  if options[:debugger]
-      Hash.new(middlewares)
+    # Ensure root is a Brite Site.
+    def ensure_brite_site
+      return true if File.exist?(rack_file)
+      return true if config.file
+      abort "Not a brite site."
     end
 
-    def log_path
-      ".cache/brite.log"
+    # Load Brite configuration.
+    def config
+      @config ||= Brite::Config.new(root)
     end
 
-    def default_options
-      super.merge({
-        :Port        => 3000,
-        :environment => (ENV['BRITE_ENV'] || "development").dup,
-        :daemonize   => false,
-        :debugger    => false,
-        :pid         => ".cache/pids/server.pid",
-        :config      => nil
-      })
+    # Site root directory.
+    def root
+      @root
     end
 
-    #
-    def root
-      Dir.pwd
+    # Configuration file for server.
+    def rack_file
+      RACK_FILE
     end
 
+    # If the site has a `brite.ru` file, that will be used to start the server,
+    # otherwise a standard Rack::Directory server ise used.
     def app
-      @app ||= begin
-        config_file = options[:config]
-        if config_file && ::File.exist?(config_file)
-          app, options = Rack::Builder.parse_file(config_file, opt_parser)
-          self.options.merge!(options)
+      @app ||= (
+        if ::File.exist?(rack_file)
+          app, options = Rack::Builder.parse_file(rack_file, opt_parser)
+          @options.merge!(options)
           app
         else
           root = self.root
-          app, options = Rack::Builder.new do
+          Rack::Builder.new do
+            use Index, root
             run Rack::Directory.new("#{root}")
           end
-          #self.options.merge!(options)
-          app
+        end
+      )
+    end
+
+    # Rack middleware to serve `index.html` file by default.
+    class Index
+      def initialize(app, root)
+        @app  = app
+        @root = root || Dir.pwd
+      end
+
+      def call(env)
+        path = Rack::Utils.unescape(env['PATH_INFO'])
+        index_file = File.join(@root, path, 'index.html')
+        if File.exists?(index_file)
+          [200, {'Content-Type' => 'text/html'}, File.new(index_file)]
+        else
+          @app.call(env) #Rack::Directory.new(@root).call(env)
         end
       end
     end
 
-  end
+    #
+    #def log_path
+    #  "_brite.log"
+    #end
 
-end
+    #
+    #def middleware
+    #  middlewares = []
+    #  #middlewares << [Rails::Rack::LogTailer, log_path] unless options[:daemonize]
+    #  #middlewares << [Rails::Rack::Debugger]  if options[:debugger]
+    #  Hash.new(middlewares)
+    #end
 
-## The static content rooted in the current working directory
-## Eg. Dir.pwd =&gt; http://0.0.0.0:3000/
-#root = Dir.pwd
-#puts ">>> Serving: #{root}"
-#run Rack::Directory.new("#{root}")
+  end
 
+end

data/lib/brite/site.rb

@@ -0,0 +1,150 @@
+require 'brite/model'
+#require 'brite/page'
+#require 'brite/post'
+#require 'brite/part'
+
+module Brite
+
+  # TODO: Limit Neapolitan to Markup formats only ?
+
+  #
+  class Site #< Model
+
+    # New Site model.
+    #
+    # @param [String] location
+    #   The directory of the site's files.
+    #
+    def initialize(location, options={})
+      @location = location
+      @config   = Config.new(location)
+
+      options.each do |k,v|
+        __send__("#{k}=", v)
+      end
+
+      @pages   = []
+      @posts   = []
+      @parts   = []
+      @layouts = []
+
+      @tags         = nil
+      @posts_by_tag = nil
+
+      load_site
+    end
+
+    #
+    attr :location
+
+    # Access to site configuration.
+    attr :config
+
+    # Returns and Array of Page instances.
+    attr :pages
+
+    # Returns and Array of Post instances.
+    attr :posts
+
+    #
+    attr :parts
+
+    #
+    attr :layouts
+
+    # Returns a String of the site's URL.
+    def url
+      @url ||= config.url
+    end
+
+    # Change site URL.
+    attr_writer :url
+
+    # Returns an Array of all tags used in all posts.
+    def tags
+      @tags ||= (
+        list = []
+        posts.each{ |post| list.concat(post.tags) }
+        list.uniq.sort
+      )
+    end
+
+    # Returns a Hash posts indexed by tag.
+    def posts_by_tag
+      @posts_by_tag ||= (
+        chart ||= Hash.new{|h,k|h[k]=[]}
+        posts.each do |post|
+          post.tags.each do |tag|
+            chart[tag] << post
+          end
+        end
+        chart
+      )
+    end
+
+    #
+    def inspect
+      "#<Brite::Site @url=#{url.inspect}>"
+    end
+
+   #private
+
+    def load_site
+      Dir.chdir(location) do
+        files = Dir['**/*']
+        files.each do |file|
+          name = File.basename(file)
+          ext  = File.extname(file)
+          case ext
+          when '.layout'
+            layouts << Layout.new(self, file)
+          when '.part'
+            parts << Part.new(self, file)
+          when '.page' #*%w{.markdown .rdoc .textile .whtml}
+            page = Page.new(self, file)
+            pages << page unless page.draft
+          when '.post'
+            post = Post.new(self, file)
+            posts << post unless post.draft
+          end
+        end
+      end
+
+      @posts.sort!{ |a,b| b.date <=> a.date }
+    end
+
+    #
+    #def page_defaults
+    #  { :stencil => config.stencil,
+    #    :layout  => config.layout,
+    #    :author  => config.author
+    #  }
+    #end
+
+  public
+
+    #
+    # Lookup layout by name.
+    #
+    def lookup_layout(name)
+      layouts.find do |layout|
+        config.layout_path.any? { |path|
+          File.join(path, name) == layout.name 
+        } or name == layout.name
+      end
+    end
+
+    #
+    #
+    #
+    def lookup_partial(name)
+      parts.find do |part|
+        config.partial_path.any? { |path|
+          File.join(path, name) == part.name 
+        } or name == part.name
+      end
+    end
+
+  end
+
+end

data/lib/brite/version.rb

@@ -0,0 +1,21 @@
+module Brite
+
+  # Access to project metadata as given in `brite.yaml` which
+  # is soft linked to the `.ruby` project file.
+  #
+  # @return [Hash] project metadata
+  def self.metadata
+    @metadata ||= (
+      require 'yaml'
+      YAML.load(File.dirname(__FILE__) + '/../brite.yml')
+    )
+  end
+
+  # If constant is missing, check project metadata.
+  #
+  # @raise [NameError] uninitialized constant
+  def self.const_missing(name)
+    metadata[name.to_s.downcase] || super(name)
+  end
+
+end

data/test/fixture/brite.yml

@@ -0,0 +1,3 @@
+---
+post_slug: "%Y/%M/%D/$name"
+

data/test/fixture/example-page.page

@@ -0,0 +1,8 @@
+---
+author: trans
+
+--- rdoc
+
+# Hello World
+
+This is an example post.

data/test/fixture/example-post.post

@@ -0,0 +1,9 @@
+---
+author: trans
+date  : 2011-11-11
+
+--- rdoc
+
+# Hello World
+
+This is an example post.

data/test/helper.rb

@@ -0,0 +1,5 @@
+require 'lemon'
+require 'ae'
+
+require 'brite'
+

data/test/test_config.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+testcase Brite::Config do
+
+  method :location do
+
+    test "config loads given location" do
+      config = Brite::Config.new('test/fixture')
+      config.assert.location == 'text/fixture'
+    end
+
+  end
+
+  method :file do
+
+    test "config find configuraiton file" do
+      config = Brite::Config.new('test/fixture')
+      config.file.assert == 'test/fixture/brite.yml'
+    end
+
+  end
+
+end