ruhoh 2.5 → 2.6

data/features/support/helpers.rb

@@ -2,17 +2,15 @@
 SampleSitePath = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '__tmp'))
 
 def start
-  @ruhoh = Ruhoh.new
-  @ruhoh.setup(:source => SampleSitePath)
+  @ruhoh = Ruhoh.new(:source => SampleSitePath)
   @ruhoh.env = :test
-  @ruhoh.setup_paths
   @ruhoh.setup_plugins
 end
 
 def compile
   start
   @ruhoh.env = 'production'
-  @ruhoh.paths.compiled = File.join(SampleSitePath, 'compiled')
+  @ruhoh.config['compiled_path'] = File.join(SampleSitePath, 'compiled')
   @ruhoh.compile
 end
 
@@ -55,7 +53,7 @@ TEXT
 end
 
 def get_compiled_file(path)
-  FileUtils.cd(@ruhoh.paths.compiled) {
+  FileUtils.cd(@ruhoh.config['compiled_path']) {
     File.open(path, 'r:UTF-8') { |f| 
       return f.read }
   }

data/history.json

@@ -1,4 +1,25 @@
 [
+  {
+    "version" : "2.6",
+    "date" : "13.12.2013",
+    "changes" : [
+      "config['compiled'] is now config['compiled_path'] and compiled folder is collection ignored.",
+      "Dash is no longer a collection, it is tracked on the root blog level and may be overloaded as normal."
+    ],
+    "features" : [
+      "config file now deep merges itself down the cascade.",
+      "data file now deep merges itself down the cascade.",
+      "page_not_found UI can now be overloaded via the cascade.",
+      "Any page metatdata attribute can be used in custom permalink",
+      "@nicolaracco adds ability to load plugins from gems."
+    ],
+    "bugs" : [
+      "@mudasobwa fix for non-ASCII summaries",
+      "custo data collections now work as expected as per the collection API.",
+      "@richtera enables ?to_javascripts to work with needed fingerpinting inclusion."
+    ]
+  }
+  ,
   {
     "version" : "2.5",
     "date" : "22.09.2013",

data/lib/ruhoh.rb

@@ -18,6 +18,8 @@ require 'ruhoh/utils'
 require 'ruhoh/friend'
 require 'ruhoh/parse'
 
+require 'ruhoh/config'
+require 'ruhoh/cascade'
 require 'ruhoh/converter'
 require 'ruhoh/views/master_view'
 require 'ruhoh/collections'
@@ -26,21 +28,24 @@ require 'ruhoh/routes'
 require 'ruhoh/string_format'
 require 'ruhoh/url_slug'
 require 'ruhoh/programs/preview'
+require 'ruhoh/plugins/plugin'
 
 class Ruhoh
   class << self
     attr_accessor :log
-    attr_reader :names, :root
+    attr_reader :root
   end
 
   attr_accessor :log, :env
-  attr_reader :config, :paths, :root, :base, :cache, :collections, :routes
+  attr_reader :root, :cache, :collections, :routes
 
   Root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
   @log = Ruhoh::Logger.new
   @root = Root
 
-  def initialize
+  def initialize(opts={})
+    self.class.log.log_file = opts[:log_file] if opts[:log_file] #todo
+    @base = opts[:source] ? opts[:source] : Dir.getwd
     @collections = Ruhoh::Collections.new(self)
     @cache = Ruhoh::Cache.new(self)
     @routes = Ruhoh::Routes.new(self)
@@ -50,119 +55,55 @@ class Ruhoh
     Ruhoh::Views::MasterView.new(self, pointer)
   end
 
-  # Public: Setup Ruhoh utilities relative to the current application directory.
-  # Returns boolean on success/failure
-  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(reload=false)
-    return @config unless (reload or @config.nil?)
-
-    config = Ruhoh::Parse.data_file(@base, "config") || {}
-    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
-
-    Time.default_format = config['date_format'] || "%Y-%m-%d"
-
-    @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.is_a?(Hash) && data['use'] == "theme" }
-    if theme
-      Ruhoh::Friend.say { plain "Using theme: \"#{theme[0]}\""}
-      @paths.theme = File.join(@base, theme[0])
-    end
-
-    @paths
+  def config
+    return @config if @config
+    @config = Ruhoh::Config.new(self)
+    @config.touch
   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
+    return @cascade if @cascade
 
-    a
+    @cascade = Ruhoh::Cascade.new(config)
+    @cascade.base = @base
+    config.touch
+
+    @cascade
   end
 
   def setup_plugins
-    ensure_paths
-
-    enable_sprockets = @config['asset_pipeline']['enable'] rescue false
+    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 = Dir[File.join(cascade.system, "plugins", "sprockets", "**/*.rb")]
       sprockets.each {|f| require f }
     end
+    require 'ruhoh/plugins/local_plugins_plugin'
 
-    plugins = Dir[File.join(@base, "plugins", "**/*.rb")]
-    plugins.each {|f| require f } unless plugins.empty?
+    Ruhoh::Plugins::Plugin.run_all self
   end
 
   def env
     @env || 'development'
   end
 
-  def base_path
-    return '/' unless (env == 'production')
-
-    string = config['base_path'].chomp('/').reverse.chomp('/').reverse
-    return '/' if string.empty? || string == '/'
-    "/#{ string }/"
-  end
-
   def compiled_path(url)
     if config['compile_as_root']
-      url = url.gsub(/^#{ base_path.chomp('/') }\/?/, '')
+      url = url.gsub(/^#{ config.base_path.chomp('/') }\/?/, '')
     end
 
-    path = File.expand_path(File.join(paths.compiled, url)).gsub(/\/{2,}/, '/')
+    path = File.expand_path(File.join(config['compiled_path'], url)).gsub(/\/{2,}/, '/')
     CGI.unescape(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 = config.base_path + args.join('/')
     url = url.gsub(/\/{2,}/, '/')
     (url == "/") ? url : url.chomp('/')
   end
@@ -196,10 +137,9 @@ class Ruhoh
   #    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
+    FileUtils.rm_r config['compiled_path'] if File.exist?(config['compiled_path'])
+    FileUtils.mkdir_p config['compiled_path']
 
     # Run the resource compilers
     compilers = @collections.all
@@ -209,6 +149,7 @@ class Ruhoh
     compilers.delete('javascripts')
     compilers.unshift('javascripts')
 
+
     compilers.each do |name|
       collection = collection(name)
       next unless collection.compiler?
@@ -229,42 +170,6 @@ class Ruhoh
     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 cascade 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 ensure_paths
-    return if @config && @paths
-    raise 'Ruhoh has not setup paths. Please call: Ruhoh.setup'
-  end
-
   def self.collection(resource)
     Collections.load(resource)
   end

data/lib/ruhoh/base/collectable.rb

@@ -0,0 +1,273 @@
+module Ruhoh::Base::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.paths.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" +
+                      " 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?('_')
+    return false if  %w{ config.json config.yaml config.yml }.include?(filepath)
+    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.cascade.find_file('_scaffold')
+    return '' unless pointer
+
+    File.open(pointer['realpath'], 'r:UTF-8') { |f| f.read }
+  end
+
+  def compiled_path
+    @compiled_path ||= @ruhoh.compiled_path(@ruhoh.to_url(url_endpoint))
+  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" +
+              " 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