proton 0.3.0.rc1

data/lib/proton/cli.rb

@@ -0,0 +1,227 @@
+# Class: Proton::CLI (Proton)
+# Command line runner.
+
+class Proton
+class CLI < Shake
+  autoload :Helpers, "#{PREFIX}/proton/cli/helpers"
+
+  extend  Helpers
+  include Defaults
+
+  task(:create) do
+    wrong_usage  unless params.size == 1
+    template = File.expand_path('../../../data/new_site', __FILE__)
+    target   = params.first
+
+    if target == '.'
+      pass "This is already a Proton project."  if @protonfile
+      FileUtils.cp_r File.join(template, 'Protonfile'), target
+      say_status :create, 'Protonfile'
+      pass
+    end
+
+    pass "Error: target directory already exists."  if File.directory?(target)
+
+    puts "Creating files in #{target}:"
+    puts
+
+    FileUtils.cp_r template, target
+    Dir[File.join(target, '**', '*')].sort.each do |f|
+      say_status :create, f  if File.file?(f)
+    end
+
+    puts ""
+    puts "Done! You've created a new project in #{target}."
+    puts "Get started now:"
+    puts ""
+    puts "  $ cd #{target}"
+    puts "  $ #{executable} start"
+    puts ""
+    puts "Or build the HTML files:"
+    puts ""
+    puts "  $ #{executable} build"
+    puts ""
+  end
+
+  task.description = "Starts a new Proton project"
+  task.usage = "create NAME"
+  task.category = :create
+
+  task(:build) do
+    pre = project.config.output_path
+
+    project.build { |page|
+      c, handler = if page.tilt?
+        [ 33, "#{page.tilt_engine_name.downcase}" ]
+      else
+        [ 30, '*' ]
+      end
+
+      puts ("\033[0;#{c}m%10s\033[0;32m  #{pre}\033[0;m%s" % [ handler, page.path ]).strip
+    }
+    project.send :build_cleanup
+  end
+
+  task.description = "Builds the current project"
+  task.category = :project
+
+  task(:start) do
+    project
+
+    port   = (params.extract('-p') || 4833).to_i
+    host   = (params.extract('-o') || '0.0.0.0')
+    daemon = (!! params.delete('-D'))
+
+    require 'proton/server'
+
+    if daemon
+      pid = fork { Proton::Server.run! :Host => host, :Port => port, :quiet => true }
+      sleep 2
+      puts
+      puts "Listening on #{host}:#{port} on pid #{pid}."
+      puts "To stop: kill #{pid}"
+    else
+      Proton::Server.run! :Host => host, :Port => port
+    end
+  end
+
+  task.description = "Starts the server"
+  task.category = :project
+  task.help = %{
+    Usage:
+
+        #{executable} start [-p PORT] [-o HOST] [-D]
+    
+    Starts an HTTP server so you may rapidly test your project locally.
+
+    If the -p and/or -o is specified, it will listen on the specified HOST:PORT.
+    Otherwise, the default is 0.0.0.0:4833.
+
+    If -D is specified, it goes into daemon mode.
+  }.gsub(/^ {4}/, '').strip.split("\n")
+
+  task(:rack) do
+    project
+
+    from  = File.expand_path("#{PREFIX}/../data/rack/*")
+    files = Dir[from]
+
+    files.each do |f|
+      FileUtils.cp f, '.'
+      say_status :create, File.basename(f)
+    end
+  end
+
+  task.description = "Makes a project Rack-compatible."
+  task.category = :project
+
+  task(:version) do
+    puts "Proton #{Proton::VERSION}"
+  end
+
+  task.description = "Shows the current version"
+  task.category = :misc
+
+  task(:help) do
+    show_help_for(params.first) and pass  if params.any?
+
+    show_task = Proc.new { |name, t| err "  %-20s %s" % [ t.usage || name, t.description ] }
+
+    err "Usage: #{executable} <command>"
+
+    unless project?
+      err "\nCommands:"
+      tasks_for(:create).each &show_task
+    end
+
+    if project?
+      err "\nProject commands:"
+      tasks_for(:project).each &show_task
+    end
+
+    if other_tasks.any?
+      err "\nOthers:"
+      other_tasks.each &show_task
+    end
+    err "\nMisc commands:"
+    tasks_for(:misc).each &show_task
+
+    unless project?
+      err
+      err "Get started by typing:"
+      err "  $ #{executable} create my_project"
+    end
+    err
+    err "Type `#{executable} help COMMAND` for additional help on a command."
+  end
+
+  task.description = "Shows help for a given command"
+  task.usage = "help [COMMAND]"
+  task.category = :misc
+
+  invalid do
+    task = task(command)
+    if task
+      err "Invalid usage."
+      err "Try: #{executable} #{task.usage}"
+      err
+      err "Type `#{executable} help` for more info."
+    else
+      err "Invalid command: #{command}"
+      err "Type `#{executable} help` for more info."
+    end
+  end
+
+  def self.run(*argv)
+    return invoke(:version)  if argv == ['-v'] || argv == ['--version']
+    trace = (!!argv.delete('--trace'))
+
+
+    begin
+      super *argv
+
+    rescue SyntaxError => e
+      raise e  if trace
+      err
+      say_error e.message.split("\n").last
+      err
+      say_error "You have a syntax error."
+      say_info "Use --trace for more info."
+
+    # Convert 'can't load redcloth' to a friendly 'please gem install RedCloth'
+    rescue LoadError => e
+      raise e  if trace
+      show_needed_gem gem_name(e)
+
+    # Print generic errors as something friendlier
+    rescue => e
+      raise e  if trace
+
+      # Can't assume that HAML is always available.
+      if Object.const_defined?(:Haml) && e.is_a?(Haml::Error)
+        # Convert HAML's "Can't run XX filter; required 'yy'" messages
+        # to something friendlier
+        needed = %w(rdiscount stringio sass/plugin redcloth)
+        needed.detect { |what| show_needed_gem(what) && true  if e.message.include?(what) }
+      else
+        err
+        say_error "#{e.class}: #{e.message}"
+        say_info "#{e.backtrace.first}"
+        err
+        say_error "Oops! An error occured."
+        say_info "Use --trace for more info."
+      end
+    end
+  end
+
+  def self.find_config_file
+    Proton::CONFIG_FILES.inject(nil) { |a, fname| a ||= find_in_project(fname) }
+  end
+
+  def self.run!(options={})
+    @config_file = options[:file] || find_config_file
+    Proton::Project.new rescue nil
+    super *[]
+  end
+end
+end

data/lib/proton/cli/helpers.rb

@@ -0,0 +1,89 @@
+class Proton
+class CLI
+module Helpers
+  def show_help_for(name)
+    task = task(name)
+    pass "No such command. Try: #{executable} help"  unless task
+
+    help = task.help
+    if help
+      help.each { |line| err line }
+      err
+    else
+      err "Usage: #{executable} #{task.usage || name}"
+      err "#{task.description}."  if task.description
+    end
+  end
+
+  def tasks_for(category)
+    tasks.select { |name, t| t.category == category }
+  end
+
+  def other_tasks
+    tasks.select { |name, t| t.category.nil? }
+  end
+
+  def say_info(str)
+    say_status '*', str, 30
+  end
+
+  def say_error(str)
+    say_status 'error', str, 31
+  end
+
+  def say_status(what, cmd, color=32)
+    c1 = "\033[0;#{color}m"
+    c0 = "\033[0;m"
+    puts "#{c1}%10s#{c0}  %s" % [ what, cmd ]
+  end
+
+  def show_needed_gem(name)
+    err
+    say_error "You will need additional gems for this project."
+    say_info "To install: gem install #{name}"
+  end
+
+  def no_project
+    "Error: no Proton config file found.\n" +
+    "(Looked for #{Proton::CONFIG_FILES.join(', ')})\n\n" +
+    "You start by creating a config file for this project:\n" +
+    "  $ #{executable} create .\n\n" +
+    "You may also create an empty project in a new directory:\n" +
+    "  $ #{executable} create NAME\n"
+  end
+
+  def project?
+    !! @config_file
+  end
+
+  # Gets the gem name from a LoadError exception.
+  def gem_name(e)
+    name = e.message.split(' ').last
+    name = 'RedCloth'  if name == 'redcloth'
+    name = 'haml'  if name == 'sass/plugin'
+    name
+  end
+
+  def project
+    @project ||= begin
+      pass no_project  unless project?
+      Dir.chdir File.dirname(@config_file)
+
+      begin
+        project = Proton.project || Proton::Project.new
+        pass no_project  unless project.config_file
+      rescue LegacyError
+        err "This is a legacy Hyde project."
+        err "To force it, try editing `hyde.conf` and upgrade the version line to `hyde_requirement: 0.1`."
+        pass
+      rescue VersionError => e
+        err e.message
+        pass
+      end
+
+      project
+    end
+  end
+end
+end
+end

data/lib/proton/compass_support.rb

@@ -0,0 +1,8 @@
+require 'compass'
+
+opts = Compass.sass_engine_options
+
+[:sass, :scss].each do |type|
+  Proton.project.config.tilt_options(type)[:load_paths] ||= Array.new
+  Proton.project.config.tilt_options(type)[:load_paths] += opts[:load_paths]
+end

data/lib/proton/config.rb

@@ -0,0 +1,116 @@
+class Proton
+# Class: Proton::Config
+# Configuration.
+#
+# ## Common usage
+#
+# Access it via `Proton.project`.
+#
+#     Proton.project.config
+#
+# You may access config variables as attributes.
+#
+#     Proton.project.config.site_path
+#     Proton.project.config.layouts_path
+#     Proton.project.config.extensions_path
+#     Proton.project.config.output_path
+#
+# Tilt options:
+#
+#     Proton.project.config.tilt_options('sass')[:load_path]
+#     Proton.project.config.tilt_options_for('filename.haml')[:style]
+#
+class Config
+  DEFAULTS = {
+    :site_path => '.',
+    :layouts_path => '_layouts',
+    :extensions_path => '_extensions',
+    :partials_path => '_layouts',
+    :output_path => '_output',
+    :tilt_options => {
+      :haml => {
+        :escape_html => true
+      },
+      :sass => {
+        :load_paths => ['css', '.'],
+        :style => :compact,
+        :line_numbers => true
+      },
+      :scss => {
+        :load_paths => ['css', '.'],
+        :style => :compact,
+        :line_numbers => true
+      },
+    },
+    :tilt_build_options => {
+      :scss => {
+        :style => :compressed,
+        :line_numbers => false
+      },
+      :sass => {
+        :style => :compressed,
+        :line_numbers => false
+      }
+    }
+  }
+
+  def self.load(config_file)
+    new(YAML::load_file(config_file)) rescue new
+  end
+
+  def initialize(options={})
+    # Try to emulate proper .merge behavior in Ruby 1.8
+    #DEFAULTS.each { |k, v| options[k] ||= v }
+    @table = Hashie::Mash.new
+    @table.deep_merge! DEFAULTS
+    @table.deep_merge! options
+  end
+
+  # Passthru
+  def method_missing(meth, *args, &blk)
+    @table.send meth, *args
+  end
+
+  def requirement
+    # Backward compatibility: this config option used to be called
+    # `hyde_requirement` before the project was renamed to Proton.
+    self[:requirement] || self[:hyde_requirement]
+  end
+
+  # Method: tilt_options_for (Proton::Config)
+  # Returns tilt options for a given file.
+  #
+  # ##  Usage
+  #     tilt_options_for(filename, options={})
+  #
+  # ##  Example
+  #     tilt_options_for('index.haml')  # { :escape_html => ... }
+  #
+  def tilt_options_for(file, options={})
+    ext = file.split('.').last.downcase
+    opts = tilt_options(ext) || Hash.new
+    opts = opts.merge(tilt_options(ext, :tilt_build_options))  if options[:build]
+
+    to_hash opts
+  end
+
+  # Method: tilt_options (Proton::Config)
+  # Returns tilt options for a given engine.
+  #
+  # ##  Usage
+  #     tilt_options(engine_name)
+  #
+  # ##  Example
+  #     tilt_options('haml')  # { :escape_html => ... }
+  #
+  def tilt_options(what, key=:tilt_options)
+    @table[key] ||= Hash.new
+    @table[key][what.to_s] ||= Hash.new
+  end
+
+private
+  def to_hash(mash)
+    mash.inject(Hash.new) { |h, (k, v)| h[k.to_sym] = v; h } 
+  end
+end
+end

data/lib/proton/helpers.rb

@@ -0,0 +1,126 @@
+# Module: Proton::Helpers (Proton)
+# Helpers you can use in your pages.
+#
+# ## Creating your own helpers
+#    To create for own helpers, make an extension. See [Extending Proton: 
+#    Helpers][1] for more info.
+#
+# [1]: /extending/helpers.html
+
+class Proton
+module Helpers
+
+  # Method: partial (Proton::Helpers)
+  # Renders a partial.
+  #
+  # ## Usage
+  #     <%= partial path, locals %>
+  #
+  # ## Description
+  #    See [Introduction: Partials](/introduction/partials.html) for more 
+  #    info.
+  #
+  # ## Example
+  #
+  # If your `_layouts/_banner.erb` looks like this:
+  #
+  #     <div class='banner'>
+  #       Welcome to <%= start.title %>
+  #     </div>
+  #
+  # ...Then this will embed the partial `_layouts/_nav.erb`. The partial
+  # will be rendered with `start` being set to the current page.
+  #
+  #     <%= partial '_banner', :start => page %>
+  #
+  def partial(path, locals={})
+    partial = Partial[path.to_s, page]  or return ''
+    partial.to_html locals.merge(:page => self)
+  end
+
+  # Method: rel (Proton::Helpers)
+  # Turns a path into a relative path.
+  #
+  # ##  Usage
+  #     <%= rel(path) %>
+  #
+  # ## Description
+  #    `rel` takes a given absolute path that begins with a `/` (for instance, 
+  #    `/x/y/z.html`) and returns a relative path (maybe `../y/z.html`). This is
+  #    useful if your site will not be be hosted on it's own domain.
+  #
+  # ##  Example
+  #     <% page.children.each do |child| %>
+  #       <a href="<%= rel(child.path) %>">
+  #         <%= child.title %>
+  #       </a>
+  #     <% end %>
+  #
+  #  This may output:
+  #
+  #     <a href="../../foo.html">
+  #       Foobar
+  #     </a>
+  #
+  # ...where the `../../` depends on the current page's path.
+  #
+  def rel(path)
+    depth = page.path.count('/')
+    dotdot = depth > 1 ? ('../' * (depth-1)) : './'
+    (dotdot[0...-1] + path)
+  end
+
+  # Method: content_for (Proton::Helpers)
+  # Content for.
+  #
+  # ## See also
+  #
+  #  * {Proton::Helpers::has_content?}
+  #  * {Proton::Helpers::content_for}
+  #  * {Proton::Helpers::yield_content}
+  #
+  def content_for(key, &blk)
+    content_blocks[key.to_sym] = blk
+  end
+
+  def content_blocks
+    $content_blocks ||= Hash.new
+    $content_blocks[page.path] ||= Hash.new
+  end
+
+  # Method: has_content? (Proton::Helpers)
+  # Checks if there's something defined for a given content block.
+  #
+  # ## Example
+  #    See {Proton::Helpers::content_for} for an example.
+  #
+  # ## See also
+  #  * {Proton::Helpers::has_content?}
+  #  * {Proton::Helpers::content_for}
+  #  * {Proton::Helpers::yield_content}
+  #
+  def has_content?(key)
+    content_blocks.member? key.to_sym
+  end
+
+  # Method: yield_content (Proton::Helpers)
+  # Yield
+  #
+  # ## Example
+  #    See {Proton::Helpers::content_for} for an example.
+  #
+  # ## See also
+  #  * {Proton::Helpers::has_content?}
+  #  * {Proton::Helpers::content_for}
+  #  * {Proton::Helpers::yield_content}
+  #
+  def yield_content(key, *args)
+    content = content_blocks[key.to_sym]
+    if respond_to?(:block_is_haml?) && block_is_haml?(content)
+      capture_haml(*args, &content)
+    elsif content
+      content.call(*args)
+    end
+  end
+end
+end