jekyll_asciidoctor_pdf 0.0.15 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81a66a88d2063060425ff0bd92f8a872ab0cd43c3adc91c83a3f9dfb30a01629
-  data.tar.gz: a0d82d2cb06efa99c9b3478b7f733dcea2740637c9ca83dd67ac6cdbb85d9cd1
+  metadata.gz: '09550c635149441d709366d60bf401788a4bb529ebeeb02fb5375019a0c42df4'
+  data.tar.gz: 872489f640ae593e3c4b0d52cbe0e66a89dbaa0bc8554789605ecdc4d7319bdf
 SHA512:
-  metadata.gz: a86d39357db19907c82a2268e8bc5dd287fafe1581e7037864964f5a0407ee48d2d442ae75586827ed39d2e973ca4de74baf2fddd55254386ea9f50320931206
-  data.tar.gz: 5aafdca752f5edb29c1495b50332a3b52480d55bb2cba9645aacf41ab6d098ae190fd15b6773824f0ef2b58f37d12236b951570798655cb324df523d2dec3cc7
+  metadata.gz: '092973c75f4944a59174674ffc09bbe7e4244cdf96734c19b3cb7aa81b56f727cc7f8649ff0b08c78c7af0b1db796524da08a4d0354bd37793f2475bb9499179'
+  data.tar.gz: b22030fa3a38f441788823c881c759f772f51ff872847040cea7f4c27c90235bc682dc6ffc7bb01da8ddca236987b772b640640b977df8f2b4fbd0dd3cb094c5

data/README.adoc

@@ -2,7 +2,7 @@
 :gem-name: jekyll_asciidoctor_pdf
 :gh-branch: master
 :badge-style: flat
-:release-version: 0.0.14
+:release-version: 0.1.2
 
 image:https://img.shields.io/gem/v/{gem-name}.svg?style={badge-style}[Gem Version, link="https://rubygems.org/gems/{gem-name}"]
 image:https://travis-ci.com/NetAppDocs/jekyll-asciidoctor-pdf.svg?token=jmKxRqiJdAgY6ceg7i2d&branch=master["Build Status", link="https://travis-ci.com/NetAppDocs/jekyll-asciidoctor-pdf"]
@@ -43,6 +43,7 @@ require 'rake_jekyll_asciidoctor_pdf'
   
 RakeJekyllAsciidoctorPdf::BuildTask.new('buildAll') do |t|
   t.jekyll_config_file = '_config.yml'
+  t.fullsite_title = ENV['PRODUCT_NAME']
 end
 ----
 
@@ -55,13 +56,11 @@ end
 [source,ruby]
 ----
 jap_config:
-    sidebar_file: '_data/sidebar.yml'
+    sidebar_path: '_data/sidebars/'
     output_path: 'pdfs'
     source_path: '.'
-    assets_list: ['media']
     exclude_list: []
     fullsite:
-        title: "Main Title"
         subtitle: "Subtitle"
         authors: "Author1, Author2"
         revision: "Revision Date"
@@ -89,10 +88,62 @@ A basic directory structure usually looks something like this:
 └── *.adoc # all asciidoc files are in the root level 
 ```
 
+A complex directory structure could be like this
+
+```
+.
+├── _config.yml
+├── _data
+│   ├── sidebar1
+│   │ ...
+│   └── sidebarN.yml
+├── sidebar1_source 
+│   ├── media
+│   ├── *.adoc # all asciidoc files are in the root level 
+|   ...
+├── sidebarN_source 
+│   ├── media
+│   ├── *.adoc # all asciidoc files are in the root level 
+└── pdfs # this folder will be created by rake_jekyll_asciidoctor_pdf
+    ├── pages/
+    ├── sidebar1/
+    ├── ...
+    ├── sidebarN/
+    └── fullsite/
+
+```
+
+
 
 == Usage
 
  $ bundle exec rake buildAll
 
+== Known Limitations
+ * Mp4 is not supported
+ * Gif files need prawn-gmagick
+ * Absolute URL not supported in the sidebar.yml
+ * Problems with image labels like that
+ * Problems with interal *links:*
+ * Unicode characters are not supported by AsciiDocPdf (e.i. ✓)
+ 
+[source,asciidoc]
+----
+//image:diagram_networking_cloud.png[service, a] not working, shoud be like this
+image:diagram_networking_cloud.png["service, a"]
+----
 
-
+ 
+== ToDo List ==
+ 
+ * [x] Remove front matter from original files
+ * [x] Generate a combined file with each item in the sidebar.yml
+ * [x] Allow to customize PDF using a theme of AsciiDoctor-PDF
+ * [ ] Remove header attribuites in the original files
+ * [x] Increase 1 level each time we combine a child in the sidebar
+ * [x] Generate a PDF for each section
+ * [ ] Support multiple sidebar.yml like HCI (Partial)
+ * [x] Support basic recursion over directories
+ 
+ 
+ 

data/lib/jekyll_asciidoctor_pdf/adoc.rb

@@ -0,0 +1,125 @@
+require 'yaml'
+require 'fileutils'
+require 'asciidoctor-pdf'
+require 'asciidoctor'
+
+# Do not touch, this REGEXP is taken from Jekyll source code
+YAML_FRONT_MATTER_REGEXP = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+
+module JekyllAsciidoctorPdf
+    class ADoc 
+        ##
+        # Generate a PDF of an individual page
+        #
+        #  - Remove the jekyll frontmatter 
+        #  - Execute the convert process 
+        #  - Let the caller to collect information from the front_matter and from the file itself
+        #
+        def self.generatePdf(title, file, output_path, parameters, cover_page, theme_pdf)
+
+            #filename = SafeYAML.load_file(file)
+            front_matter = {}
+
+            content = File.read(file)
+            if content =~ YAML_FRONT_MATTER_REGEXP
+                #content = $POSTMATCH
+                front_matter = SafeYAML.load(Regexp.last_match(1))
+            end
+
+            stream_adoc = content.gsub(YAML_FRONT_MATTER_REGEXP, '')
+
+            filename = File.basename(file,'.*') + '.pdf'
+            filename_path = output_path
+            subtitle = 'Page'
+            base_path = File.dirname(file)
+
+            generateBookTypePdf(filename, filename_path, title, subtitle, base_path, stream_adoc, parameters, cover_page, theme_pdf)
+
+            yield(front_matter, stream_adoc) if block_given?
+        end
+
+
+        ##
+        # We abstract the call to Asciidoctor to convert Stream => PDF
+        #
+        # Arguments:
+        #     - filename:       name of the output file (should include extension e.i. name.pdf)
+        #     - filename_path:  output path for the filename
+        #     - title:          title of the cover page
+        #     - subtitle:       subtitle of the cover page
+        #     - base_path:      this is the root path to execture the convert process (relative :imagedir attribute use that path)
+        #     - stream_adoc:    the Asciidoc file as string
+        #     - parameters:     configuration from YAML file
+        #     - cover_page:     absolute image for the cover page
+        #     - theme_pdf:      absolute YAML file with the theme configuration of Asciidoctor-pdf 
+        #
+        #  NOTE: 
+        #      * We set the mode to :unsafe, due to the error "image has illegal reference to ancestor of jail;"
+        #    e.i :imagedirs: ../media
+        #
+        #      * We allow to read external files with the attribute 'allow-uri-read' => ''
+        #    e.i  image:http://example.org/image.png          
+        #      (we may want to block this feature is too expensive)
+        #
+        def self.generateBookTypePdf(filename, filename_path, title, subtitle, base_path, stream_adoc, parameters, cover_page, theme_pdf)
+
+            Asciidoctor.convert(
+                getFullsiteTemplate(title, subtitle, stream_adoc, parameters, cover_page, theme_pdf), 
+                backend: 'pdf', 
+                doctype: 'book', 
+                to_file: filename,
+                to_dir: filename_path, 
+                mkdirs: true, 
+                safe: :unsafe, 
+                attributes: { 'allow-uri-read' => '' },
+                base_dir: base_path 
+            );
+        end
+
+        ##
+        # Basic Template for the fullsite pdf 
+        #
+        # TODO: Add more configuracion
+        #
+        def self.getFullsiteTemplate(title, subtitle, fullsite, parameters, cover_page, theme_pdf)
+            fullsite_config = parameters['fullsite']
+
+            authors  = fullsite_config['authors']
+            revision = fullsite_config['revision']
+
+            text = <<~TEXT
+                    = #{title} : #{subtitle}
+                    #{authors}
+                    #{revision}
+                    :doctype: book
+                    :experimental:
+                    :reproducible:
+                    :icons: font
+                    :listing-caption: Listing
+                    :sectnums:
+                    :imagesdir: ./media/
+                    :toc:
+                    :toclevels: 2
+                    ifeval::["{asciidoctor-version}" < "1.5.7"]
+                    :legacy-footnoteref:
+                    endif::[]
+                    ifdef::backend-pdf[]
+                    :pdf-theme: #{theme_pdf}
+                    :title-page:
+                    :title-page-background-image: image:#{cover_page}[fit=none,pdfwidth=100%,position=top]
+                    :source-highlighter: rouge
+                    endif::[]
+                    :chapter-label:
+
+                    :leveloffset: +1
+                    #{fullsite}
+                    :leveloffset: -1
+            TEXT
+
+            return text
+        end
+
+
+    end
+
+end

data/lib/jekyll_asciidoctor_pdf/commands.rb

@@ -6,11 +6,10 @@ require 'yaml'
 require 'fileutils'
 require 'asciidoctor-pdf'
 require 'asciidoctor'
-require 'jekyll_asciidoctor_pdf/tree'
-
-
-# Do not touch, this REGEXP is taken from Jekyll source code
-YAML_FRONT_MATTER_REGEXP = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+require 'jekyll_asciidoctor_pdf/adoc'
+require 'jekyll_asciidoctor_pdf/logger'
+require 'jekyll_asciidoctor_pdf/sidebar'
+require 'jekyll_asciidoctor_pdf/permalink'
 
 
 module JekyllAsciidoctorPdf
@@ -56,34 +55,35 @@ module JekyllAsciidoctorPdf
         attr_accessor :description
 
         attr_accessor :parameters
+        attr_accessor :permalinks
 
-        attr_reader :absolute_temp_path
         attr_reader :absolute_working_path
         attr_reader :absolute_source_path
-        attr_reader :absolute_assets_list
         attr_reader :absolute_config_file
-        attr_reader :absolute_sidebar_file
+        attr_reader :absolute_sidebar_path
         attr_reader :absolute_output_path
 
-        attr_reader :assets_list
+        attr_reader :absolute_cover_page
+        attr_reader :absolute_theme_pdf
+
         attr_reader :quiet
 
         callable_attr :jekyll_config_file, '_config.yml'
 
+        callable_attr :fullsite_title, 'NetApp'
+
+
+        ##
+        #
         def initialize(name = :build_pdf)
             @name = name
             @description = 'Generate PDF files for each *.adoc in the source_list  '
 
             @absolute_working_path = Dir.pwd
-            @absolute_temp_path    = Dir.mktmpdir 
-
-            @quiet = { verbose: true } 
 
-            #file = __FILE__
-            #file = File.readlink(file) if File.symlink?(file)
-            #@base_dir = File.dirname(file)
+            @permalinks = Hash.new
 
-            #puts @base_dir 
+            @quiet = { verbose: true } 
 
             yield self if block_given?
 
@@ -92,15 +92,10 @@ module JekyllAsciidoctorPdf
             do_jekyll_config_ok? do |t|
                 @absolute_source_path   = File.join(@absolute_working_path, @parameters['source_path']);
                 @absolute_output_path   = File.join(@absolute_working_path, @parameters['output_path']);
-                @absolute_sidebar_file  = File.join(@absolute_working_path, @parameters['sidebar_file']);
+                @absolute_sidebar_path  = File.join(@absolute_working_path, @parameters['sidebar_path']);
+                @absolute_cover_page    = File.join(@absolute_output_path, 'assets','cover_page_background.jpg');
+                @absolute_theme_pdf     = File.join(@absolute_output_path, 'assets','pdf-theme.yml');
 
-                files = []
-                FileList[@parameters['assets_list']].each do |file|
-                    files << File.join(@absolute_working_path,file)
-                end
-
-                @absolute_assets_list = files
-           
                 define_task!
             end
         end
@@ -119,34 +114,17 @@ module JekyllAsciidoctorPdf
                 clean
             end
 
-
-            # We can improve it using replace inline and cp
-            desc "Rewriting *.adoc files and generating auxiliary files without front matter"
-            task :generateTempFiles => [ :clean ]  do
-                generate_temp_files
-            end
-
-            desc "Generating PDFs files for each page"
-            task :generatePdf => [:clean, :generateTempFiles] do
-                generate_pdf
-            end
-
-            desc "Generate the fullsite.adoc file"
-            file 'fullsite.adoc' => ['generateTempFiles'] do
-
-                generate_fullsite_adoc
-            end
-
-            desc "Generate the fullsite.pdf file"
-            file 'fullsite.pdf' => 'fullsite.adoc' do
-
-                generate_fullsite_pdf
+            desc "Initialize files & directories"
+            task :init => [ :clean ] do
+                init 
             end
 
 
             desc description
-            task name.to_sym => [:generatePdf, 'fullsite.pdf'] do
-                remove_entry absolute_temp_path
+            task name.to_sym => [:clean, :init] do
+                generate_individual_pdf
+                generate_fullsite_adoc
+                undo_init
             end
 
 
@@ -165,9 +143,8 @@ module JekyllAsciidoctorPdf
             @parameters   = config['jap_config']
 
             assert_key(@parameters, 'source_path' , "Expected key 'jap_config.source_path' to exist, but does not") 
-            assert_key(@parameters, 'assets_list' , "Expected key 'jap_config.assets_list' to exist, but does not") 
             assert_key(@parameters, 'output_path' , "Expected key 'jap_config.output_path' to exist, but does not") 
-            assert_key(@parameters, 'sidebar_file', "Expected key 'jap_config.sidebar_file' to exist, but does not") 
+            assert_key(@parameters, 'sidebar_path', "Expected key 'jap_config.sidebar_path' to exist, but does not") 
 
             yield
         end
@@ -180,120 +157,138 @@ module JekyllAsciidoctorPdf
         end
 
 
+        ##
+        # Only to debug 
+        #
         def print_variables 
             output("Current directory: "   + absolute_working_path)
             output("Jekyll Config File: "  + absolute_config_file)
             output("Source directory: "    + absolute_source_path)
-            output("Assets files: "        + absolute_assets_list.join("\n"))
-            output("Temporary directory: " + absolute_temp_path)
+            output("Sidebar directory: "   + absolute_sidebar_path)
             output("Building directory: "  + absolute_output_path)
         end
 
+        ##
+        #
+        #
         def clean
-            output_pages = File.join(absolute_output_path, '/pages')
-            output("Removing files & ouput directories ...")
+            output("Removing files & output directories ...")
             rm_rf(absolute_output_path, quiet)
-            mkdir_p(absolute_output_path, quiet)
-            mkdir_p(output_pages,quiet)
         end
 
-        def generate_temp_files
-            temp_pages = File.join(absolute_temp_path, '/pages')
-            temp_links = File.join(absolute_temp_path, '/links')
-            
-            output("Creating Temporary Folders and Ouput Directories ...")
-            mkdir_p(temp_pages,quiet)
-            mkdir_p(temp_links, quiet)
-
-            FileList[absolute_assets_list].each do |file|
-                cp_r(file, temp_pages, quiet)
-            end
+        ##
+        #
+        #
+        def init
+            output("Initialize files & output directories ...")
+            output_fullsite = File.join(absolute_output_path, '/fullsite')
+            output_pages    = File.join(absolute_output_path, '/pages')
+            output_assets   = File.join(absolute_output_path, '/assets')
 
-            output("Rewriting *.adoc files and generating auxiliary files without front matter ...")
-            FileList[absolute_source_path + "/*.adoc"].each do |file|
+            mkdir_p(absolute_output_path, quiet)
+            mkdir_p(output_pages,quiet)
+            mkdir_p(output_assets,quiet)
+            mkdir_p(output_fullsite,quiet)
 
-                filename = SafeYAML.load_file(file)
-                front_matter = {}
+            fullsite_config         = parameters['fullsite']
+            background_image        = File.join(absolute_working_path, fullsite_config['background_image'])
+            cp_r(background_image, absolute_cover_page, quiet)
 
-                content = File.read(file)
-                if content =~ YAML_FRONT_MATTER_REGEXP
-                    #content = $POSTMATCH
-                    front_matter = SafeYAML.load(Regexp.last_match(1))
-                end
+            File.open(absolute_theme_pdf, "w") { |file| file.write(getPdfTheme() ) }
 
-                result = content.gsub(YAML_FRONT_MATTER_REGEXP, '')
-            
-                if front_matter.key?('permalink')  
-                    output = File.join(temp_links, front_matter['permalink'] + '.adoc')
-                else 
-                    output = File.join(temp_links, File.basename(file))
-                end
-                # Write the auxiliary file for combine later in the full pdf file
-                File.write(output, result)
+        end
 
-                # Write the auxiliary file for individual pages 
-                output = File.join(temp_pages, File.basename(file))
-                File.write(output, result)
-            end
+        ##
+        #
+        #
+        def undo_init
+            output("Removing auxiliaries files & directories ...")
+            output_assets = File.join(absolute_output_path, '/assets')
+            rm_rf(output_assets, quiet)
         end
 
-        def generate_pdf
-            output("Generating PDFs files for each page ...")
-            temp_pages = File.join(absolute_temp_path, '/pages')
-            pdf_pages  = File.join(absolute_output_path, '/pages') 
+        ##
+        # Loop over each AsciiDoctor file recursively
+        #
+        # Steps:
+        #
+        # 1. Read the file
+        # 2. Remove jekyll fronmatter
+        # 3. Generate a PDF with the content and put it in <output>/pages/[<subfolder>]/<filename>.pdf
+        # 4. Get the 'permalink' and add the content to a hash to be used by sidebar process
+        #
+        # Warning: We should keep the original directory structure to avoid name collisions
+        #
+        def generate_individual_pdf
 
-            FileList[temp_pages + "/*.adoc"].each do |file|
-                Asciidoctor.convert_file file, backend: 'pdf', doctype: 'article', to_dir: pdf_pages , mkdirs: true,  safe: :safe
-            end
-        end
 
-        def generate_fullsite_adoc
+            output("Generating content for each individual pages")
 
-            output("Generating fullside.adoc ...")
-            toc = YAML.load_file(absolute_sidebar_file)
+            pdf_pages  = File.join(absolute_output_path, '/pages') 
 
-            tree = create_from_menu('Root', toc['entries'], true)
+            cd absolute_source_path
+            FileList["**/*.adoc"].each do |file|
 
-            Tree.printTree(tree,2)
+                output_path = File.join(pdf_pages,File.dirname(file))
+                mkdir_p_if_not_exist(output_path)
 
-            #tree.traverse_subtree do |node|
-            #    children = node.children.map { |child| child.title}
-            #    puts "#{node.title}: #{children}"
-            #end
+                JekyllAsciidoctorPdf::ADoc.generatePdf(fullsite_title, file,pdf_pages, parameters, absolute_cover_page, absolute_theme_pdf ) do |front_matter, stream_adoc|
+                    if front_matter.key?('permalink')  
+                        name = File.join('/', front_matter['permalink'])
+                        data = PermalinkData.new(front_matter['sidebar'], stream_adoc, file)
+                        permalinks[name] = data
+                    end 
+                end
 
-            temp_links = File.join(absolute_temp_path, '/links')
-            output = File.join(absolute_temp_path,'fullsite.adoc')
-            File.write(output, Tree.updateContent(tree, temp_links))
 
-            output("Full site AsciiDoc generated in [ " + output +" ]")
+            end 
 
         end
 
-        def generate_fullsite_pdf
 
-            FileList[absolute_assets_list].each do |file|
-                cp_r(file, absolute_temp_path, quiet)
-            end
+        ##
+        # Loop over each YAML file in the sidebar_path 
+        #
+        # Steps:
+        #   - Execute generateContent to create all sections and one file with the whole content of the sitebar
+        #
+        # Output directories:
+        #
+        #   <output_path>
+        #        |__ <sidebar>/<section>.pdf           -> Section output
+        #        |__ fullsite/fullsite_<sidebar>.pdf   -> whole sidebar content (a.k.a. fullsite PDF)
+        #
+        def generate_fullsite_adoc
 
-            fullsite_config  = parameters['fullsite']
-            background_image        = File.join(absolute_working_path, fullsite_config['background_image'])
-            output_background_image = File.join(absolute_temp_path, '/media', 'cover_page_background.jpg')
-            cp_r(background_image, output_background_image, quiet)  
 
+            FileList[absolute_sidebar_path + "*.yml"].each do |file|
+                output("Generating content for " + File.basename(file))
+
+                name = File.basename(file).ext('')
 
-            output = File.join(absolute_output_path,'fullsite_template.pdf')
-            #cp(File.join('fullsite_template.adoc'),build_fullsite_output , quiet)
-            cd(absolute_temp_path)
-            File.open("pdf-theme.yml", "w") { |file| file.write(getPdfTheme() ) }
-            File.open("fullsite_template.adoc", "w") { |file| file.write(getFullsiteTemplate() ) }
-            #content = getFullsiteTemplate()
+                JekyllAsciidoctorPdf::SidebarYAML.new(
+                    fullsite_title, 
+                    name, 
+                    file, 
+                    permalinks, 
+                    parameters, 
+                    absolute_output_path, 
+                    absolute_source_path,
+                    absolute_cover_page,
+                    absolute_theme_pdf
+                )
 
-            Asciidoctor.convert_file 'fullsite_template.adoc', backend: 'pdf', mkdirs: true,  safe: :safe
-            cp_r('fullsite_template.pdf',absolute_output_path, quiet)
-            output("Full site PDF generated in [ " + output +" ]")
+                #cd absolute_working_path
 
+                #sidebar.generatePdf()
+
+            end
         end
 
+
+        ##
+        # Assert function
+        #
         def assert(condition, message)
             if not condition
                 output(message)
@@ -301,74 +296,28 @@ module JekyllAsciidoctorPdf
             end
         end
 
-
-        # Print functionallity
-        def output(string)
-            puts ' * ' + string
+        ##
+        # Create a directory only if its necessary 
+        #
+        def mkdir_p_if_not_exist(dir)
+            mkdir_p(dir, quiet) unless File.exists?(dir)
         end
 
-        def getFullsiteTemplate()
-            fullsite_config = parameters['fullsite']
-
-            title    = fullsite_config['title']
-            subtitle = fullsite_config['subtitle']
-            authors  = fullsite_config['authors']
-            revision = fullsite_config['revision']
-            #background_image = fullsite_config['background_image']
-
-            text = <<~TEXT
-                = #{title} : #{subtitle}
-                #{authors}
-                #{revision}
-                :doctype: book
-                :experimental:
-                :reproducible:
-                :icons: font
-                :listing-caption: Listing
-                :sectnums:
-                :imagesdir: ./media/
-                :toc:
-                :toclevels: 2
-                ifeval::["{asciidoctor-version}" < "1.5.7"]
-                :legacy-footnoteref:
-                endif::[]
-                ifdef::backend-pdf[]
-                :pdf-theme: pdf-theme.yml 
-                :title-page:
-                :title-page-background-image: image:cover_page_background.jpg[fit=none,pdfwidth=100%,position=top]
-                :source-highlighter: rouge
-                //:rouge-style: github
-                endif::[]
-                :chapter-label:
-
-                :leveloffset: +1
-                include::fullsite.adoc[]
-                :leveloffset: -1
-            TEXT
-
-            return text
-        end
 
+
+        ##
+        # Load the asciidoctor-pdf theme from the jekyll _config.yml
+        #
         def getPdfTheme()
             return parameters['pdf_theme'].to_yaml
         end
 
-       def create_from_menu(name, children, root)
-            root_node     = Tree::Node.new(name, '','',root)
-            children.each do |child|
-                if child.key?('entries') 
-                    root_node.add_child(create_from_menu(child['title'], child['entries'],false))
-                else
-                    if child['url'].downcase.start_with?('http:') or child['url'].downcase.start_with?('https:')
-                        output("Absolute links are not supported!")
-                    else 
-                        root_node.add_child(Tree::Node.new(child['title'],child['url'], '', false))
-                    end
-                end
-            end
+    def output(string)
+        puts ' * ' + string
+    end
+
+
 
-            return root_node
-       end
 
     end
 end

data/lib/jekyll_asciidoctor_pdf/logger.rb

@@ -0,0 +1,11 @@
+
+module JekyllAsciidoctorPdf
+    ##
+    # Log functionallity
+    # TODO: Use the quit parameter to control the behavior
+    #
+    def self.output(string)
+        puts ' * ' + string
+    end
+
+end

data/lib/jekyll_asciidoctor_pdf/permalink.rb

@@ -0,0 +1,18 @@
+
+module JekyllAsciidoctorPdf
+
+    ##
+    # Abstract structure for a hash dictionary
+    #
+    # We use to create a dictionary of all permalinks a its content (without frontmatter)
+    #
+    class PermalinkData
+        attr_reader :sidebar, :content, :filename
+        def initialize(sidebar, content, filename)
+            @sidebar  = sidebar
+            @content  = content
+            @filename = filename
+        end
+    end
+end
+

data/lib/jekyll_asciidoctor_pdf/sidebar.rb

@@ -0,0 +1,174 @@
+require 'rake'
+require 'rake/tasklib'
+require 'tmpdir'
+
+require 'yaml'
+require 'fileutils'
+require 'asciidoctor-pdf'
+require 'asciidoctor'
+
+require 'jekyll_asciidoctor_pdf/logger'
+
+
+module JekyllAsciidoctorPdf
+    ##
+    # General Tree Data Structure 
+    #
+    class SidebarEntry 
+        attr_reader :children, :content, :page, :title, :root
+
+        def initialize(title, page, content, root)
+            @children = []
+            @root  = root
+            @page  = page 
+            @title = title
+            @content = content
+        end
+
+        def add_content(content)
+            @content << "\n"
+            @content << content
+        end
+
+        def add_child(child)
+            @children << child
+        end
+
+    end
+
+
+    ##
+    # Data Structure that hold the information of an specific sidebar and generate content with that
+    #
+    # TODO:
+    #    In order to generalize the directory structure we need to 
+    #
+    #    - add a base_path with the relative path root of all *.adoc files
+    #    - add a prefix_permanlink to get that front_matter.permalink = prefix_permalink + sidebar.url
+    #
+    class SidebarYAML 
+    
+        attr_reader :title, :name, :file, :permalinks, :parameters, :section_output_path, :sidebar_output_path, :base_path, :cover_page, :theme_pdf
+
+
+        def initialize(title, name, file, permalinks, parameters, output_path, base_path, cover_page, theme_pdf )
+            @title       = title
+            @name        = name
+            @file        = file
+            @permalinks  = permalinks
+            @parameters  = parameters
+            @base_path   = base_path
+            @cover_page  = cover_page
+            @theme_pdf   = theme_pdf
+
+            @section_output_path = File.join(output_path,name)
+            @sidebar_output_path = File.join(output_path,'/fullsite')
+
+            FileUtils::mkdir_p(section_output_path)
+            FileUtils::mkdir_p(sidebar_output_path)
+
+            toc = YAML.load_file(file)
+            loadAndProcess('Root', toc['entries'], true)
+
+        end
+
+
+
+        ##
+        # We always call this function with a section or the whole sidebar (in a branch of the Tree Structure)
+        #
+        #
+        def loadAndProcess(name, children, root)
+            output("- Process " + name)
+            node = JekyllAsciidoctorPdf::SidebarEntry.new(name, '','',root)
+
+            #  In the section level, we will display the title 
+            # and increase the section level for the content
+            if not root
+                node.add_content("= " + node.title + "\n")
+                node.add_content(":leveloffset: +1 \n")
+            end
+
+            ##
+            # Loop over the children
+            #
+            # Case 1:
+            #    - We are in a section (handled by recursion over the tree)
+            #    - Add the content in the 'node' (father) and continue
+            # Case 2:
+            #    - We are in a leaf
+            #    - Avoid absolute URL or not found permalink
+            #    - Add the content in the 'node' (father) and continue
+            # 
+            children.each do |child|
+                page    = child['url']
+                title   = child['title']
+                entries = child['entries']
+
+                if child.key?('entries') 
+                    ##
+                    # We are in a section
+                    #
+                    ret = loadAndProcess(title, entries,false)
+                    node.add_child(ret)
+                    node.add_content(ret.content) 
+                else
+                    ##
+                    # We are in a leaf of the tree 
+                    #
+                    if page.downcase.start_with?('http:') or page.downcase.start_with?('https:')
+                        # We ignore absolute links
+                        output("Absolute links are not supported!")
+                    else 
+                        if permalinks.key?(page) 
+                            # We have the content
+                            node.add_child(JekyllAsciidoctorPdf::SidebarEntry.new(title,page, permalinks[page].content, false))
+                            node.add_content(permalinks[page].content) 
+                        else
+                            # We don't have the content
+                            node.add_child(JekyllAsciidoctorPdf::SidebarEntry.new(title,page, "= Page not found "+ page + "\n", false))
+                        end
+                    end
+                end
+            end
+
+            ##
+            # We need to generate the content for the whole section or the whole sidebar
+            if not root 
+                # This is a section
+                node.add_content(":leveloffset: -1 \n")
+                filename = node.title.gsub(/[^0-9A-Z]/i, '_') + '.pdf'
+
+                JekyllAsciidoctorPdf::ADoc.generateBookTypePdf(filename, section_output_path, title, node.title, base_path, node.content, parameters, cover_page, theme_pdf)
+            else
+                # This is the root of the sidebar
+                subtitle = 'Docs'
+                filename = File.basename(file).ext('.pdf')
+                filename_path = sidebar_output_path
+
+                JekyllAsciidoctorPdf::ADoc.generateBookTypePdf(filename, filename_path, title, subtitle, base_path, node.content, parameters, cover_page, theme_pdf)
+            end
+
+            return node
+            
+        end
+
+        ##
+        # Print a tree structure
+        #
+        def self.printTree(tree, level) 
+            puts str = ("-" * level) + tree.title
+            if tree.children.length > 0 
+                tree.children.map { |child| printTree(child, level + 1) }
+            end
+        end
+
+        def output(string)
+            puts ' * ' + string
+        end
+
+    end
+end
+
+
+

data/lib/jekyll_asciidoctor_pdf/version.rb

@@ -1,3 +1,3 @@
 module JekyllAsciidoctorPdf
-  VERSION = '0.0.15'
+  VERSION = '0.1.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll_asciidoctor_pdf
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.1.2
 platform: ruby
 authors:
 - Guido Genzone
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-13 00:00:00.000000000 Z
+date: 2020-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -124,8 +124,11 @@ files:
 - bin/setup
 - jekyll_asciidoctor_pdf.gemspec
 - lib/jekyll_asciidoctor_pdf.rb
+- lib/jekyll_asciidoctor_pdf/adoc.rb
 - lib/jekyll_asciidoctor_pdf/commands.rb
-- lib/jekyll_asciidoctor_pdf/tree.rb
+- lib/jekyll_asciidoctor_pdf/logger.rb
+- lib/jekyll_asciidoctor_pdf/permalink.rb
+- lib/jekyll_asciidoctor_pdf/sidebar.rb
 - lib/jekyll_asciidoctor_pdf/version.rb
 homepage: https://rubygems.org/gems/jekyll_asciidoctor_pdf
 licenses:

data/lib/jekyll_asciidoctor_pdf/tree.rb

@@ -1,71 +0,0 @@
-require 'yaml'
-require 'fileutils'
-
-module Tree
-
-    class Node
-        attr_reader :children, :content, :page, :title, :root
-
-        def initialize(title, page, content, root)
-            @children = []
-            @root  = root
-            @page  = page 
-            @title = title
-            @content = content
-        end
-
-        def add_content(content)
-            @content << "\n"
-            @content << content
-        end
-
-        def add_child(child)
-            @children << child
-        end
-
-
-        def traverse_subtree(&block)
-            node_queue = [self]                             # Step 1
-            until node_queue.empty?                         # Step 2
-                node = node_queue.shift                       # Step 3
-                yield node                                    # Step 4
-                node_queue = node.children.concat(node_queue) # Step 5
-            end
-        end
-
-    end
-
-    def self.updateContent(tree, temp_dir)
-        if tree.page.length > 0 
-            file = File.join(temp_dir, tree.page + '.adoc')
-            tree.add_content(File.read(file))
-        else 
-            if not tree.root 
-                tree.add_content("= " + tree.title)
-            end
-        end
-
-        if not tree.root 
-            tree.add_content(":leveloffset: +1 \n")
-        end
-
-        if tree.children.length > 0 
-            tree.children.map { |child| tree.add_content(updateContent(child, temp_dir)) }
-        end
-
-        if not tree.root 
-            tree.add_content(":leveloffset: -1 \n")
-        end
-        return tree.content
-    end
-    def self.printTree(tree, level) 
-        puts str = ("-" * level) + tree.title
-        if tree.children.length > 0 
-            tree.children.map { |child| printTree(child, level + 1) }
-        end
-    end
-
-end
-
-
-