PlainSite 1.2.0

data/lib/PlainSite/Data/PostList.rb

@@ -0,0 +1,164 @@
+#coding:utf-8
+module PlainSite;end
+module PlainSite::Data
+  require 'PlainSite/Data/Post'
+  require 'PlainSite/Data/PostListPage'
+  class PostList
+    include Enumerable
+    # PostList,default sort by date desc and by name asc
+    # posts - The Post[]|String[] of posts or posts file path(abs or relative to site.data_path) array
+    # site - The Site
+    def initialize(posts,site)
+      if String===posts[0]
+        @posts=posts.map {|f| Post.new f,site }
+      else
+        @posts=posts.map &:dup
+      end
+      @posts.sort! do |a,b|
+        # sort by date desc and by name asc
+        [b.date,a.slug] <=> [a.date,b.slug]
+      end
+      @site=site
+      @custom_index= @posts.any? &:is_index
+    end
+
+    # Array like slice method
+    # Return the Post or slice PostList
+    def [](*args)
+      if args.length==1
+        i=args[0]
+        if Range===i
+          posts=@posts[i]
+          return nil if posts.nil? || posts.empty?
+          PostList.new posts,@site
+        else
+          post=@posts[i]
+          if post
+            post.next_post= i-1 < 0 ? nil : @posts[i-1] # Because -1 will index from last
+            post.prev_post= @posts[i+1]
+          end
+          post
+        end
+      else
+        start,len=args
+        posts=@posts[start,len]
+        return nil if posts.nil? || posts.empty?
+        PostList.new posts,@site
+      end
+    end
+    alias :slice :[]
+
+    # Paginate post list
+    # This is a smart paginater. Version Control System friendly!
+    # What's VCS friendly? It's page nums use a revert order.
+    # The old the page's date is,the smaller the page's num is.
+    # Options:
+    #   page_size - The Integer page size number,must be more than zero,default is 10
+    #   revert_nos - The Boolean value to control if use revert order page num,default is true
+    # Return: The PostListPage[]
+    def paginate(opts={})
+      revert_nos=opts[:revert_nos].nil? ? true : opts[:revert_nos]
+      page_size=opts[:page_size] || 10
+      total=@posts.length
+      return [] if total==0
+
+      # In revert nos case,the first page need padding to fit full page
+      if revert_nos && total>page_size
+        start=total % page_size
+        pages=[self.slice(0,page_size)]
+      else
+        start=0
+        pages=[]
+      end
+
+      while posts=self.slice(start,page_size)
+        pages.push posts
+        start+=page_size
+      end
+
+      nos_list=(1..pages.length).to_a
+      display_nums=nos_list.dup
+      slugs=('a'..'zzz').take pages.length # Use letters id instead of numbers
+
+      if revert_nos
+        nos_list.reverse!
+        slugs.reverse!
+      end
+      slugs[0]='index' unless @custom_index # Category has its custom index post
+
+      total_pages_count=pages.length
+      pages= pages.zip(nos_list,display_nums,slugs).map do |a|
+        posts,num,display_num,slug=a
+        PostListPage.new(
+          # num: num,  # It's useles
+          slug: slug, display_num: display_num,
+          posts: posts, site: @site,
+          total_pages_count: total_pages_count,
+          total_posts_count: total,
+          page_size: page_size,
+          revert_nos: revert_nos
+        )
+      end
+
+      next_pages=[nil]+pages[0..-2]
+      prev_pages=(pages[1..-1] or [])+[nil]
+      pages.zip(prev_pages,next_pages) do |a|
+        page,prev_page,next_page=a
+        page.prev_page=prev_page
+        page.next_page=next_page
+        page.all_pages=pages
+      end
+
+      pages
+    end
+
+    # Install B
+    # `posts / 5`  is same as `posts.paginate(page_size:5)`
+    def /(page_size)
+      paginate(page_size:page_size)
+    end
+
+    def +(other)
+      raise TypeError,"Except #{PostList} Type" unless PostList===other
+      PostList.new @posts+other.to_a
+    end
+
+    # Check if contains one post
+    # p - The Post object or the String path or relpath or data_id of post
+    def include?(p)
+      if Post===p
+        return @posts.include? p
+      end
+      return @posts.any? {|post| post.path==p || post.relpath==p || post.data_id==p}
+    end
+
+    def length
+      @posts.length
+    end
+
+    def empty?
+      length==0
+    end
+
+    def each(&block)
+      block_given? or return enum_for __method__
+      0.upto @posts.length-1 do |i|
+        yield self[i]
+      end
+    end
+
+    def to_a
+      @posts.dup
+    end
+    alias :to_ary :to_a
+
+    %w(drop drop_while find_all select reject sort sort_by take take_while).each do |method|
+      define_method(method) do |*args,&block|
+        ary=super *args,&block
+        if ary
+          PostList.new ary.to_a,@site
+        end
+      end
+    end
+  end
+end

data/lib/PlainSite/Data/PostListPage.rb

@@ -0,0 +1,80 @@
+#coding:utf-8
+module PlainSite;end
+module PlainSite::Data
+  require 'ostruct'
+  # PostList Pagination
+  class PostListPage<OpenStruct
+    # These attributes' accessors are auto  generated by OpenStruct
+    # attr_reader(
+    #  :slug,:display_num,
+    #  :posts,:prev_page,:next_page,
+    #  :total_pages_count,:total_posts_count,:page_size,:all_pages,
+    #  :revert_nos,:site
+    # )
+    attr_accessor :prev_page,:next_page,:all_pages # set after create
+
+    # Options:
+    # slug - The String page name suggested to used in url,first page is 'index',others are 'a'...'zzz' string
+    # display_num - The Integer always be ascending,first page is 1,second page is 2
+    # posts - The PostList
+    # prev_page - The previous PostListPage
+    # next_page - The next PostListPage
+    # total_pages_count - The Integer of total count in this pagination
+    # total_posts_count - The Integer of total count in this pagination
+    # page_size - The Integer of preset page size
+    # revert_nos - The Boolean indicate if this post list page use revert nos.
+    #         When false case,it's html page must be regenerated every time.
+    # site - The Site belongs to
+    def initialize(opts)
+      super opts
+    end
+
+    # The String url of self
+    def url
+      site.url_for self
+    end
+
+    # See PostList#include?
+    def include?(a)
+      posts.include? a
+    end
+
+
+    # @deprecated
+
+    # Remove posts,resort all previous pages
+    # list - The String[] of post's path list
+    def remove(list)
+      posts=posts.select do |p|
+        list.include? p.path
+      end
+      try_pad_from_other_page
+    end
+
+
+    # Pop posts
+    # Return Post[]
+    def pop_multi(n)
+      ret=posts.slice(-n,n)
+      posts=posts.slice(0,-n-1)
+      ret
+    end
+
+    def try_pad_from_other_page
+      n=page_size-posts.length
+      return [] unless n>0
+      related_pages=[self]
+      if prev_page
+        posts=prev_page.posts.pop_multi(n)+posts
+        related_pages.concat prev_page.try_pad_from_other_page
+      elsif next_page
+        posts+=next_page.posts.take n
+      end
+      related_pages
+    end
+
+
+
+
+  end
+end

data/lib/PlainSite/RenderTask.rb

@@ -0,0 +1,235 @@
+#coding:utf-8
+
+module PlainSite
+  require 'fileutils'
+  require 'pathname'
+  require 'PlainSite/Data/PostList'
+  require 'PlainSite/Data/PostListPage'
+  require 'PlainSite/Data/Post'
+  require 'PlainSite/Tpl/LayErb'
+  require 'PlainSite/Utils'
+
+  class BadUrlPatternException<Exception;end
+  class RenderTask
+    Post=Data::Post
+    PostList=Data::PostList
+    PostListPage=Data::PostListPage
+    attr_reader :site
+    # site - The Site
+    def initialize(site)
+      @site=site
+      @tasks=[]
+    end
+
+    # Options:
+    # url_pattern - The String with var replacement pattern "{property.property}"
+    #       "{property.property}" is the data Hash key path.
+    #       Example:
+    #       "/article/{date.year}/{name}.html" will render url
+    #       "/article/2011/hello-world.html"
+    #           with post "posts/2011-09-09-hello-world.md"
+    # data - The Array|PostList|Object|String data to render
+    #    In String case,it represents the post.data_id or category.data_id.
+    #    Example: 'essay/*' same as $site.data['essay/*']
+    #    If `data` type is Array or PostList,it will render each item with template,
+    #    else only generate one page
+    # template - The String template path relative to '_site/templates'
+    # build_anyway - The Boolean value to indicate
+    #           this route rule will build anyway even if no post updates
+    def route(opts)
+      url_pattern=opts[:url_pattern]
+      items=opts[:data]
+      template=opts[:template]
+      build_anyway=opts[:build_anyway]
+
+      if String===items
+        items=@site.data[items]
+        raise Exception,"Data not found:#{opts[:data]}!" if items.nil?
+      end
+      items=[items] unless Data::PostList===items || Array===items
+
+      tasks= items.map do |item|
+        urlpath=RenderTask.sub_url url_pattern,item
+        urlpath[0]=''  if urlpath[0]=='/'
+        id =if item.respond_to? :data_id
+              item.data_id
+            else
+              item.object_id
+            end
+
+        { id: id, urlpath: urlpath, item: item,
+          template:File.join(@site.templates_path,template),
+          build_anyway:build_anyway }
+      end
+      @tasks.concat tasks
+    end
+
+    # Get the url for object
+    # obj - The Post|PageListPage|Category|String
+    # Return the String url prefix with site root url(site.url) or relative path if build --local
+    def url_for(obj)
+      obj[0]='' if String===obj && obj[0]=='/'
+
+      if String===obj && (File.exists? (File.join @site.assets_path,obj))
+        # static file path
+        urlpath=obj
+      else
+        urlpath=object2url obj
+      end
+
+      if @site.local
+        urlpath=urlpath+'/index.html' if urlpath.end_with? '/'
+        urlpath='index.html'  if urlpath.empty?
+        p1=Pathname.new (File.dirname urlpath)
+        basename=File.basename urlpath
+        (p1.relative_path_from Pathname.new(@site._cur_page_dir)).to_s+'/'+basename
+      else
+        #URI.join @site.url,urlpath
+        '/' + urlpath
+      end
+    end
+
+    def object2url(obj)
+      id =if String===obj
+            obj
+          elsif obj.respond_to? :data_id
+            obj.data_id
+          else
+            obj.object_id
+          end
+      return (id2url_map[id] || id).to_s
+    end
+
+    # Return all valid output pages url path
+    def all_urlpath
+      return @all_urlpath  if @all_urlpath
+      @all_urlpath=@tasks.map do |t|
+        t[:urlpath]
+      end
+    end
+
+    # Render  pages
+    # partials - The Hash of new or updated and deleted posts and templates.
+    #            If nil,it will render all pages.
+    # Structure:
+    # {
+    #   updated_posts:[],
+    #   updated_templates:[],
+    #   has_deleted_posts:Bool
+    # }
+    def render(partials=nil)
+      if partials.nil?
+        return @tasks.each {|t|render_task t}
+      end
+      build_tasks,other_tasks=@tasks.partition {|t|!!t[:build_anyway]}
+
+      if tpls=partials[:updated_templates]
+        a,other_tasks=other_tasks.partition {|t|tpls.include? t[:template] }
+        build_tasks.concat a
+      end
+      if posts=partials[:updated_posts]
+        a,other_tasks=other_tasks.partition do |t|
+          _detectContainsPosts(t[:item],posts)
+        end
+        build_tasks.concat a
+      end
+
+      if partials[:has_deleted_posts]
+        # rebuild all post list pages
+        a,other_tasks=other_tasks.partition {|t|PostList===t[:item] || PostListPage===t[:item]}
+        build_tasks.concat a
+      end
+      build_tasks.each do |t|
+        render_task t
+      end
+    end
+
+    # Render single url corresponding task
+    # url - The String url pathname one can be used in browser,such as
+    #       '/posts','/posts/','/posts/index.html' are both valid
+    # Returns the String page content
+    def render_url(url)
+      url=url.dup
+      url[0]=''  if url[0]=='/'
+      url=url+'index.html' if url.end_with? '/'
+      # url=url+'/index.html' if site.url.start_with? url
+      t = @tasks.detect {|t|t[:urlpath]==url}
+      if t
+        return render_task t,false
+      end
+    end
+
+  private
+    # The Hash of data_id=>url or object_id=>url
+    def id2url_map
+      return @id2url_map if @id2url_map
+      @id2url_map=@tasks.group_by {|a| a[:id]}
+      @id2url_map.merge!(@id2url_map) do |k,v|
+        if v.length>1
+          urls=(v.map {|a|a[:urlpath]}).join "\n\t"
+          $stderr.puts "Object[#{k}] has more than one url:"
+          $stderr.puts "\t#{urls}"
+        end
+        v[0][:urlpath]
+      end
+      @id2url_map
+    end
+
+    def render_task(t,write_file=true)
+      item=t[:item]
+      urlpath=t[:urlpath]
+      template=t[:template]
+
+      @site._cur_page_dir = File.dirname(urlpath) if @site.local
+
+      item=Utils::ObjectProxy.new item,{site:@site} # Keep site always accessable
+      erb=Tpl::LayErb.new template
+      result=erb.render item
+
+      return result unless write_file
+      output_path=File.join(@site.dest,urlpath)
+      dir=File.dirname output_path
+      FileUtils.mkdir_p dir
+      File.open(output_path,'wb') do |f|
+        f.write result
+      end
+    end
+
+    # Render url_pattern with context data
+    # url_pattern - The String url pattern.
+    # context - The Object context
+    # Return url pathname
+    def self.sub_url(url_pattern,context)
+      url_pattern.gsub(/\{([^{}\/]+)\}/) do
+        m=$1
+        key_path=m.strip.split '.'
+        key_path.reduce(context) do |o,key|
+          v = if o.respond_to? key
+                o.send key
+              elsif (o.respond_to? :[])
+                o[key] || o[key.to_sym]
+              end
+          next v if v
+          raise BadUrlPatternException,"Unresolved property `#{m}` in url pattern [#{url_pattern}]!"
+        end
+      end
+    end
+
+    def _detectContainsPosts(item,posts)
+        return posts.include? item.path if Post===item
+        return posts.any? {|p|item.include? p} if PostList===item || PostListPage===item
+        if Hash===item
+          item.each do |k,v|
+            return true if _detectContainsPosts(v,posts)
+          end
+        elsif Array===item
+          item.each do |a|
+            return true if _detectContainsPosts(a,posts)
+          end
+        end
+        return false
+    end
+
+  end
+
+end