ruhoh 1.1 → 2.1

data/lib/ruhoh/cache.rb

@@ -0,0 +1,46 @@
+class Ruhoh
+  class Cache
+    def initialize(ruhoh)
+      @__cache = {}
+    end
+
+    def __cache
+      @__cache
+    end
+
+    def set(key, data)
+      key = tokenize(key)
+      return nil unless key
+
+      @__cache[key] = data
+    end
+
+    def get(key)
+      key = tokenize(key)
+      return nil unless key
+
+      if @__cache[key]
+        @__cache[key]
+      end
+    end
+
+    def delete(key)
+      @__cache.delete(tokenize(key))
+    end
+
+    private
+
+    def tokenize(key)
+      new_key = case key
+                when Hash
+                  key.to_a.sort.to_s.strip
+                when Array
+                  key.sort.to_s.strip
+                else
+                  key.to_s.strip
+                end
+
+      new_key.empty? ? nil : new_key
+    end
+  end
+end

data/lib/ruhoh/client.rb

@@ -0,0 +1,162 @@
+require 'ruhoh/programs/compile'
+require 'ruhoh/console_methods'
+require 'irb'
+require 'benchmark'
+
+class Ruhoh
+
+  class Client
+    DefaultBlogScaffold = 'git://github.com/ruhoh/blog.git'
+    Help = [
+      {
+        "command" => "new <directory_path>",
+        "desc" => "Create a new blog directory based on the Ruhoh specification."
+      },
+      {
+        "command" => "compile",
+        "desc" => "Compile to static website."
+      },
+      {
+        "command" => "help",
+        "desc" => "Show this menu."
+      }
+    ]
+    def initialize(data)
+      @args = data[:args]
+      @options = data[:options]
+      @opt_parser = data[:opt_parser]
+      @ruhoh = Ruhoh.new
+      cmd = (@args[0] == 'new') ? 'blog' : (@args[0] || 'help')
+
+      @ruhoh.setup
+      @ruhoh.setup_paths
+
+      return __send__(cmd) if respond_to?(cmd)
+
+      Ruhoh::Friend.say {
+        yellow "-> Autoloading '#{cmd}' as pages collection"
+      } unless @ruhoh.collections.exists?(cmd)
+
+      collection = @ruhoh.collection(cmd)
+      client = collection.load_client(data)
+
+      Ruhoh::Friend.say { 
+        red "method '#{data[:args][1]}' not found for #{client.class}"
+        exit 
+      } unless @args[1] && client.respond_to?(@args[1])
+
+      client.__send__(@args[1])
+    end
+
+    # Thanks rails! https://github.com/rails/rails/blob/master/railties/lib/rails/commands/console.rb
+    def console
+      require 'pp'
+      Ruhoh::ConsoleMethods.env = @args[1]
+      IRB::ExtendCommandBundle.send :include, Ruhoh::ConsoleMethods
+
+      ARGV.clear # IRB throws an error otherwise.
+      IRB.start
+    end
+    alias_method :c, :console
+
+    # Show Client Utility help documentation.
+    def help
+      options = @opt_parser.help
+      resources = [{"methods" => Help}]
+      resources += @ruhoh.collections.all.map {|name|
+        collection = @ruhoh.collection(name)
+        next unless collection.client?
+        next unless collection.client.const_defined?(:Help)
+        {
+          "name" => name,
+          "methods" => collection.client.const_get(:Help)
+        }
+      }.compact
+
+      Ruhoh::Friend.say { 
+        plain "Ruhoh is a nifty, modular static blog generator."
+        plain "It is the Universal Static Blog API."
+        plain "Visit http://www.ruhoh.com for complete usage and documentation."
+        plain ''
+        plain options
+        plain ''
+        plain 'Commands:'
+        plain ''
+        resources.each do |resource|
+          resource["methods"].each do |method|
+            if resource["name"]
+              green("  " + "#{resource["name"]} #{method["command"]}")
+            else
+              green("  " + method["command"])
+            end
+            plain("    "+ method["desc"])
+          end
+        end
+      }
+    end
+
+    # Public: Compile to static website.
+    def compile
+      puts Benchmark.measure {
+        Ruhoh::Program.compile(@args[1])
+      }
+    end
+
+    # Public: Create a new blog at the directory provided.
+    def blog
+      name = @args[1]
+      scaffold = @args.length > 2 ? @args[2] : DefaultBlogScaffold
+      useHg = @options.hg
+      Ruhoh::Friend.say { 
+        red "Please specify a directory path." 
+        plain "  ex: ruhoh new the-blogist"
+        exit
+      } if name.nil?
+
+      target_directory = File.join(Dir.pwd, name)
+
+      Ruhoh::Friend.say { 
+        red "#{target_directory} already exists."
+        plain "  Specify another directory or `rm -rf` this directory first."
+        exit
+      } if File.exist?(target_directory)
+      
+      Ruhoh::Friend.say { 
+        plain "Trying this command:"
+
+        if useHg
+          cyan "  hg clone #{scaffold} #{target_directory}"
+          success = system('hg', 'clone', scaffold, target_directory)
+        else
+          cyan "  git clone #{scaffold} #{target_directory}"
+          success = system('git', 'clone', scaffold, target_directory)
+        end
+
+        if success
+          green "Success! Now do..."
+          cyan "  cd #{target_directory}"
+          cyan "  rackup -p9292"
+          cyan "  http://localhost:9292"
+        else
+          red "Could not git clone blog scaffold. Please try it manually:"
+          cyan "  git clone git://github.com/ruhoh/blog.git #{target_directory}"
+        end
+      }
+    end
+
+    def ask(message, valid_options)
+      if valid_options
+        answer = get_stdin("#{message} #{valid_options.to_s.gsub(/"/, '').gsub(/, /,'/')} ") while !valid_options.include?(answer)
+      else
+        answer = get_stdin(message)
+      end
+      answer
+    end
+
+    def get_stdin(message)
+      print message
+      STDIN.gets.chomp
+    end
+
+  end
+end

data/lib/ruhoh/collections.rb

@@ -0,0 +1,172 @@
+module Ruhoh::Resources ; end
+# Require all the resources
+FileUtils.cd(File.join(File.dirname(__FILE__), 'base')) do
+  (Dir['*.rb'] + Dir[File.join('*', '*.rb')]).each do |f|
+    require File.join(File.dirname(__FILE__), 'base', f)
+  end
+end
+FileUtils.cd(File.join(File.dirname(__FILE__), 'resources')) do
+  Dir[File.join('**', '*.rb')].each do |f|
+    require File.join(File.dirname(__FILE__), 'resources', f)
+  end
+end
+
+class Ruhoh
+  class Collections
+    def initialize(ruhoh)
+      @ruhoh = ruhoh
+      @collections = {}
+    end
+
+    def collection(resource)
+      get_module_namespace_for(resource).const_get(:Collection)
+    end
+
+    def collection?(resource)
+      get_module_namespace_for(resource).const_defined?(:Collection)
+    end
+
+    # Load and cache a given resource collection.
+    # This allows you to work with single object instance and perform
+    # persistant mutations on it if necessary.
+    # Note the collection is always wrapped in its view.
+    # @returns[Class Instance] of the resource and class_name given.
+    def load(resource)
+      return @collections[resource] if @collections[resource]
+      instance =  collection?(resource) ?
+                    collection(resource).new(@ruhoh) :
+                    Ruhoh::Base::Collection.new(@ruhoh)
+      instance.resource_name = resource
+      @collections[resource] = instance.load_collection_view
+    end
+
+    # Load the CollectionView class for this resource.
+    # Used primarily to as the plugin interface to include modules for mustache.
+    def self.load(resource)
+      get_module_namespace_for(resource).const_get(:CollectionView)
+    end
+
+    def all
+      (discover + registered).uniq
+    end
+
+    def base
+      Ruhoh::Base.constants.select{ |a|
+        Ruhoh::Base.const_get(a).class == Module
+      }.map{ |a| 
+        a.to_s.downcase
+      }
+    end 
+
+    def registered
+      self.class.registered
+    end
+
+    def self.registered
+      Ruhoh::Resources.constants.map{ |a| a.to_s.downcase }.delete_if{ |a| a == "pages" }
+    end
+
+    # discover all the resource mappings
+    def discover
+      FileUtils.cd(@ruhoh.base) {
+        return Dir['*'].select { |x| 
+          File.directory?(x) && !["plugins", 'compiled'].include?(x)
+        }
+      }
+    end
+
+    def acting_as_pages
+      pool = discover
+      theme = @ruhoh.config['theme']['name'] rescue nil
+      pool.delete(theme)
+
+      pool.keep_if { |resource|
+        config = @ruhoh.config[resource]
+        if (config && config["use"]) 
+          config["use"] == "pages"
+        else
+          if resource == "pages"
+            true
+          else
+            !registered.include?(resource)
+          end
+        end
+      }
+    end
+
+    def exists?(name)
+      all.include?(name)
+    end
+    alias_method :exist?, :exists?
+
+    def paginator_urls
+      data = {}
+      all.each do |name|
+        paginator = load(name).config['paginator']['url'] rescue nil
+        next if paginator.nil? || paginator.empty?
+
+        data[name] = @ruhoh.to_url(paginator)
+      end
+
+      data
+    end
+
+    def url_endpoints
+      urls = {}
+      urls["base_path"] = @ruhoh.base_path
+
+      all.each do |name|
+        collection = load(name)
+        next unless collection.respond_to?(:url_endpoint)
+        urls[name] = @ruhoh.to_url(collection.url_endpoint)
+      end
+
+      urls
+    end
+
+    def url_endpoints_sorted
+      sorted_urls = url_endpoints.each.map {|k, v| {"name" => k, "url" => v} }
+      sorted_urls.sort { |a, b| b["url"].length <=> a["url"].length }
+    end
+
+    protected
+
+    # Load the registered resource else default to Pages if not configured.
+    # @returns[Constant] the resource's module namespace
+    def get_module_namespace_for(resource)
+      type = @ruhoh.config[resource]["use"] rescue nil
+
+      self.class.get_module_namespace_for(resource, type)
+    end
+
+    def self.get_module_namespace_for(resource, type=nil)
+      if type
+        if registered.include?(type)
+          Ruhoh::Resources.const_get(camelize(type))
+        elsif base.include?(type)
+          Ruhoh::Base.const_get(camelize(type))
+        else
+          klass = camelize(type)
+          Friend.say {
+            red "#{resource} resource set to use:'#{type}' in config.yml but Ruhoh::Resources::#{klass} does not exist."
+          }
+          abort
+        end
+      else
+        if registered.include?(resource)
+          Ruhoh::Resources.const_get(camelize(resource))
+        else
+          Ruhoh::Resources.const_get(:Pages)
+        end
+      end
+    end
+
+    def camelize(name)
+      self.class.camelize(name)
+    end
+
+    def self.camelize(name)
+      name.to_s.split('_').map {|a| a.capitalize}.join
+    end
+  end
+end

data/lib/ruhoh/console_methods.rb

@@ -0,0 +1,21 @@
+class Ruhoh
+  module ConsoleMethods
+    class << self
+      attr_accessor :env
+    end
+    
+    def ruhoh
+      return @ruhoh if @ruhoh
+      @ruhoh = Ruhoh.new
+      @ruhoh.setup
+      @ruhoh.env = ConsoleMethods.env || 'development'
+      @ruhoh.setup_paths
+      @ruhoh
+    end
+
+    def reload!
+      @ruhoh = nil
+      self.ruhoh
+    end
+  end
+end

data/lib/ruhoh/{converters/converter.rb → converter.rb}

@@ -1,4 +1,7 @@
-require 'ruhoh/converters/markdown'
+# Require all the converters
+Dir[File.join(File.dirname(__FILE__), 'converters', '*.rb')].each { |f|
+  require f
+}
 
 class Ruhoh
   module Converter

data/lib/ruhoh/programs/compile.rb

@@ -0,0 +1,22 @@
+class Ruhoh
+  module Program
+    # Public: A program for compiling to a static website.
+    # The compile environment should always be 'production' in order
+    # to properly omit drafts and other development-only settings.
+    def self.compile(target)
+      ruhoh = Ruhoh.new
+      ruhoh.setup
+      ruhoh.env = 'production'
+      ruhoh.setup_paths
+      ruhoh.setup_plugins
+      
+      if target
+        ruhoh.paths.compiled = File.expand_path(target)
+      elsif ruhoh.config["compiled"]
+        ruhoh.paths.compiled = ruhoh.config["compiled"]
+      end
+      
+      ruhoh.compile
+    end
+  end
+end

data/lib/ruhoh/programs/preview.rb

@@ -0,0 +1,63 @@
+require 'ruhoh/programs/watch'
+class Ruhoh
+  module Program
+    # Public: A program for running ruhoh as a rack application
+    # which renders singular pages via their URL.
+    # 
+    # Examples
+    #
+    #  In config.ru:
+    #
+    #   require 'ruhoh'
+    #   run Ruhoh::Program.preview
+    #
+    # Returns: A new Rack builder object which should work inside config.ru
+    def self.preview(opts={})
+      opts[:watch] ||= true
+      opts[:env] ||= 'development'
+      
+      ruhoh = Ruhoh.new
+      ruhoh.setup
+      ruhoh.env = opts[:env]
+      ruhoh.setup_paths
+      ruhoh.setup_plugins unless opts[:enable_plugins] == false
+
+      # initialize the routes dictionary for all page resources.
+      ruhoh.routes.all
+
+      Ruhoh::Program.watch(ruhoh) if opts[:watch]
+      Rack::Builder.new {
+        use Rack::Lint
+        use Rack::ShowExceptions
+
+        # Url endpoints as registered by the resources.
+        # The urls are mapped to the resource's individual rack-compatable Previewer class.
+        # Note page-like resources (posts, pages) don't render uniform url endpoints,
+        # since presumably they define customized permalinks per singular resource.
+        # Page-like resources are handled the root mapping below.
+        ruhoh.collections.url_endpoints_sorted.each do |h|
+          # Omit base_path and theme because they are special use-cases.
+          next if %w{base_path theme}.include?(h["name"])
+          map h["url"] do
+            collection = ruhoh.collection(h["name"])
+            if collection.previewer?
+              run collection.load_previewer
+            else
+              run Rack::Cascade.new(
+                collection.paths.reverse.map { |path|
+                  Rack::File.new(path)
+                }
+              )
+            end
+          end
+        end
+
+        # The generic Page::Previewer is used to render any/all page-like resources,
+        # since they likely have arbitrary urls based on permalink settings.
+        map '/' do
+          run Ruhoh::Resources::Pages::Previewer.new(ruhoh)
+        end
+      }
+    end
+  end
+end