dimples 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75d2399050f11daf798efddb9f19ddf49ad1747a
-  data.tar.gz: 4729eb1b780383dfc1803d1a1306d434e2ae7853
+  metadata.gz: c480fd2f7363a7a6072668b2380b2e6962456bf3
+  data.tar.gz: ab0db580748680bd12d31dc34b947ee7d2161c60
 SHA512:
-  metadata.gz: 6e9bdc8ac3a8cdfe45e081530a1306acbcba76f6ec5c642f50b6aa870a4bb0cfc8be9c0daff5d3a6ae6d6f99bdcee7bffe4af8fe5bdc824557d52be2c6b36377
-  data.tar.gz: b4559ed758eb51bcbe39dc6636ca9536b5f5fd4f46c763d555924a8a88431676fff2b66a3bfd68c52d3608c8cd13071b6a44095105f59d61b65f163cb6abd8c5
+  metadata.gz: d56249e0b2cfaa9d0e4cfe6472503cfaa30d6e17e83da57cdeee62568c643c126492e03a714118d6f6e5023dd3c51b9d870d33bb075336f4494073ed01ab34c4
+  data.tar.gz: 84b2d79bc6f0108196098b91fbb62ba8d533114ef4902164ebf525ae1ad6cd8fc50a5b260a00ccdc0e1327cb7a457a21ccf255b6b110cb8ddf95e64ffda87fbb

data/lib/dimples/site.rb

@@ -17,7 +17,7 @@ module Dimples
       @output_paths = {}
       @templates = {}
       @categories = {}
-      @archives = {}
+      @archives = {year: {}, month: {}, day: {}}
 
       @pages = []
       @posts = []
@@ -39,163 +39,117 @@ module Dimples
       @output_paths[:posts] = File.join(@output_paths[:site], @config['paths']['posts'])
     end
 
+    def generate
+      prepare_site
+      scan_files
+
+      generate_posts
+      generate_pages
+      generate_archives
+
+      generate_categories if @config['generation']['categories']
+      generate_posts_feed if @config['generation']['feed']
+      generate_category_feeds if @config['generation']['category_feeds']
+
+      copy_assets
+    end
+
+    def prepare_site
+      begin
+        FileUtils.remove_dir(@output_paths[:site]) if Dir.exist?(@output_paths[:site])
+        Dir.mkdir(@output_paths[:site])
+      rescue => e
+        raise "Failed to prepare the site directory (#{e})"
+      end
+    end
+
     def scan_files
+      scan_templates
+      scan_pages
+      scan_posts
+    end
+
+    def scan_templates
       Dir.glob(File.join(@source_paths[:templates], '**', '*.*')).each do |path|
         template = Dimples::Template.new(self, path)
         @templates[template.slug] = template
       end
+    end
 
+    def scan_pages
       Dir.glob(File.join(@source_paths[:pages], '**', '*.*')).each do |path|
         @pages << @page_class.new(self, path)
       end
+    end
 
-      Dir.glob(File.join(@source_paths[:posts], '*.*')).each do |path|
-        @posts << @post_class.new(self, path)
-      end
-
-      @posts.reverse!
-      @latest_post = @posts.first
-
-      @posts.each do |post|
-
-        year = post.year.to_s
-        month = post.month.to_s
-        day = post.day.to_s
-
-        @archives[year] ||= {posts: [], months: {}}
+    def scan_posts
 
-        @archives[year][:posts] << post
-        @archives[year][:months][month] ||= {posts: [], days: {}, name: post.date.strftime('%B')}
-        @archives[year][:months][month][:posts] << post
-        @archives[year][:months][month][:days][day] ||= []
-        @archives[year][:months][month][:days][day] << post
+      Dir.glob(File.join(@source_paths[:posts], '*.*')).reverse.each do |path|
+        post = @post_class.new(self, path)
 
         post.categories.each do |category|
           (@categories[category] ||= []) << post
         end
-      end
-    end
 
-    def generate
-      scan_files
-      
-      begin
-        FileUtils.remove_dir(@output_paths[:site]) if Dir.exist?(@output_paths[:site])
-        Dir.mkdir(@output_paths[:site])
-      rescue => e
-        raise "Failed to prepare the site directory (#{e})"
-      end
+        %w[year month day].each do |date_type|
+          if @config['generation']["#{date_type}_archives"]
 
-      @posts.each do |post|
-        begin
-          post.write(@output_paths[:posts])
-        rescue => e
-          raise "Failed to render post #{File.basename(post.path)} (#{e})"
+            date_key = post.date.strftime(@config['date_formats'][date_type])
+            (@archives[date_type.to_sym][date_key] ||= []) << post
+          end
         end
-      end
 
-      @pages.each do |page|
-        begin
-          page.write(@output_paths[:site])
-        rescue => e
-          raise "Failed to render page from #{page.path.gsub(@source_paths[:root], '')} (#{e})"
-        end
+        @posts << post
       end
 
-      if @config['generation']['paginated_posts'] && @posts.length > 0
-        begin
-          paginate(@posts, false, @config['pagination']['per_page'], [@output_paths[:posts]], @config['layouts']['posts'])
-        rescue => e
-          raise "Failed to paginate main posts (#{e})"
-        end
-      end
+      @latest_post = @posts.first
+    end
 
-      if @config['generation']['year_archives'] && @archives.length > 0
+    def generate_posts
+      @posts.each do |post|
         begin
-          generate_archives
+          post.write(@output_paths[:posts])
         rescue => e
-          raise "Failed to generate archives (#{e})"
+          raise "Failed to render post #{post.path} (#{e})"
         end
       end
 
-      if @config['generation']['categories'] && @categories.length > 0
-        @categories.each_pair do |slug, posts|  
-          if @config['generation']['category_feeds']
-            begin
-              generate_feed(File.join(@output_paths[:posts], slug), {posts: posts[0..@config['pagination']['per_page'] - 1], category: slug})
-            rescue => e
-              raise "Failed to generate category feed for '#{slug}' (#{e})"
-            end
-          end
-
-          begin
-            paginate(posts, slug.capitalize, @config['pagination']['per_page'], [@output_paths[:posts], slug], @config['layouts']['category'])
-          rescue => e
-            raise "Failed to generate category pages for '#{slug}' (#{e})"
-          end
-        end
+      if @config['generation']['paginated_posts']
+        paginate(posts: @posts, paths: [@output_paths[:posts]], layout: @config['layouts']['posts'])
       end
+    end
 
-      if @config['generation']['feed'] && @posts.length > 0
+    def generate_pages
+      @pages.each do |page|
         begin
-          generate_feed(@output_paths[:site], {posts: @posts[0..@config['pagination']['per_page'] - 1]})
+          page.write(@output_paths[:site])
         rescue => e
-          raise "Failed to generate main feed (#{e})"
+          raise "Failed to render page #{page.path.gsub(@source_paths[:root], '')} (#{e})"
         end
       end
+    end
 
-      begin
-        FileUtils.cp_r(File.join(@source_paths[:public], '.'), @output_paths[:site]) if Dir.exists?(@source_paths[:public])
-      rescue => e
-        raise "Failed to copy site assets (#{e})"
+    def generate_categories
+      @categories.each_pair do |slug, posts|
+        paginate(posts: posts, title: slug.capitalize, paths: [@output_paths[:posts], slug], layout: @config['layouts']['category'])
       end
     end
 
     def generate_archives
-      if @config['layouts'].has_key?('year')
-        year_template = @config['layouts']['year']
-      elsif @config['layouts'].has_key?('archives')
-        year_template = @config['layouts']['archives']
-      else
-        year_template = @config['layouts']['posts']
-      end
+      %w[year month day].each do |date_type|
 
-      @archives.each do |year, year_archive|
-
-        if @config['generation']['month_archives']
-          if @config['layouts'].has_key?('month')
-            month_template = @config['layouts']['month']
-          elsif @config['layouts'].has_key?('archives')
-            month_template = @config['layouts']['archives']
-          else
-            month_template = @config['layouts']['posts']
-          end
+        if @config['generation']["#{date_type}_archives"]
 
-          year_archive[:months].each do |month, month_archive|
+          template = @config['layouts'][date_type] || @config['layouts']['archives'] || @config['layouts']['posts']
+          archives[date_type.to_sym].each_pair do |date_title, posts|
 
-            if @config['generation']['day_archives']
+            paths = [@output_paths[:posts], posts[0].year]
+            paths << posts[0].month if date_type =~ /month|day/
+            paths << posts[0].day if date_type == 'day'
 
-              if @config['layouts'].has_key?('day')
-                day_template = @config['layouts']['day']
-              elsif @config['layouts'].has_key?('archives')
-                day_template = @config['layouts']['archives']
-              else
-                day_template = @config['layouts']['posts']
-              end
-
-              month_archive[:days].each do |day, posts|
-                day_title = posts[0].date.strftime(@config['date_formats']['day'])
-                paginate(posts, day_title, @config['pagination']['per_page'], [@output_paths[:posts], year.to_s, month.to_s, day.to_s], day_template)
-              end
-            end
-
-            month_title = month_archive[:posts][0].date.strftime(@config['date_formats']['month'])
-            paginate(month_archive[:posts], month_title, @config['pagination']['per_page'], [@output_paths[:posts], year.to_s, month.to_s], month_template)
+            paginate(posts: posts, title: date_title, paths: paths, layout: template)
           end
         end
-
-        year_title = year_archive[:posts][0].date.strftime(@config['date_formats']['year'])
-        paginate(year_archive[:posts], year_title, @config['pagination']['per_page'], [@output_paths[:posts], year.to_s], year_template)
       end
     end
 
@@ -206,53 +160,75 @@ module Dimples
       feed.extension = 'atom'
       feed.layout = 'feed'
 
-      feed.write(path, options)
+      begin
+        feed.write(path, options)
+      rescue => e
+        raise "Failed to generate feed #{path} (#{e})"
+      end
     end
 
-    def paginate(posts, title, per_page, paths, layout, params = {})
-      fail "'#{layout}' template not found" unless @templates.has_key?(layout)
+    def generate_posts_feed
+      generate_feed(@output_paths[:site], {posts: @posts[0..@config['pagination']['per_page'] - 1]})
+    end
 
-      pages = (posts.length.to_f / per_page.to_i).ceil
+    def generate_category_feeds
+      @categories.each_pair do |slug, posts|
+        generate_feed(File.join(@output_paths[:posts], slug), {posts: posts[0..@config['pagination']['per_page'] - 1], category: slug})
+      end
+    end
 
-      for index in 0...pages
-        range = posts.slice(index * per_page, per_page)
+    def copy_assets
+      begin
+        FileUtils.cp_r(File.join(@source_paths[:public], '.'), @output_paths[:site]) if Dir.exists?(@source_paths[:public])
+      rescue => e
+        raise "Failed to copy site assets (#{e})"
+      end
+    end
 
-        page = @page_class.new(self)
+    def pagination_url(page, paths)
+      path = '/'
 
-        page_paths = paths.clone
-        page_title = title ? title : @templates[layout].title
+      path += File.split(paths[0])[-1] + "/" if paths[0] != @output_paths[:site]
+      path += paths[1..-1].join('/') + "/" if paths.length > 1
+      
+      path
+    end
 
-        if page_paths[0] == @output_paths[:site]
-          url_path = '/'
-        else
-          url_path = "/#{File.split(page_paths[0])[-1]}/"
-        end
+    def paginate(posts:, title: nil, paths:, layout: false)
+      fail "'#{layout}' template not found" unless @templates.has_key?(layout)
 
-        url_path += "#{page_paths[1..-1].join('/')}/" if page_paths.length > 1
+      per_page = @config['pagination']['per_page']
+      page_count = (posts.length.to_f / per_page.to_i).ceil
 
-        if index > 0
-          page_paths.push("page#{index + 1}")
-        end
+      for index in 1..page_count
+        range = posts.slice((index - 1) * per_page, per_page)
+
+        page = @page_class.new(self)
+
+        page.layout = layout
+        page.title = title || @templates[layout].title
+
+        page_paths = paths.clone
 
         pagination = {
-          page: index + 1,
-          pages: pages,
-          total: posts.length,
-          path: url_path
+          page: index,
+          pages: page_count,
+          post_count: posts.length,
+          path: pagination_url(index, page_paths)
         }
 
-        if (pagination[:page] - 1) > 0
-          pagination[:previous_page] = pagination[:page] - 1
-        end
+        page_paths << "page#{index}" if index != 1
 
-        if (pagination[:page] + 1) <= pagination[:pages]
-          pagination[:next_page] = pagination[:page] + 1
-        end
+        pagination[:previous_page] = pagination[:page] - 1 if (pagination[:page] - 1) > 0
+        pagination[:next_page] = pagination[:page] + 1 if (pagination[:page] + 1) <= pagination[:pages]
 
-        page.layout = layout
-        page.title = page_title
+        path = File.join(page_paths)
 
-        page.write(File.join(page_paths), {posts: range, pagination: pagination}.merge(params))
+        begin
+          page.write(path, {posts: range, pagination: pagination})
+        rescue => e
+          raise "Failed to generate paginated page #{path} (#{e})"
+        end
       end
     end
   end

data/lib/dimples/version.rb

@@ -1,3 +1,3 @@
 module Dimples
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dimples
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Daniel Bogan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-21 00:00:00.000000000 Z
+date: 2015-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt