ruhoh 1.1 → 2.1

data/Gemfile

@@ -2,12 +2,12 @@ source "http://rubygems.org"
 gemspec
 
 gem 'rack', "~> 1.4"
-gem 'directory_watcher', "~> 1.4"
-gem 'psych', "~> 1.3", :platforms => [:ruby_18, :mingw_18]
+gem 'directory_watcher', "~> 1.4.0"
+gem 'psych', "~> 1.3"#, :platforms => [:ruby_18, :mingw_18]
 gem 'redcarpet', "~> 2.1"
 gem 'nokogiri', "~> 1.5"
 
 group :development do
-  gem 'rspec', "~> 2.11"
+  gem 'rspec', "~> 2"
   gem 'rake'
 end

data/README.md

@@ -4,8 +4,9 @@
 
 ### Usage
 
-$ gem install ruhoh     
-$ ruhoh help
+This is the new ruhoh 2.x.alpha code.
+
+Please follow the directions on the [new 2.0.alpha blog scaffold](https://github.com/ruhoh/blog/tree/2.0.alpha#readme)
 
 ### Platforms
 

data/Rakefile

@@ -17,33 +17,12 @@ task :release => :build do
   sh "gem push pkg/#{name}-#{Ruhoh::VERSION}.gem"
 end
 
-task :build => :gemspec do
+task :build do
   sh "mkdir -p pkg"
   sh "gem build #{gemspec_file}"
   sh "mv #{gem_file} pkg"
 end
 
-task :gemspec do
-  # read spec file and split out manifest section
-  spec = File.read(gemspec_file)
-  head, manifest, tail = spec.split("  # = MANIFEST =\n")
-
-  # determine file list from git ls-files
-  files = `git ls-files`.
-    split("\n").
-    sort.
-    reject { |file| file =~ /^\./ }.
-    reject { |file| file =~ /^(rdoc|pkg|coverage)/ }.
-    map { |file| "    #{file}" }.
-    join("\n")
-
-  # piece file back together and write
-  manifest = "  s.files = %w[\n#{files}\n  ]\n"
-  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
-  File.open(gemspec_file, 'w') { |io| io.write(spec) }
-  puts "Updated #{gemspec_file}"
-end
-
 ## Tests
 
 RSpec::Core::RakeTask.new('spec')

data/bin/ruhoh

@@ -4,7 +4,7 @@ $:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
 
 require 'ruhoh'
 require 'ruhoh/version'
-require 'ruhoh/client/client'
+require 'ruhoh/client'
 
 require 'optparse'
 
@@ -14,10 +14,6 @@ options = Options.new
 opt_parser = OptionParser.new do |opts|
   opts.banner = 'Use `ruhoh help` for full command list.'
   
-  opts.on("-e", "--ext [EXT]", "Specify filename extension. Defaults to '.md' ") do |ext|
-    options.ext = ext
-  end
-  
   opts.on("--hg", "Use mercurial (hg) instead of git for source control.") do
     options.hg = true
   end

data/history.json

@@ -1,4 +1,20 @@
 [
+  {
+    "version" : "2.1",
+    "date" : "19.05.2013",
+    "changes" : [
+      "Major release. Internal logic has been drastically changed."
+    ],
+    "features" : [
+      "Support for arbitrary custom collections, e.g. ability to model essays, snippets, posts, etc.",
+      "Page finders can omit file extensions so you can reference the about.md file using 'about'.",
+      "All collections can have their own paginator.",
+      "themes and config.yml are optional implying very basic websites can be built without configuration overhead.",
+      "ruhoh environment is not instantiated, meaning everything exists in its own instance.",
+      "Improved cache management",
+      "Support for asset pipeline."
+    ]
+  },
   {
     "version" : "1.1",
     "date" : "26.08.2012",

data/lib/ruhoh.rb

@@ -3,111 +3,256 @@ Encoding.default_internal = 'UTF-8'
 require 'yaml'
 require 'psych'
 YAML::ENGINE.yamler = 'psych'
-
 require 'json'
 require 'time'
 require 'cgi'
 require 'fileutils'
 require 'ostruct'
+require 'delegate'
+require 'digest'
+require 'observer'
 
 require 'mustache'
 
 require 'ruhoh/logger'
 require 'ruhoh/utils'
 require 'ruhoh/friend'
-require 'ruhoh/config'
-require 'ruhoh/paths'
-require 'ruhoh/urls'
-require 'ruhoh/db'
-require 'ruhoh/templaters/rmustache'
-require 'ruhoh/converters/converter'
-require 'ruhoh/page'
-require 'ruhoh/previewer'
-require 'ruhoh/watch'
-require 'ruhoh/program'
+
+require 'ruhoh/converter'
+require 'ruhoh/views/master_view'
+require 'ruhoh/collections'
+require 'ruhoh/cache'
+require 'ruhoh/routes'
+require 'ruhoh/programs/preview'
 
 class Ruhoh
-  
   class << self
     attr_accessor :log
-    attr_reader :config, :names, :paths, :root, :urls, :base
+    attr_reader :names, :root
   end
-  
-  @log = Ruhoh::Logger.new
+
+  attr_accessor :log, :env
+  attr_reader :config, :paths, :root, :base, :cache, :collections, :routes
+
   Root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-  Names = {
-    :assets => 'assets',
-    :config_data => 'config.yml',
-    :compiled => 'compiled',
-    :dashboard_file => 'dash.html',
-    :layouts => 'layouts',
-    :media => 'media',
-    :pages => 'pages',
-    :partials => 'partials',
-    :plugins => 'plugins',
-    :posts => 'posts',
-    :javascripts => 'javascripts',
-    :scaffolds => 'scaffolds',
-    :site_data => 'site.yml',
-    :stylesheets => 'stylesheets',
-    :system => 'system',
-    :themes => 'themes',
-    :theme_config => 'theme.yml',
-    :widgets => 'widgets',
-    :widget_config => 'config.yml'
-  }
-  @names = OpenStruct.new(Names)
+  @log = Ruhoh::Logger.new
   @root = Root
-  
+
+  def initialize
+    @collections = Ruhoh::Collections.new(self)
+    @cache = Ruhoh::Cache.new(self)
+    @routes = Ruhoh::Routes.new(self)
+  end
+
+  def master_view(pointer)
+    Ruhoh::Views::MasterView.new(self, pointer)
+  end
+
   # Public: Setup Ruhoh utilities relative to the current application directory.
   # Returns boolean on success/failure
-  def self.setup(opts={})
-    self.reset
-    @log.log_file = opts[:log_file] if opts[:log_file]
-    @base = opts[:source] if opts[:source]
-    @config = Ruhoh::Config.generate
-    !!@config
-  end
-  
-  def self.reset
-    @base = Dir.getwd
-  end
-  
-  def self.setup_paths
-    self.ensure_config
-    @paths = Ruhoh::Paths.generate
-  end
-
-  def self.setup_urls
-    self.ensure_config
-    @urls = Ruhoh::Urls.generate
-  end
-  
-  def self.setup_plugins
-    self.ensure_paths
-    plugins = Dir[File.join(self.paths.plugins, "**/*.rb")]
+  def setup(opts={})
+    self.class.log.log_file = opts[:log_file] if opts[:log_file] #todo
+    @base = opts[:source] ? opts[:source] : Dir.getwd
+    !!config
+  end
+
+  def collection(resource)
+    @collections.load(resource)
+  end
+
+  def config
+    config = Ruhoh::Utils.parse_yaml_file(@base, "config.yml") || {}
+    config['compiled'] = config['compiled'] ? File.expand_path(config['compiled']) : "compiled"
+
+    config['_root'] ||= {}
+    config['_root']['permalink'] ||= "/:relative_path/:filename"
+    config['_root']['paginator'] ||= {}
+    config['_root']['paginator']['url'] ||= "/index/"
+    config['_root']['rss'] ||= {}
+    config['_root']['rss']['url'] ||= "/"
+
+    config['base_path'] = config['base_path'].to_s.strip
+    if config['base_path'].empty?
+      config['base_path'] = '/'
+    else
+      config['base_path'] += "/" unless config['base_path'][-1] == '/'
+    end
+
+    @config = config
+  end
+
+  Paths = Struct.new(:base, :theme, :system, :compiled)
+  def setup_paths
+    @paths = Paths.new
+    @paths.base = @base
+    @paths.system = File.join(Ruhoh::Root, "system")
+    @paths.compiled = @config["compiled"]
+
+    theme = @config.find{ |resource, data| data['use'] == "theme" }
+    if theme
+      Ruhoh::Friend.say { plain "Using theme: \"#{theme[0]}\""}
+      @paths.theme = File.join(@base, theme[0])
+    end
+
+    @paths
+  end
+
+  # Default paths to the 3 levels of the cascade.
+  def cascade
+    a = [
+      {
+        "name" => "system",
+        "path" => paths.system
+      },
+      {
+        "name" => "base",
+        "path" => paths.base
+      }
+    ]
+    a << {
+      "name" => "theme",
+      "path" => paths.theme
+    } if paths.theme
+
+    a
+  end
+
+  def setup_plugins
+    ensure_paths
+
+    enable_sprockets = @config['asset_pipeline']['enable'] rescue false
+    if enable_sprockets
+      Ruhoh::Friend.say { green "=> Oh boy! Asset pipeline enabled by way of sprockets =D" }
+      sprockets = Dir[File.join(@paths.system, "plugins", "sprockets", "**/*.rb")]
+      sprockets.each {|f| require f }
+    end
+
+    plugins = Dir[File.join(@base, "plugins", "**/*.rb")]
     plugins.each {|f| require f } unless plugins.empty?
   end
-  
-  def self.ensure_setup
-    return if Ruhoh.config && Ruhoh.paths && Ruhoh.urls
+
+  def env
+    @env || 'development'
+  end
+
+  def base_path
+    (env == 'production') ?
+      config['base_path'] :
+      '/'
+  end
+
+  # @config['base_path'] is assumed to be well-formed.
+  # Always remove trailing slash.
+  # Returns String - normalized url with prepended base_path
+  def to_url(*args)
+    url = base_path + args.join('/')
+    url = url.gsub(/\/{2,}/, '/')
+    (url == "/") ? url : url.chomp('/')
+  end
+
+  def relative_path(filename)
+    filename.gsub(Regexp.new("^#{@base}/"), '')
+  end
+
+  # Compile the ruhoh instance (save to disk).
+  # Note: This method recursively removes the target directory. Should there be a warning?
+  #
+  # Extending:
+  #   TODO: Deprecate this functionality and come up with a 2.0-friendly interface.
+  #   The Compiler module is a namespace for all compile "tasks".
+  #   A "task" is a ruby Class that accepts @ruhoh instance via initialize.
+  #   At compile time all classes in the Ruhoh::Compiler namespace are initialized and run.
+  #   To add your own compile task simply namespace a class under Ruhoh::Compiler
+  #   and provide initialize and run methods:
+  #
+  #  class Ruhoh
+  #    module Compiler
+  #      class CustomTask
+  #        def initialize(ruhoh)
+  #          @ruhoh = ruhoh
+  #        end
+  #       
+  #        def run
+  #          # do something here
+  #        end
+  #      end
+  #    end
+  #  end
+  def compile
+    ensure_paths
+    Ruhoh::Friend.say { plain "Compiling for environment: '#{@env}'" }
+    FileUtils.rm_r @paths.compiled if File.exist?(@paths.compiled)
+    FileUtils.mkdir_p @paths.compiled
+
+    # Run the resource compilers
+    compilers = @collections.all
+    # Hack to ensure assets are processed first so post-processing logic reflects in the templates.
+    compilers.delete('stylesheets')
+    compilers.unshift('stylesheets')
+    compilers.delete('javascripts')
+    compilers.unshift('javascripts')
+
+    compilers.each do |name|
+      collection = collection(name)
+      next unless collection.compiler?
+      collection.load_compiler.run
+    end
+
+    # Run extra compiler tasks if available:
+    if Ruhoh.const_defined?(:Compiler)
+      Ruhoh::Compiler.constants.each {|c|
+        compiler = Ruhoh::Compiler.const_get(c)
+        next unless compiler.respond_to?(:new)
+        task = compiler.new(self)
+        next unless task.respond_to?(:run)
+        task.run
+      }
+    end
+
+    true
+  end
+
+  # Find a file in the base cascade directories
+  # @return[Hash, nil] a single file pointer
+  def find_file(key)
+    dict = _all_files
+    dict[key] || dict.values.find{ |a| key == a['id'].gsub(/.[^.]+$/, '') }
+  end
+
+  # Collect all files from the base bascade directories.
+  # @return[Hash] dictionary of file pointers
+  def _all_files
+    dict = {}
+    cascade.map{ |a| a['path'] }.each do |path|
+      FileUtils.cd(path) { 
+        Dir["*"].each { |id|
+          next unless File.exist?(id) && FileTest.file?(id)
+          dict[id] = {
+            "id" => id,
+            "realpath" => File.realpath(id),
+          }
+        }
+      }
+    end
+
+    dict
+  end
+
+  def ensure_setup
+    return if @config && @paths
     raise 'Ruhoh has not been fully setup. Please call: Ruhoh.setup'
-  end  
-  
-  def self.ensure_config
-    return if Ruhoh.config
-    raise 'Ruhoh has not setup config. Please call: Ruhoh.setup'
-  end  
-
-  def self.ensure_paths
-    return if Ruhoh.config && Ruhoh.paths
+  end
+
+  def ensure_paths
+    return if @config && @paths
     raise 'Ruhoh has not setup paths. Please call: Ruhoh.setup'
-  end  
-  
-  def self.ensure_urls
-    return if Ruhoh.config && Ruhoh.urls
-    raise 'Ruhoh has not setup urls. Please call: Ruhoh.setup + Ruhoh.setup_urls' 
-  end  
-  
-  
-end # Ruhoh
+  end
+
+  def self.collection(resource)
+    Collections.load(resource)
+  end
+
+  def self.model(resource)
+    Collections.get_module_namespace_for(resource).const_get(:ModelView)
+  end
+end

data/lib/ruhoh/base/collection.rb

@@ -0,0 +1,280 @@
+module Ruhoh::Base
+
+  module Collectable
+
+    def self.included(klass)
+      klass.__send__(:attr_accessor, :resource_name, :master)
+      klass.__send__(:attr_reader, :ruhoh)
+    end
+
+    def initialize(ruhoh)
+      @ruhoh = ruhoh
+    end
+
+    # Public API for finding a resource from this collection
+    # @param name_or_pointer [String, Hash]
+    #  Hash   - File pointer
+    #  String - id (filename) with full extension, e.g: about-me.md
+    #  String - name (filename) without the extension e.g: about-me
+    #           Returns the first matched filename.
+    #           See implementation for how match is determined.
+    # @param opts [Hash] Optional options
+    #  opts[:all] - true to search all files as some may be invalid as resources
+    #
+    # @return[model, nil] the model is always wrapped in its view.
+    def find(name_or_pointer, opts={})
+      pointer = find_file(name_or_pointer, opts)
+      return nil unless pointer
+
+      @ruhoh.cache.get(pointer['realpath']) ||
+      @ruhoh.cache.set(pointer['realpath'], load_model_view(pointer))
+    end
+
+    # Public API
+    # @return[Hash] dictionary of models { "id" => Model }
+    def dictionary
+      dict = {}
+      files.values.each { |pointer|
+        dict.merge!({
+          pointer['id'] => find(pointer)
+        })
+      }
+      dict
+    end
+
+    def resource_name
+      @resource_name ||= self.class.name.split("::").pop
+    end
+
+    # Implemented via Observable module
+    # See http://ruby-doc.org/stdlib-1.9.3/libdoc/observer/rdoc/Observable.html
+    # Collection subscribes to its child models.
+    # #update is called on model #process.
+    # noop
+    def update(model_data)
+    end
+
+    # The default glob for finding files.
+    # Every file in all child directories.
+    def glob
+      "**/*"
+    end
+
+    # Default paths to the 3 levels of the cascade.
+    def paths
+      Array(@ruhoh.cascade.map{|h| h["path"]}).map { |path|
+        collection_path = File.join(path, resource_name)
+        next unless File.directory?(collection_path)
+
+        collection_path
+      }.compact
+    end
+
+    # Does this resource have any valid paths to process?
+    # A valid path may exist on any of the cascade levels.
+    # False means there are no directories on any cascade level.
+    # @returns[Boolean]
+    def paths?
+      !paths.empty?
+    end
+
+    def config
+      config = @ruhoh.config[resource_name] || {}
+      unless config.is_a?(Hash)
+        Ruhoh.log.error("'#{resource_name}' config key in config.yml" +
+                        " is a #{config.class}; it needs to be a Hash (object).")
+      end
+      config
+    end
+
+    # NOOP
+    # touch a model.
+    # Used to perform custom regeneration logic against a model.
+    def touch(name_or_pointer)
+    end
+
+    # @param key [String, Hash]
+    #  String - id (filename) with full extension, e.g: about-me.md
+    #  String - name (filename) without the extension e.g: about-me
+    #           Returns the first matched filename.
+    #           See implementation for how match is determined.
+    #  Hash   - File pointer
+    #
+    # @param opts [Hash] Optional options
+    #  opts[:all] - true to search all files as some may be invalid as resources
+    #
+    # @return [pointer, nil]
+    def find_file(key, opts={})
+      return key if key.is_a?(Hash) # assume valid pointer
+
+      dict = opts[:all] ? _all_files : files
+
+      dict[key] || dict.values.find{ |a| key == a['id'].gsub(/.[^.]+$/, '') }
+    end
+
+    # Collect all files (as mapped by data resources) for this data endpoint.
+    # Each resource can have 3 file references, one per each cascade level.
+    # The file hashes are collected in order 
+    # so they will overwrite eachother if found.
+
+    # @param id [String, Array] Optional.
+    #   Collect all files for a single data resource.
+    #   Can be many files due to the cascade.
+    # @param [block] Optional.
+    #   Implement custom validation logic by passing in a block.
+    #   The block is given (id, self) as args.
+    #   Return true/false for whether the file is valid/invalid.
+    #
+    # @return[Hash] dictionary of pointers.
+    def files(id=nil, &block)
+      return @ruhoh.cache.get(files_cache_key) if @ruhoh.cache.get(files_cache_key)
+
+      dict = _all_files
+      dict.keep_if do |id, pointer|
+        block_given? ? yield(id, self) : valid_file?(id)
+      end
+
+      @ruhoh.cache.set(files_cache_key, dict)
+      dict
+    end
+
+    # Collect all files within this collection, valid or otherwise.
+    # Each resource can have 3 file references, one per each cascade level.
+    # The file hashes are collected in order and overwrite eachother if found.
+    # This is a low-level method, see #files for the public interface.
+    #
+    # @return[Hash] dictionary of pointers.
+    def _all_files
+      dict = {}
+      paths.each do |path|
+        FileUtils.cd(path) { 
+          Dir[glob].each { |id|
+            next unless File.exist?(id) && FileTest.file?(id)
+            dict[id] = {
+              "id" => id,
+              "realpath" => File.realpath(id),
+              "resource" => resource_name,
+            }
+          }
+        }
+      end
+
+      dict
+    end
+
+    def valid_file?(filepath)
+      return false if filepath.start_with?('.')
+      return false if filepath.start_with?('_')
+      excludes = Array(config['exclude']).map { |node| Regexp.new(node) }
+      excludes.each { |regex| return false if filepath =~ regex }
+      true
+    end
+
+    %w{
+      collection_view
+      model
+      model_view
+      client
+      compiler
+      watcher
+      previewer
+    }.each do |method_name|
+      define_method(method_name) do
+        get_module_namespace.const_get(camelize(method_name).to_sym)
+      end
+
+      define_method("#{method_name}?") do
+        get_module_namespace.const_defined?(camelize(method_name).to_sym)
+      end
+    end
+
+    def load_collection_view
+      @_collection_view ||= collection_view? ?
+                              collection_view.new(self) :
+                              self
+    end
+
+    def load_model(pointer)
+      _model = model? ?
+                model.new(@ruhoh, pointer) :
+                Ruhoh::Base::Model.new(@ruhoh, pointer)
+      _model.add_observer(self)
+      _model
+    end
+
+    def load_model_view(pointer)
+      model_view? ? 
+        model_view.new(load_model(pointer)) :
+        Ruhoh::Base::ModelView.new(load_model(pointer))
+    end
+
+    def load_client(opts)
+      @_client ||= client.new(load_collection_view, opts)
+    end
+
+    def load_compiler
+      @_compiler ||= compiler.new(load_collection_view)
+    end
+
+    def load_watcher(*args)
+      @_watcher ||= watcher? ?
+        watcher.new(load_collection_view) :
+        Ruhoh::Base::Watcher.new(load_collection_view)
+    end
+
+    def load_previewer(*args)
+      @_previewer ||= previewer.new(@ruhoh)
+    end
+
+    def files_cache_key
+      "#{ resource_name }-files"
+    end
+
+    def scaffold
+      pointer = find_file('_scaffold', all: true) || @ruhoh.find_file('_scaffold')
+      return '' unless pointer
+
+      File.open(pointer['realpath'], 'r:UTF-8') { |f| f.read }
+    end
+
+    protected
+
+    # Load the registered resource else default to Pages if not configured.
+    # @returns[Constant] the resource's module namespace
+    def get_module_namespace
+      type = @ruhoh.config[resource_name]["use"] rescue nil
+      if type
+        if @ruhoh.collections.registered.include?(type)
+          Ruhoh::Resources.const_get(camelize(type))
+        elsif @ruhoh.collections.base.include?(type)
+          Ruhoh::Base.const_get(camelize(type))
+        else
+          klass = camelize(type)
+          Friend.say {
+            red "#{resource_name} resource set to use:'#{type}' in config.yml" +
+                " but Ruhoh::Resources::#{klass} does not exist."
+          }
+          abort
+        end
+      else
+        if @ruhoh.collections.registered.include?(resource_name)
+          Ruhoh::Resources.const_get(camelize(resource_name))
+        else
+          Ruhoh::Resources.const_get(:Pages)
+        end
+      end
+    end
+
+    def camelize(name)
+      name.to_s.split('_').map { |a| a.capitalize }.join
+    end
+  end
+
+  # Generic base implementation of a Collection class.
+  # All collections use this class by default
+  # unless the Collection class is explicitly defined for the resource.
+  class Collection
+    include Collectable
+  end
+
+end