ruhoh 1.1 → 2.1

data/lib/ruhoh/programs/watch.rb

@@ -0,0 +1,45 @@
+require 'directory_watcher'
+
+class Ruhoh
+  module Program
+
+    # Internal: Watch website source directory for file changes.
+    # The observer triggers data regeneration as files change
+    # in order to keep the data up to date in real time.
+    def self.watch(ruhoh)
+      ruhoh.ensure_setup
+
+      Ruhoh::Friend.say {
+        cyan "=> Start watching: #{ruhoh.paths.base}"
+      }
+      dw = DirectoryWatcher.new(ruhoh.paths.base, {
+        :glob => "**/*", 
+        :pre_load => true
+      })
+      dw.interval = 1
+      dw.add_observer do |*args| 
+        args.each do |event|
+          ruhoh.cache.delete(event['path'])
+
+          path = event['path'].gsub(ruhoh.paths.base + '/', '')
+
+          Ruhoh::Friend.say {
+            yellow "Watch [#{Time.now.strftime("%H:%M:%S")}] [Update #{path}] : #{args.size} files changed"
+          }
+
+          separator = File::ALT_SEPARATOR ?
+                      %r{#{ File::SEPARATOR }|#{ File::ALT_SEPARATOR }} :
+                      File::SEPARATOR
+          resource = path.split(separator)[0]
+
+          ruhoh.cache.delete(ruhoh.collection(resource).files_cache_key)
+
+          ruhoh.collection(resource).load_watcher.update(path)
+        end
+      end
+
+      dw.start
+    end
+
+  end
+end

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

@@ -0,0 +1,10 @@
+module Ruhoh::Resources::Dash
+  class Collection
+    include Ruhoh::Base::Collectable
+
+    def url_endpoint
+      "/dash"
+    end
+  
+  end  
+end

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

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

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

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

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

@@ -0,0 +1,13 @@
+module Ruhoh::Resources::Dash
+  class Previewer
+    def initialize(ruhoh)
+      @ruhoh = ruhoh
+    end
+
+    def call(env)
+      pointer = @ruhoh.collection("dash").find_file('index')
+      view = @ruhoh.master_view(pointer)
+      [200, {'Content-Type' => 'text/html'}, [view.render_full]]
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Ruhoh::Resources::Data
+  class Collection
+    include Ruhoh::Base::Collectable
+
+    def dictionary
+      Ruhoh::Utils.parse_yaml_file(@ruhoh.paths.base, "#{resource_name}.yml") || {}
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Ruhoh::Resources::Data
+  class CollectionView < SimpleDelegator
+
+    def initialize(collection)
+      super(collection)
+
+      # Define direct access to the dictionary Hash object
+      # but don't overwrite methods if already defined.
+      dictionary.keys.each do |method|
+        (class << self; self; end).class_eval do
+          next if method_defined?(method)
+          define_method method do |*args, &block|
+            dictionary[method]
+          end
+        end
+      end
+    end
+
+    def [](attribute)
+      __send__(attribute)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,46 @@
+module Ruhoh::Resources::Javascripts
+  class CollectionView < SimpleDelegator
+    attr_accessor :_cache
+
+    def initialize(collection)
+      super(collection)
+      @_cache = {}
+    end
+
+    # Load javascripts as defined within the given sub_context
+    #
+    # Example:
+    #   {{# javascripts.load }}
+    #     app.js
+    #     scroll.js
+    #   {{/ javascripts.load }}
+    #   (scripts are separated by newlines)
+    #
+    # This is a convenience method that will automatically create script tags
+    # with respect to ruhoh's internal URL generation mechanism; e.g. base_path.
+    #
+    # @returns[String] HTML script tags for given javascripts.
+    def load(sub_context)
+      javascripts = sub_context.split("\n").map{ |s| s.gsub(/\s/, '') }.delete_if(&:empty?)
+      javascripts.map { |name|
+        "<script src='#{make_url(name)}'></script>"
+      }.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/javascripts/compiler.rb

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

data/lib/ruhoh/resources/layouts/client.rb

@@ -0,0 +1,45 @@
+module Ruhoh::Resources::Layouts
+  class Client
+    Help = [
+      {
+        "command" => "new <name>",
+        "desc" => "Create a new layout for the currently active theme."
+      }
+    ]      
+
+    def initialize(collection, data)
+      @ruhoh = collection.ruhoh
+      @collection = collection
+      @args = data[:args]
+      @options = data[:options]
+    end
+    
+    # Public: Create a new layout file for the active theme.
+    def new
+      ruhoh = @ruhoh
+      name = @args[2]
+      Ruhoh::Friend.say { 
+        red "Please specify a layout name." 
+        cyan "ex: ruhoh layouts new splash"
+        exit
+      } if name.nil?
+
+      filename = File.join((@ruhoh.paths.theme || @ruhoh.paths.base), "layouts", name.gsub(/\s/, '-').downcase) + ".html"
+
+      if File.exist?(filename)
+        abort("Create new layout: aborted!") if ask("#{filename} already exists. Do you want to overwrite?", ['y', 'n']) == 'n'
+      end
+
+      FileUtils.mkdir_p File.dirname(filename)
+
+      File.open(filename, 'w:UTF-8') do |page|
+        page.puts (@collection.scaffold || '')
+      end
+
+      Ruhoh::Friend.say {
+        green "New layout:"
+        plain ruhoh.relative_path(filename)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Ruhoh::Resources::Layouts
+  class Model
+    include Ruhoh::Base::PageLike
+
+    def process
+      parsed_page = parse_page_file
+      # This ensures the call to @sub_layout.layout does not error.
+      parsed_page['data']['layout'] ||= nil
+
+      changed
+      notify_observers(parsed_page)
+
+      parsed_page
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Ruhoh::Resources::Media
+  class Collection
+    include Ruhoh::Base::Collectable
+
+    def url_endpoint
+      "/assets/media"
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Ruhoh::Resources::Media
+  class Compiler
+    include Ruhoh::Base::Compilable
+
+    #  TODO: Use the asset compiler.
+    # We can't use it now because there is automatic digest support
+    # but currently no way to dynamically update all media links in views with digest path.
+    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
+      
+      @collection.files.values.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/pages/client.rb

@@ -0,0 +1,124 @@
+module Ruhoh::Resources::Pages
+  class Client
+    Help = [
+      {
+        "command" => "draft <title>",
+        "desc" => "Create a new draft. Title is optional.",
+      },
+      {
+        "command" => "new <title>",
+        "desc" => "Create a new resource. Title is optional.",
+      },
+      {
+        "command" => "titleize",
+        "desc" => "Update draft filenames to their corresponding titles. Drafts without titles are ignored.",
+      },
+      {
+        "command" => "drafts",
+        "desc" => "List all drafts.",
+      },
+      {
+        "command" => "list",
+        "desc" => "List all resources.",
+      }
+    ]
+
+    def initialize(collection, data)
+      @ruhoh = collection.ruhoh
+      @collection = collection
+      @args = data[:args]
+      @options = data[:options]
+      @iterator = 0
+    end
+
+    def draft
+      create(draft: true)
+    end
+
+    def new
+      create
+    end
+
+    # Public: Update draft filenames to their corresponding titles.
+    def titleize
+      @collection.dictionary.each do |id, data|
+        next unless File.basename(data['id']) =~ /^untitled/
+        new_name = Ruhoh::Utils.to_slug(data['title'])
+        new_file = "#{new_name}#{File.extname(data['id'])}"
+        old_file = File.basename(data['id'])
+        next if old_file == new_file
+
+        FileUtils.cd(File.dirname(data['pointer']['realpath'])) {
+          FileUtils.mv(old_file, new_file)
+        }
+        Ruhoh::Friend.say { green "Renamed #{old_file} to: #{new_file}" }
+      end
+    end
+
+    def drafts
+      _list(@collection.drafts)
+    end
+
+    def list
+      _list(@collection.all)
+    end
+
+    protected
+
+    def create(opts={})
+      ruhoh = @ruhoh
+
+      begin
+        file = @args[2] || "untitled"
+        ext = File.extname(file).to_s
+        ext  = ext.empty? ? @collection.config["ext"] : ext
+
+        # filepath vs title
+        name =  if file.include?('/')
+                  name = File.basename(file, ext).gsub(/\s+/, '-')
+                  File.join(File.dirname(file), name)
+                else
+                  Ruhoh::Utils.to_slug(File.basename(file, ext))
+                end
+
+        name = "#{name}-#{@iterator}" unless @iterator.zero?
+        filename = opts[:draft] ?
+          File.join(@ruhoh.paths.base, @collection.resource_name, "drafts", "#{name}#{ext}") :
+          File.join(@ruhoh.paths.base, @collection.resource_name, "#{name}#{ext}")
+        @iterator += 1
+      end while File.exist?(filename)
+
+      FileUtils.mkdir_p File.dirname(filename)
+      output = (@collection.scaffold || '').gsub('{{DATE}}', Time.now.strftime('%Y-%m-%d'))
+
+      File.open(filename, 'w:UTF-8') {|f| f.puts output }
+
+      resource_name = @collection.resource_name
+      Ruhoh::Friend.say { 
+        green "New #{resource_name}:"
+        green "  > #{ruhoh.relative_path(filename)}"
+        if opts[:draft]
+          plain "View drafts at the URL: /dash"
+        end
+      }
+    end
+
+    def _list(data)
+      if @options.verbose
+        Ruhoh::Friend.say {
+          data.each_value do |p|
+            cyan("- #{p['id']}")
+            plain("  title: #{p['title']}") 
+            plain("  url: #{p['url']}")
+          end
+        }
+      else
+        Ruhoh::Friend.say {
+          data.each do |p|
+            cyan("- #{p['id']}")
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Ruhoh::Resources::Pages
+  module 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
+
+  class Collection
+    include Ruhoh::Base::Collectable
+    include Routable
+
+    # model observer callback.
+    def update(model_data)
+      routes_add(model_data['data']['url'], model_data['data']['pointer'])
+      @ruhoh.cache.set(model_data['data']['pointer']['realpath'], model_data)
+    end
+
+    # Easy way to regenerate a model
+    # Used in the file watcher implementation.
+    def touch(name_or_pointer)
+      pointer = find_file(name_or_pointer)
+      routes_delete(pointer)
+      find(name_or_pointer) # find/load so the route is regenerated
+    end
+
+    def config
+      hash = super
+      hash['permalink'] ||= "/:path/:filename"
+      hash['summary_lines'] ||= 20
+      hash['summary_lines'] = hash['summary_lines'].to_i
+      hash['latest'] ||= 2
+      hash['latest'] = hash['latest'].to_i
+      hash['ext'] ||= ".md"
+
+      rss = hash['rss'] || {}
+      rss['limit'] ||= 20
+      rss['limit'] = rss['limit'].to_i
+      rss["url"] ||=  "/#{ resource_name }"
+      rss["url"] = rss["url"].to_s
+      rss["url"] = "/#{ rss["url"] }" unless rss["url"].start_with?('/')
+      rss["url"] = rss["url"].chomp('/') unless rss["url"] == '/'
+      hash['rss'] = rss
+
+      paginator = hash['paginator'] || {}
+      paginator["url"] ||=  "/#{ resource_name }/index"
+      paginator["url"] = paginator["url"].to_s
+      unless paginator["url"].start_with?('/')
+        paginator["url"] = "/#{paginator["url"]}"
+      end
+      unless paginator["url"] == '/'
+        paginator["url"] = paginator["url"].chomp('/') 
+      end
+
+      paginator["per_page"] ||=  5
+      paginator["per_page"] = paginator["per_page"].to_i
+      paginator["layout"] ||=  "paginator"
+
+      if paginator["root_page"]
+        unless paginator["root_page"].start_with?('/')
+          paginator["root_page"] = "/#{paginator["root_page"]}"
+        end
+        unless paginator["root_page"] == '/'
+          paginator["root_page"] = paginator["root_page"].chomp('/')
+        end
+      end
+
+      hash['paginator'] = paginator
+
+      hash
+    end
+  end
+end