ruhoh 1.1 → 2.1

data/lib/ruhoh/resources/widgets/compiler.rb

@@ -0,0 +1,27 @@
+module Ruhoh::Resources::Widgets
+  class Compiler
+    include Ruhoh::Base::Compilable
+
+    def run
+      collection = @collection
+      unless @collection.paths?
+        Ruhoh::Friend.say { yellow "#{collection.resource_name.capitalize}: directory not found - skipping." }
+        return
+      end
+      Ruhoh::Friend.say { cyan "#{collection.resource_name.capitalize}: (copying valid files)" }
+
+      compiled_path = Ruhoh::Utils.url_to_path(@ruhoh.to_url(@collection.url_endpoint), @ruhoh.paths.compiled)
+      FileUtils.mkdir_p compiled_path
+
+      files = @collection.files.values
+      # Don't copy over the layouts.
+      files.delete_if { |p| p['id'].end_with?('.html') }
+      files.each do |pointer|
+        compiled_file = File.join(compiled_path, pointer['id'])
+        FileUtils.mkdir_p File.dirname(compiled_file)
+        FileUtils.cp_r pointer['realpath'], compiled_file
+        Ruhoh::Friend.say { green "  > #{pointer['id']}" }
+      end
+    end
+  end
+end

data/lib/ruhoh/resources/widgets/model.rb

@@ -0,0 +1,16 @@
+module Ruhoh::Resources::Widgets
+  class Model
+    include Ruhoh::Base::PageLike
+
+    def process
+      parsed = parse_page_file
+      @data = parsed['data']
+      @content = parsed['content']
+
+      changed
+      notify_observers(parsed)
+
+      parsed
+    end
+  end
+end

data/lib/ruhoh/routes.rb

@@ -0,0 +1,29 @@
+class Ruhoh
+  class Routes
+    def initialize(ruhoh)
+      @ruhoh = ruhoh
+    end
+
+    def find(route)
+      @ruhoh.collections.acting_as_pages.each do |r|
+        next unless @ruhoh.collection(r).routes[route]
+        return @ruhoh.collection(r).routes[route]
+        break
+      end
+
+      nil
+    end
+
+    # All available routes from pages.
+    # This is not cached because the page collections should manage
+    # their own cache invalidation strategy
+    # @returns[Hash map]
+    def all
+      routes = {}
+      @ruhoh.collections.acting_as_pages.each do |r|
+        routes.merge!(@ruhoh.collection(r).routes)
+      end
+      routes
+    end
+  end
+end

data/lib/ruhoh/utils.rb

@@ -15,60 +15,24 @@ class Ruhoh
       nil
     end
     
-    def self.parse_page_file(*args)
-      path = File.__send__(:join, args)
-      raise "File not found: #{path}" unless File.exist?(path)
-
-      page = File.open(path, 'r:UTF-8') {|f| f.read }
-
-      front_matter = page.match(FMregex)
-      if front_matter
-        data = YAML.load(front_matter[0].gsub(/---\n/, "")) || {}
-        data['categories'] = Array(data['categories'])
-        data['tags'] = Array(data['tags'])
-      else
-        data = {}
-      end
-      
-      { 
-        "data" => data,
-        "content" => page.gsub(FMregex, '')
-      }
-    rescue Psych::SyntaxError => e
-      Ruhoh.log.error("ERROR in #{path}: #{e.message}")
-      nil
-    end
-    
-    def self.parse_layout_file(*args)
-      path = File.__send__(:join, args)
-      raise "Layout file not found: #{path}" unless File.exist?(path)
-      data = {}
-      page = File.open(path, 'r:UTF-8') {|f| f.read }
-
-      front_matter = page.match(FMregex)
-      if front_matter
-        data = YAML.load(front_matter[0].gsub(/---\n/, "")) || {}
-      end
-      
-      { 
-        "data" => data,
-        "content" => page.gsub(FMregex, '')
-      }
-    rescue Psych::SyntaxError => e
-      Ruhoh.log.error("ERROR in #{path}: #{e.message}")
-      nil
-    end
-    
-    def self.relative_path(filename)
-      filename.gsub(Regexp.new("^#{Ruhoh.paths.base}/"), '')
-    end
-
     def self.url_to_path(url, base=nil)
+      url = url.gsub(/^\//, '')
       parts = url.split('/')
       parts = parts.unshift(base) if base
       File.__send__(:join, parts)
     end    
-
+    
+    def self.to_url_slug(title)
+      CGI::escape self.to_slug(title)
+    end
+    
+    # My Post Title ===> my-post-title
+    def self.to_slug(title)
+      title = title.to_s.downcase.strip.gsub(/[^\p{Word}+]/u, '-')
+      title.gsub(/^\-+/, '').gsub(/\-+$/, '').gsub(/\-+/, '-')
+    end
+    
+    
     def self.report(name, collection, invalid)
       output = "#{collection.count}/#{collection.count + invalid.count} #{name} processed."
       if collection.empty? && invalid.empty?
@@ -102,5 +66,24 @@ class Ruhoh
       target
     end
     
+    def self.constantize(class_name)
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ class_name
+        raise NameError, "#{class_name.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+    
+    # Thanks ActiveSupport: http://stackoverflow.com/a/1509939/101940
+    def self.underscore(string)
+      string.
+      to_s.
+      gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+    
   end
 end #Ruhoh

data/lib/ruhoh/version.rb

@@ -1,4 +1,4 @@
 class Ruhoh
-  Version = VERSION = '1.1'
-  RuhohSpec = '1.0'
+  Version = VERSION = '2.1'
+  RuhohSpec = '2.1'
 end

data/lib/ruhoh/views/helpers/categories.rb

@@ -0,0 +1,38 @@
+module Ruhoh::Views::Helpers
+  module Categories
+    # Category dictionary
+    def categories
+      categories_url = nil
+      [ruhoh.to_url("categories"), ruhoh.to_url("categories.html")].each { |url|
+        categories_url = url and break if ruhoh.routes.find(url)
+      }
+      dict = {}
+      dictionary.each_value do |model|
+        Array(model.data['categories']).each do |cat|
+          cat = Array(cat).join('/')
+          if dict[cat]
+            dict[cat]['count'] += 1
+          else
+            dict[cat] = { 
+              'count' => 1, 
+              'name' => cat, 
+              resource_name => [],
+              'url' => "#{categories_url}##{cat}-ref"
+            }
+          end 
+
+          dict[cat][resource_name] << model.id
+        end
+      end  
+      dict["all"] = dict.each_value.map { |cat| cat }
+      dict
+    end
+          
+    # Convert single or Array of category ids (names) to category hash(es).
+    def to_categories(sub_context)
+      Array(sub_context).map { |id|
+        categories[id] 
+      }.compact
+    end
+  end
+end

data/lib/ruhoh/views/helpers/paginator.rb

@@ -0,0 +1,39 @@
+module Ruhoh::Views::Helpers
+  module Paginator
+    # current_page is set via a compiler or previewer
+    # in which it can discern what current_page to serve
+    def paginator
+      per_page = config["paginator"]["per_page"] rescue 5
+      current_page = master.page_data['current_page'].to_i
+      current_page = current_page.zero? ? 1 : current_page
+      offset = (current_page-1)*per_page
+
+      page_batch = all[offset, per_page]
+      raise "Page does not exist" unless page_batch
+      page_batch
+    end
+
+    def paginator_navigation
+      paginator_config = config["paginator"] || {}
+      page_count = all.length
+      total_pages = (page_count.to_f/paginator_config["per_page"]).ceil
+      current_page = master.page_data['current_page'].to_i
+      current_page = current_page.zero? ? 1 : current_page
+
+      pages = total_pages.times.map { |i| 
+        url = if i.zero? && paginator_config["root_page"]
+                paginator_config["root_page"]
+              else
+                "#{paginator_config["url"]}/#{i+1}"
+              end
+
+        {
+          "url" => ruhoh.to_url(url),
+          "name" => "#{i+1}",
+          "is_active_page" => (i+1 == current_page)
+        }
+      }
+      pages 
+    end
+  end
+end

data/lib/ruhoh/views/helpers/tags.rb

@@ -0,0 +1,37 @@
+module Ruhoh::Views::Helpers
+  module Tags
+    # Generate the tags dictionary
+    def tags
+      tags_url = nil
+      [ruhoh.to_url("tags"), ruhoh.to_url("tags.html")].each { |url|
+        tags_url = url and break if ruhoh.routes.find(url)
+      }
+      dict = {}
+      dictionary.each_value do |model|
+        Array(model.data['tags']).each do |tag|
+          if dict[tag]
+            dict[tag]['count'] += 1
+          else
+            dict[tag] = { 
+              'count' => 1, 
+              'name' => tag,
+              resource_name => [],
+              'url' => "#{tags_url}##{tag}-ref"
+            }
+          end 
+
+          dict[tag][resource_name] << model.id
+        end
+      end  
+      dict["all"] = dict.each_value.map { |tag| tag }
+      dict
+    end
+    
+    # Convert single or Array of tag ids (names) to tag hash(es).
+    def to_tags(sub_context)
+      Array(sub_context).map { |id|
+        tags[id] 
+      }.compact
+    end
+  end
+end

data/lib/ruhoh/views/master_view.rb

@@ -0,0 +1,183 @@
+require 'ruhoh/views/rmustache'
+
+module Ruhoh::Views
+  module Helpers ; end
+  class MasterView < RMustache
+    attr_reader :sub_layout, :master_layout
+    attr_accessor :page_data
+    
+    def initialize(ruhoh, pointer_or_data)
+      @ruhoh = ruhoh
+      define_resource_collection_namespaces(ruhoh)
+
+      if pointer_or_data['id']
+        @pointer = pointer_or_data
+        @page = collection.find(pointer_or_data)
+        unless @page
+          raise "Could not find the page with pointer: #{ pointer_or_data }" +
+            "Finding this page is required because an 'id' key is being passed."
+        end
+
+        @page_data = @page.data.dup # legacy...working on removing this..
+      else
+        @content = pointer_or_data['content']
+        @page_data = pointer_or_data
+        @pointer = pointer_or_data
+      end
+    end
+
+    def render_full
+      process_layouts
+      render(expand_layouts)
+    end
+
+    def render_content
+      render('{{{page.content}}}')
+    end
+
+    # Delegate #page to the kind of resource this view is modeling.
+    def page
+      collection ? collection.find(@pointer) : nil
+    end
+
+    def collection
+      @pointer["resource"] ? __send__(@pointer["resource"]) : nil
+    end
+
+    def urls
+      @ruhoh.collections.url_endpoints
+    end
+
+    def content
+      render(@content || page.content)
+    end
+
+    # NOTE: newline ensures proper markdown rendering.
+    def partial(name)
+      partial = partials.find(name.to_s)
+      partial ?
+        partial.process.to_s + "\n" :
+        Ruhoh::Friend.say { yellow "partial not found: '#{name}'" } 
+    end
+
+    def page_collections
+      @ruhoh.collections.acting_as_pages.map do |a|
+        @ruhoh.collection(a)
+      end
+    end
+
+    def to_json(sub_context)
+      sub_context.to_json
+    end
+  
+    def to_pretty_json(sub_context)
+      JSON.pretty_generate(sub_context)
+    end
+    
+    def debug(sub_context)
+      Ruhoh::Friend.say { 
+        yellow "?debug:"
+        magenta sub_context.class
+        cyan sub_context.inspect
+      }
+
+      "<pre>#{sub_context.class}\n#{sub_context.pretty_inspect}</pre>"
+    end
+
+    def raw_code(sub_context)
+      code = sub_context.gsub('{', '&#123;').gsub('}', '&#125;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('_', "&#95;")
+      "<pre><code>#{code}</code></pre>\n"
+    end
+    
+    # My Post Title ===> my-post-title
+    # Handy for transforming ids into css-classes in your views.
+    # @returns[String]
+    def to_slug(sub_context)
+      Ruhoh::Utils.to_slug(sub_context)
+    end
+    
+    # Public: Formats the path to the compiled file based on the URL.
+    #
+    # Returns: [String] The relative path to the compiled file for this page.
+    def compiled_path
+      path = CGI.unescape(@page_data['url']).gsub(/^\//, '') #strip leading slash.
+      path = "index.html" if path.empty?
+      path += '/index.html' unless path =~ /\.\w+$/
+      path
+    end
+
+    protected
+
+    def process_layouts
+      if @page_data['layout']
+        @sub_layout = layouts.find(@page_data['layout'], :all => true)
+        raise "Layout does not exist: #{@page_data['layout']}" unless @sub_layout
+      elsif @page_data['layout'] != false
+        # try default
+        @sub_layout = layouts.find(@pointer["resource"], :all => true)
+      end
+
+      if @sub_layout && @sub_layout.layout
+        @master_layout = layouts.find(@sub_layout.layout)
+        raise "Layout does not exist: #{ @sub_layout.layout }" unless @master_layout
+      end
+    end
+
+    # Expand the layout(s).
+    # Pages may have a single master_layout, a master_layout + sub_layout, or no layout.
+    def expand_layouts
+      if @sub_layout
+        layout = @sub_layout.content
+
+        # If a master_layout is found we need to process the sub_layout
+        # into the master_layout using mustache.
+        if @master_layout && @master_layout.content
+          layout = render(@master_layout.content, {"content" => layout})
+        end
+      else
+        # Minimum layout if no layout defined.
+        layout = page ? '{{{ page.content }}}' : '{{{ content }}}'
+      end
+
+      layout
+    end
+
+    private
+
+    # Dynamically add method proxies to resource collections
+    # This is how collections are accessed throughout mustache's global context.
+    # Also support calling ?to_<resource> contextual block helpers
+    def define_resource_collection_namespaces(ruhoh)
+      ruhoh.collections.all.each do |method_name|
+        (class << self; self; end).class_eval do
+          define_method(method_name) do
+            load_collection_view_for(method_name.to_s)
+          end
+
+          define_method("to_#{method_name}") do |*args|
+            resource_generator_for(method_name, *args)
+          end
+        end
+      end
+    end
+
+    # Load collection views dynamically when calling a resources name.
+    # Uses method_missing to catch calls to resource namespace.
+    # @returns[CollectionView] for the calling resource.
+    def load_collection_view_for(resource)
+      view = @ruhoh.collection(resource)
+      view.master = self
+      view
+    end
+
+    # Transforms an Array or String of resource ids into their corresponding resource objects.
+    # Uses method_missing to catch calls to 'to_<resource>` contextual helper.
+    # @returns[Array] the resource modelView objects or raw data hash.
+    def resource_generator_for(resource, sub_context)
+      collection_view = load_collection_view_for(resource)
+      Array(sub_context).map { |id|
+        collection_view.find(id)
+      }.compact
+    end
+  end
+end