ruhoh 2.5 → 2.6

data/lib/ruhoh/base/compilable.rb

@@ -0,0 +1,30 @@
+module Ruhoh::Base::Compilable
+  def self.included(klass)
+    __send__(:attr_reader, :collection)
+  end
+
+  def initialize(collection)
+    @ruhoh = collection.ruhoh
+    @collection = collection
+  end
+
+  def setup_compilable
+    return false unless collection_exists?
+
+    compile_collection_path
+  end
+
+  def compile_collection_path
+    FileUtils.mkdir_p(@collection.compiled_path)
+  end
+
+  def collection_exists?
+    collection = @collection
+    unless @collection.paths?
+      Ruhoh::Friend.say { yellow "#{ collection.resource_name.capitalize }: directory not found - skipping." }
+      return false
+    end
+    Ruhoh::Friend.say { cyan "#{ collection.resource_name.capitalize }: (copying valid files)" }
+    true
+  end
+end

data/lib/ruhoh/base/compilable_asset.rb

@@ -0,0 +1,30 @@
+require 'ruhoh/base/compilable'
+module Ruhoh::Base::CompilableAsset
+  include Ruhoh::Base::Compilable
+
+  # A basic compiler task which copies each valid collection resource file to the compiled folder.
+  # This is different from the static compiler in that it supports fingerprinting.
+  # Valid files are identified by their pointers.
+  # Invalid files are files that are excluded from the resource's configuration settings.
+  # The collection's url_endpoint is used to determine the final compiled path.
+  #
+  # @returns Nothing.
+  def run
+    return unless setup_compilable
+
+    manifest = {}
+    @collection.files.values.each do |pointer|
+      digest = Digest::MD5.file(pointer['realpath']).hexdigest
+      digest_file = pointer['id'].sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+      manifest[pointer['id']] = digest_file
+
+      compiled_file = File.join(@collection.compiled_path, digest_file)
+      FileUtils.mkdir_p File.dirname(compiled_file)
+      FileUtils.cp_r pointer['realpath'], compiled_file
+      Ruhoh::Friend.say { green "  > #{pointer['id']}" }
+    end
+
+    # Update the paths to the digest format:
+    @collection.load_collection_view._cache.merge!(manifest)
+  end
+end

data/lib/ruhoh/base/model_viewable.rb

@@ -0,0 +1,30 @@
+module Ruhoh::Base::ModelViewable
+  def initialize(model)
+    super(model)
+    @model = model
+    @ruhoh = model.ruhoh
+
+    # Define direct access to the data Hash object
+    # but don't overwrite methods if already defined.
+    data.keys.each do |method|
+      (class << self; self; end).class_eval do
+        next if method_defined?(method)
+        define_method method do |*args, &block|
+          data[method]
+        end
+      end
+    end
+  end
+
+  def <=>(other)
+    id <=> other.id
+  end
+
+  def [](attribute)
+    __send__(attribute)
+  end
+
+  def []=(key, value)
+    __send__("#{key}=", value)
+  end
+end

data/lib/ruhoh/base/modelable.rb

@@ -0,0 +1,44 @@
+module Ruhoh::Base::Modelable
+  include Observable
+  
+  def self.included(klass)
+    klass.__send__(:attr_reader, :pointer, :ruhoh)
+  end
+
+  def initialize(ruhoh, pointer)
+    raise "Cannot instantiate a model with a nil pointer" unless pointer
+    @ruhoh = ruhoh
+    @pointer = pointer
+  end
+  
+  # @returns[Hash Object] Top page metadata
+  def data
+    return @data if @data
+    process
+    @data || {}
+  end
+
+  # @returns[String] Raw (unconverted) page content
+  def content
+    return @content if @content
+    process
+    @content || ''
+  end
+
+  def collection
+    @ruhoh.collection(@pointer['resource'])
+  end
+
+  # Override this to process custom data
+  def process
+    changed
+    notify_observers(@pointer)
+    @pointer
+  end
+
+  def try(method)
+    return __send__(method) if respond_to?(method)
+    return data[method.to_s] if data.key?(method.to_s)
+    false
+  end
+end

data/lib/ruhoh/base/page_like.rb

@@ -0,0 +1,111 @@
+require 'ruhoh/base/modelable'
+module Ruhoh::Base::PageLike
+  include Ruhoh::Base::Modelable
+
+  DateMatcher = /^(.+\/)*(\d+-\d+-\d+)-(.*)(\.[^.]+)$/
+  Matcher = /^(.+\/)*(.*)(\.[^.]+)$/
+
+  # Process this file. See #parse_page_file
+  # @return[Hash] the processed data from the file.
+  #   ex:
+  #   { "content" => "..", "data" => { "key" => "value" } }
+  def process
+    return {} unless file?
+
+    parsed_page = parse_page_file
+    data = parsed_page['data']
+
+    filename_data = parse_page_filename(@pointer['id'])
+
+    data['pointer'] = @pointer
+    data['id'] = @pointer['id']
+
+    data['title'] = data['title'] || filename_data['title']
+    data['date'] ||= filename_data['date']
+
+    # Parse and store date as an object
+    begin
+      data['date'] = Time.parse(data['date']) unless data['date'].nil? || data['date'].is_a?(Time)
+    rescue
+      Ruhoh.log.error(
+        "ArgumentError: The date '#{data['date']}' specified in '#{@pointer['id']}' is unparsable."
+      )
+      data['date'] = nil
+    end
+    data['url'] = url(data)
+    data['layout'] = collection.config['layout'] if data['layout'].nil?
+
+    parsed_page['data'] = data
+
+    changed
+    notify_observers(parsed_page)
+    data
+  end
+
+  protected
+
+  # Is the resource backed by a physical file in the filesystem?
+  # For example the pagination system uses a page-stub
+  # that has no reference to an actual file.
+  # @return[Boolean]
+  def file?
+    !!@pointer['realpath']
+  end
+
+  # See Ruhoh::Parse.page_file
+  # @returns[Hash Object] processed top meta-data, raw (unconverted) content body
+  def parse_page_file
+    raise "File not found: #{@pointer['realpath']}" unless File.exist?(@pointer['realpath'])
+    result = Ruhoh::Parse.page_file(@pointer['realpath'])
+
+    # variable cache
+    @data = result["data"]
+    @content = result['content']
+
+    result
+  end
+
+  def parse_page_filename(filename)
+    data = *filename.match(DateMatcher)
+    data = *filename.match(Matcher) if data.empty?
+    return {} if data.empty?
+
+    if filename =~ DateMatcher
+      {
+        "path" => data[1],
+        "date" => data[2],
+        "slug" => data[3],
+        "title" => self.to_title(data[3]),
+        "extension" => data[4]
+      }
+    else
+      {
+        "path" => data[1],
+        "slug" => data[2],
+        "title" => to_title(data[2]),
+        "extension" => data[3]
+      }
+    end
+  end
+
+  # my-post-title ===> My Post Title
+  def to_title(file_slug)
+    if file_slug == 'index' && !@pointer['id'].index('/').nil?
+      file_slug = @pointer['id'].split('/')[-2]
+    end
+
+    Ruhoh::StringFormat.titleize(file_slug)
+  end
+
+  def url(page_data)
+    page_data['permalink_ext'] ||= collection.config['permalink_ext']
+
+    format = page_data['permalink'] ||
+             collection.config['permalink'] ||
+             "/:path/:filename"
+
+    slug = Ruhoh::UrlSlug.new(page_data: page_data, format: format)
+
+    @ruhoh.to_url(slug.generate)
+  end
+end

data/lib/ruhoh/base/page_viewable.rb

@@ -0,0 +1,92 @@
+require 'ruhoh/summarizer'
+require 'ruhoh/base/model_viewable'
+module Ruhoh::Base::PageViewable
+  include Ruhoh::Base::ModelViewable
+
+  # Default order by alphabetical title name.
+  def <=>(other)
+    sort = @model.collection.config["sort"] || []
+    attribute = sort[0] || "title"
+    direction = sort[1] || "asc"
+
+    this_data = __send__(attribute)
+    other_data = other.__send__(attribute)
+    if attribute == "date"
+      if this_data.nil? || other_data.nil?
+        Ruhoh.log.error(
+          "ArgumentError:" +
+          " The '#{ @model.collection.resource_name }' collection is configured to sort based on 'date'" +
+          " but '#{ @model.pointer['id'] }' has no parseable date in its metadata." +
+          " Add date: 'YYYY-MM-DD' to its YAML metadata."
+        )
+      end
+      direction = sort[1] || "desc" #default should be reverse
+    end
+
+    if direction == "asc"
+      this_data <=> other_data
+    else
+      other_data <=> this_data
+    end
+  end
+
+  def categories
+    @model.collection.to_categories(data['categories'])
+  end
+
+  def tags
+    @model.collection.to_tags(data['tags'])
+  end
+
+  # Lazy-load the page body.
+  # Notes:
+  # @content is not used for caching, it's used to manually
+  # define content for a given page. Useful in the case that
+  # you want to model a resource that does not actually
+  # reference a file.
+  def content
+    return @content if @content
+    content = @model.collection.master.render(@model.content)
+    Ruhoh::Converter.convert(content, id)
+  end
+
+  def is_active_page
+    id == @model.collection.master.page_data['id']
+  end
+
+  def summary
+    model_data = @model.data
+    collection_config = @model.collection.config
+
+    line_limit = model_data['summary_lines'] ||
+                 collection_config['summary_lines']
+    stop_at_header = model_data['summary_stop_at_header'] ||
+                     collection_config['summary_stop_at_header']
+
+    Ruhoh::Summarizer.new({
+      content: @ruhoh.master_view(@model.pointer).render_content,
+      line_limit: line_limit,
+      stop_at_header: stop_at_header
+    }).generate
+  end
+
+  def next
+    return unless id
+    all_cache = @model.collection.all
+    index = all_cache.index {|p| p["id"] == id}
+    return unless index && (index-1 >= 0)
+    _next = all_cache[index-1]
+    return unless _next
+    _next
+  end
+
+  def previous
+    return unless id
+    all_cache = @model.collection.all
+    index = all_cache.index {|p| p["id"] == id}
+    return unless index && (index+1 >= 0)
+    prev = all_cache[index+1]
+    return unless prev
+    prev
+  end
+end

data/lib/ruhoh/base/routable.rb

@@ -0,0 +1,20 @@
+# Makes a collection routable.
+module Ruhoh::Base::Routable
+  def routes
+    return @routes if @routes
+    @routes = {}
+    dictionary
+    @routes
+  end
+
+  def routes_add(route, pointer)
+    @routes ||= {}
+    @routes[route] = pointer
+  end
+
+  def routes_delete(pointer)
+    return unless @routes
+    route = @routes.find{ |k, v| v == pointer }
+    @routes.delete(route[0]) if route
+  end
+end

data/lib/ruhoh/base/watchable.rb

@@ -0,0 +1,18 @@
+module Ruhoh::Base::Watchable
+  def self.included(klass)
+    klass.__send__(:attr_accessor, :collection)
+  end
+
+  def initialize(collection)
+    @collection = collection
+  end
+
+  def update(path)
+    # Drop the resource namespace
+    matcher = File::ALT_SEPARATOR ?
+                %r{^.+(#{ File::SEPARATOR }|#{ File::ALT_SEPARATOR })} :
+                %r{^.+#{ File::SEPARATOR }}
+
+    collection.touch(path.gsub(matcher, ''))
+  end
+end

data/lib/ruhoh/cascade.rb

@@ -0,0 +1,93 @@
+class Ruhoh
+  class Cascade
+
+    attr_reader :config
+    attr_accessor :theme, :base, :system
+
+    def initialize(config)
+      @config = config
+      config.add_observer(self)
+    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
+
+    def merge_data_file(key)
+      realpaths = []
+      paths.map{ |a| a['path'] }.each do |path|
+        FileUtils.cd(path) { 
+          match = Dir["*"].find { |id|
+            File.exist?(id) &&
+              FileTest.file?(id) &&
+                id.gsub(/.[^.]+$/, '') == key
+          }
+          next unless match
+          realpaths << File.realpath(match)
+        }
+      end
+
+      return nil unless realpaths && !realpaths.empty?
+
+      data = {}
+      realpaths.each do |path|
+        data = Ruhoh::Utils.deep_merge(data, (Ruhoh::Parse.data_file(path) || {}))
+      end
+
+      data
+    end
+
+    # Collect all files from the base cascade directories.
+    # @return[Hash] dictionary of file pointers
+    def _all_files
+      dict = {}
+      paths.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
+
+    # When config is updated
+    def update(config_data)
+      if config_data['_theme_collection']
+        @theme = File.join(base, config_data['_theme_collection']) 
+      end
+    end
+
+    # Default paths to the 3 levels of the cascade.
+    def paths
+      a = [
+        {
+          "name" => "system",
+          "path" => system
+        },
+        {
+          "name" => "base",
+          "path" => base
+        }
+      ]
+      a << {
+        "name" => "theme",
+        "path" => theme
+      } if theme
+
+      a
+    end
+
+    def system
+      File.join(Ruhoh::Root, "system")
+    end
+  end
+end