ruhoh 1.1 → 2.1

data/lib/ruhoh/resources/pages/collection_view.rb

@@ -0,0 +1,73 @@
+require 'ruhoh/views/helpers/categories'
+require 'ruhoh/views/helpers/tags'
+require 'ruhoh/views/helpers/paginator'
+module Ruhoh::Resources::Pages
+
+  class CollectionView < SimpleDelegator
+    include Ruhoh::Views::Helpers::Tags
+    include Ruhoh::Views::Helpers::Categories
+    include Ruhoh::Views::Helpers::Paginator
+
+    def all
+      dictionary.each_value.find_all { |model|
+        File.basename(File.dirname(model.id)) != "drafts"
+      }.sort
+    end
+
+    def drafts
+      dictionary.each_value.find_all { |model|
+        File.basename(File.dirname(model.id)) == "drafts"
+      }.sort
+    end
+
+    def latest
+      latest = config['latest']
+      latest ||= 10
+      (latest.to_i > 0) ? all[0, latest.to_i] : all
+    end
+
+    # Internal: Create a collated pages data structure.
+    #
+    # pages - Required [Array] 
+    #  Must be sorted chronologically beforehand.
+    #
+    # @returns[Array] collated pages:
+    # [{ 'year': year, 
+    #   'months' : [{ 'month' : month, 
+    #     'pages': [{}, {}, ..] }, ..] }, ..]
+    def collated
+      collated = []
+      pages = all
+      pages.each_with_index do |page, i|
+        thisYear = Time.parse(page['date']).strftime('%Y')
+        thisMonth = Time.parse(page['date']).strftime('%B')
+        if (i-1 >= 0)
+          prevYear = Time.parse(pages[i-1]['date']).strftime('%Y')
+          prevMonth = Time.parse(pages[i-1]['date']).strftime('%B')
+        end
+
+        if(prevYear == thisYear) 
+          if(prevMonth == thisMonth)
+            collated.last['months'].last[resource_name] << page['id'] # append to last year & month
+          else
+            collated.last['months'] << {
+                'month' => thisMonth,
+                resource_name => [page['id']]
+              } # create new month
+          end
+        else
+          collated << { 
+            'year' => thisYear,
+            'months' => [{ 
+              'month' => thisMonth,
+              resource_name => [page['id']]
+            }]
+          } # create new year & month
+        end
+
+      end
+
+      collated
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'nokogiri'
+module Ruhoh::Resources::Pages
+  class Compiler
+    include Ruhoh::Base::Compilable
+
+    def run
+      pages = @collection.all
+      resource_name = @collection.resource_name
+      Ruhoh::Friend.say { cyan "#{resource_name.capitalize}: (#{pages.count} #{resource_name})" }
+      
+      FileUtils.cd(@ruhoh.paths.compiled) {
+        pages.each do |data|
+          view = @ruhoh.master_view(data['pointer'])
+
+          FileUtils.mkdir_p File.dirname(view.compiled_path)
+          File.open(view.compiled_path, 'w:UTF-8') { |p| p.puts view.render_full }
+
+          Ruhoh::Friend.say { green "  > #{data['id']}" }
+        end
+      }
+
+      pagination
+      rss
+    end
+
+    def pagination
+      config = @collection.config["paginator"] || {}
+      resource_name = @collection.resource_name
+      if config["enable"] == false
+        Ruhoh::Friend.say { yellow "#{resource_name} paginator: disabled - skipping." }
+        return
+      end
+
+      pages_count = @collection.all.length
+      total_pages = (pages_count.to_f/config["per_page"]).ceil
+
+      Ruhoh::Friend.say { cyan "#{resource_name} paginator: (#{total_pages} pages)" }
+      
+      FileUtils.cd(@ruhoh.paths.compiled) {
+        total_pages.times.map { |i| 
+          # if a root page is defined we assume it's getting compiled elsewhere.
+          next if (i.zero? && config["root_page"])
+
+          url = "#{config["url"]}/#{i+1}"
+          view = @ruhoh.master_view({"resource" => resource_name})
+          view.page_data = {
+            "layout" => config["layout"],
+            "current_page" => (i+1),
+            "url" => @ruhoh.to_url(url)
+          }
+          FileUtils.mkdir_p File.dirname(view.compiled_path)
+          File.open(view.compiled_path, 'w:UTF-8') { |p| p.puts view.render_full }
+          Ruhoh::Friend.say { green "  > #{view.page_data['url']}" }
+        }
+      }
+    end
+
+    def rss
+      config = @collection.config["rss"] || {}
+      resource_name = @collection.resource_name
+      if config["enable"] == false
+        Ruhoh::Friend.say { yellow "#{resource_name} RSS: disabled - skipping." }
+        return
+      end
+
+      limit = config["limit"] || 20
+      pages = @collection.all.first(limit)
+      Ruhoh::Friend.say { cyan "#{resource_name} RSS: (first #{limit} pages)" }
+      data = @ruhoh.collection("data").dictionary
+
+      feed = Nokogiri::XML::Builder.new do |xml|
+       xml.rss(:version => '2.0') {
+         xml.channel {
+           xml.title_ data['title']
+           xml.link_ @ruhoh.config['production_url']
+           xml.pubDate_ Time.now          
+           pages.each do |page|
+             view = @ruhoh.master_view(page.pointer)
+             xml.item {
+               xml.title_ page.title
+               xml.link "#{@ruhoh.config['production_url']}#{page.url}"
+               xml.pubDate_ page.date if page.date
+               xml.description_ (page.try(:description) ? page.description : view.render_content)
+             }
+           end
+         }
+       }
+      end
+
+      FileUtils.cd(@ruhoh.paths.compiled) {
+        compiled_path = CGI.unescape(@ruhoh.to_url(config['url'], "rss.xml"))
+        compiled_path = compiled_path.gsub(/^\//, '')
+
+        FileUtils.mkdir_p File.dirname(compiled_path)
+        File.open(compiled_path, 'w'){ |p| p.puts feed.to_xml }
+
+        Ruhoh::Friend.say { green "  > #{compiled_path}" }
+      }
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Ruhoh::Resources::Pages
+  class Model
+    include Ruhoh::Base::PageLike
+  end
+end

data/lib/ruhoh/resources/pages/model_view.rb

@@ -0,0 +1,5 @@
+module Ruhoh::Resources::Pages
+  class ModelView < SimpleDelegator
+    include Ruhoh::Base::PageViewable
+  end
+end

data/lib/ruhoh/resources/pages/previewer.rb

@@ -0,0 +1,72 @@
+# Public: Rack application used to render singular pages via their URL.
+module Ruhoh::Resources::Pages
+  class Previewer
+
+    def initialize(ruhoh)
+      @ruhoh = ruhoh
+    end
+
+    def call(env)
+      return favicon if env['PATH_INFO'] == '/favicon.ico'
+
+      # Always remove trailing slash if sent unless it's the root page.
+      env['PATH_INFO'].chomp!("/") unless env['PATH_INFO'] == "/"
+
+      pointer = @ruhoh.routes.find(env['PATH_INFO'])
+      view = pointer ? @ruhoh.master_view(pointer) : paginator_view(env)
+      if view
+        content = view.render_full
+        Ruhoh::Friend.say {
+          cyan "-> previewing page:"
+          plain "   - #{pointer.inspect}"
+          plain "   - sub-layout: #{ view.sub_layout }"
+          plain "   - master-layout: #{ view.master_layout }"
+          plain "   - meta-data: #{ view.page_data }"
+        }
+        [200, {'Content-Type' => 'text/html'}, [content]]
+      else
+        message = "No generated page URL matches '#{ env['PATH_INFO'] }'" +
+          " using file pointer: '#{ pointer.inspect }'."
+
+        if pointer.nil?
+          message += " Since the file pointer was nil" +
+            " we tried to load a pagination view but it didn't work;" +
+            "\n Expected the format to be: '<valid_resource_name>/page_number'"
+        end
+
+        raise message
+      end
+    end
+
+    # Try the paginator.
+    # search for the namespace and match it to a resource:
+    # need a way to register pagination namespaces then search the register. 
+    def paginator_view(env)
+      path = env['PATH_INFO'].reverse.chomp("/").reverse
+      resource = @ruhoh.collections.paginator_urls.find do |a, b|
+        "/#{ path }" =~ %r{^#{ b }}
+      end
+      resource = resource[0] if resource
+      return false unless resource
+
+      page_number = path.match(/([1-9]+)$/)[0] rescue nil
+
+      return false unless @ruhoh.collections.exist?(resource)
+      return false if page_number.to_i.zero?
+
+      collection = @ruhoh.collection(resource)
+      config = collection.config["paginator"] || {}
+
+      view = @ruhoh.master_view({"resource" => resource})
+      view.page_data = {
+        "layout" => config["layout"],
+        "current_page" => page_number
+      }
+      view
+    end
+
+    def favicon
+      [200, {'Content-Type' => 'image/x-icon'}, ['']]
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Ruhoh::Resources::Partials
+  class Model
+    include Ruhoh::Base::Modelable
+
+    def process
+      return File.open(@pointer['realpath'], 'r:UTF-8') { |f| 
+        return f.read
+      }
+    end
+  end
+end

data/lib/ruhoh/resources/stylesheets/collection.rb

@@ -0,0 +1,9 @@
+module Ruhoh::Resources::Stylesheets
+  class Collection
+    include Ruhoh::Base::Collectable
+
+    def url_endpoint
+      "assets/#{ resource_name }"
+    end
+  end
+end

data/lib/ruhoh/resources/stylesheets/collection_view.rb

@@ -0,0 +1,45 @@
+module Ruhoh::Resources::Stylesheets
+  class CollectionView < SimpleDelegator
+    attr_accessor :_cache
+
+    def initialize(collection)
+      super(collection)
+      @_cache = {}
+    end
+    
+    # Load Stylesheets as defined within the given sub_context
+    #
+    # Example:
+    #   {{# stylesheets.load }}
+    #     global.css
+    #     custom.css
+    #   {{/ stylesheets.load }}
+    #   (stylesheets are separated by newlines)
+    #
+    # This is a convenience method that will automatically create link tags
+    # with respect to ruhoh's internal URL generation mechanism; e.g. base_path
+    #
+    # @returns[String] HTML link tags for given stylesheets
+    def load(sub_context)
+      stylesheets = sub_context.split("\n").map{ |s| s.gsub(/\s/, '') }.delete_if(&:empty?)
+      stylesheets.map { |name|
+        "<link href='#{make_url(name)}' type='text/css' rel='stylesheet' media='all'>"
+      }.join("\n")
+    end
+
+    protected
+
+    def make_url(name)
+      return name if name =~ /^(http:|https:)?\/\//i
+
+      path = if @_cache[name]
+        @_cache[name]
+      else
+        @_cache[name] = name
+        "#{name}?#{rand()}"
+      end
+
+      ruhoh.to_url(url_endpoint, path)
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Ruhoh::Resources::Stylesheets
+  class Compiler
+    include Ruhoh::Base::CompilableAsset
+  end
+end

data/lib/ruhoh/resources/theme/collection.rb

@@ -0,0 +1,14 @@
+module Ruhoh::Resources::Theme
+  class Collection
+    include Ruhoh::Base::Collectable
+
+    def url_endpoint
+      "/assets"
+    end
+
+    # noop
+    def dictionary
+      {}
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Ruhoh::Resources::Theme
+  class Compiler
+    include Ruhoh::Base::Compilable
+
+    def run
+      copy
+    end
+
+    # Copies all assets over to the compiled site.
+    # Note the compiled assets are namespaced at /assets/
+    def copy
+      collection = @collection
+      unless @collection.paths?
+        Ruhoh::Friend.say { yellow "#{collection.resource_name.capitalize}: directory not found - skipping." }
+        return
+      end
+
+      Ruhoh::Friend.say { cyan "Theme: ('#{collection.resource_name}' copying non-resource files)" }
+
+      theme = Ruhoh::Utils.url_to_path(@collection.url_endpoint, @ruhoh.paths.compiled)
+      FileUtils.mkdir_p theme
+
+      self.files.each do |file|
+        original_file = File.join(@ruhoh.paths.theme, file)
+        compiled_file = File.join(theme, file)
+        FileUtils.mkdir_p File.dirname(compiled_file)
+        FileUtils.cp_r original_file, compiled_file
+        Ruhoh::Friend.say { green "  > #{file}" }
+      end
+    end
+
+    # Returns list of all files from the theme to be compiled.
+    # @returns[Array] relative filepaths
+    def files
+      FileUtils.cd(@ruhoh.paths.theme) {
+        return Dir["**/*"].select { |filepath|
+          is_valid_asset?(filepath)
+        }
+      }
+    end
+
+    # Checks a given asset filepath against any user-defined exclusion rules in theme.yml
+    # Omit layouts, stylesheets, javascripts, media as they are handled by their respective resources.
+    # @returns[Boolean]
+    def is_valid_asset?(filepath)
+      return false unless File.exist? filepath
+      return false if FileTest.directory?(filepath)
+      return false if filepath.start_with?('.', 'layouts', 'stylesheets', 'javascripts', 'media')
+      excludes = Array(@collection.config['exclude']).map { |node| Regexp.new(node) }
+      excludes.each { |regex| return false if filepath =~ regex }
+      true
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Ruhoh::Resources::Widgets
+  class Collection
+    include Ruhoh::Base::Collectable
+
+    def initialize(ruhoh)
+      @ruhoh = ruhoh
+      @path = File.join(@ruhoh.paths.base, "widgets")
+      @system_path = File.join(@ruhoh.paths.system, "widgets")
+    end
+
+    def url_endpoint
+      "/assets/widgets"
+    end
+
+    # @returns[Array] registered widget names.
+    def widgets
+      names = []
+      paths.each do |path|
+        FileUtils.cd(path) {
+          names += Dir["*"]
+        }
+      end
+      names.uniq
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Ruhoh::Resources::Widgets
+  class CollectionView < SimpleDelegator
+
+    def widget(name)
+      page_config = (master.page_data["widgets"][name] || {}) rescue {}
+      widget_config = (config[name] || {}).merge(page_config)
+      return '' if widget_config['enable'].to_s == 'false'
+
+      model = find("#{ name }/#{ (widget_config['use'] || "default") }")
+      return '' unless model
+
+      view = ruhoh.master_view({})
+
+      # merge the config.yml data into the inline layout data.
+      # Note this is reversing the normal hierarchy 
+      # in that inline should always override config level.
+      # However the inline in this case is set as implementation defaults 
+      # and meant to be overridden by user specific data.
+      view.render(model.content, {
+        "this_config" => model.data.merge(widget_config),
+        "this_path" => ruhoh.to_url(url_endpoint, name)
+      })
+    end
+
+    def method_missing(name, *args, &block)
+      __getobj__.widgets.include?(name.to_s) ? widget(name.to_s) : super
+    end
+
+    def respond_to?(method)
+      __getobj__.widgets.include?(method.to_s) ? true : super
+    end
+
+  end
+end