adocsite 1.0.0

data/lib/adocsite/content_loader.rb

@@ -0,0 +1,59 @@
+module Adocsite
+  class ContentLoader
+    attr_reader :styles, :scripts, :images, :files, :pages, :articles
+    def initialize
+      @adoc_options = {:attributes => {
+        "imagesdir" => Adocsite::config[:IMAGES_FOLDER],
+        "stylesdir" => Adocsite::config[:STYLES_FOLDER],
+        "iconsdir" => Adocsite::config[:IMAGES_FOLDER] + "/icons"
+        }}
+
+      # files to copy
+      @styles = Array.new
+      @scripts = Array.new
+      @images = Array.new
+      @files = Array.new
+
+      #content
+      @pages = Hash.new
+      @articles = Hash.new
+    end
+
+    def find_all_files
+      file_list = []
+      Adocsite::config[:INPUT_FOLDERS].each {|input_folder|
+        file_list.concat(Dir[File.join(input_folder, "**","*")].reject {|x| File.directory?(x)})
+      }
+      return file_list
+    end
+
+    def load_assets
+      all_files = find_all_files
+
+      @content = all_files.select {|path| path.end_with?(*Adocsite::config[:DOCUMENTS])}
+
+      @styles = all_files.select {|path| path.end_with?(*Adocsite::config[:STYLES])}
+      @scripts = all_files.select {|path| path.end_with?(*Adocsite::config[:SCRIPTS])}
+      @images = all_files.select {|path| path.end_with?(*Adocsite::config[:IMAGES])}
+      @files = all_files - @images - @scripts - @styles - @content
+
+      build_pages_and_articles
+    end
+
+    def build_pages_and_articles
+      @content.each {|path|
+        adoc = Asciidoctor::load_file(path, @adoc_options)
+        if adoc.attributes["page"].nil?
+          article = Article.new(adoc)
+        @articles[article.name] = article
+        else
+          page = Page.new(adoc)
+        @pages[page.name] = page
+        end
+      }
+
+    end
+
+    private :build_pages_and_articles, :find_all_files
+  end
+end

data/lib/adocsite/content_types.rb

@@ -0,0 +1,60 @@
+module Adocsite
+  class Content
+    attr_reader :name, :title
+    def initialize(adoc)
+      @name = Content::title_to_name(adoc.doctitle)
+      @title = adoc.doctitle
+      @content = adoc.content
+    end
+
+    def self.title_to_name(title)
+      title = title.strip
+      title = title.gsub(/[^0-9A-Za-z.\-]/, '_')
+      title = title.gsub(/[_]+/, '_')
+    end
+
+    def stringreturn(title, link_text)
+      link_text = link_text.empty? ? title : link_text
+      '<a href="'+Content::title_to_name(title)+'.html">'+link_text+'</a>'
+    end
+
+    def content()
+      @content = @content.gsub(/sitenav:['"](.*)['"](\[(.*)\])?/) {|sitenav| stringreturn("#$1","#$3")}
+    end
+
+    private :stringreturn
+  end
+
+  class Article < Content
+    UNCATEGORIZED_NAME = 'Uncategorized'
+    attr_reader :categories, :abstract
+    def initialize(adoc)
+      super(adoc)
+      @abstract = ''
+      idx = adoc.blocks.index {|block| block.context==:preamble}
+      if idx
+        @abstract = adoc.blocks[idx].content
+      end
+      @categories = Array.new
+      if adoc.attributes['categories'] != nil
+        @categories = CSV.parse_line(adoc.attributes['categories'].gsub(/,\s+"/,',"'))
+      else
+        @categories << UNCATEGORIZED_NAME
+      end
+      @categories.each_index {|cat_idx|
+        @categories[cat_idx] = @categories[cat_idx].strip
+      }
+    end
+  end
+
+  class Category
+    attr_reader :name, :articles
+    def initialize(name, articles)
+      @name = name
+      @articles = articles
+    end
+  end
+
+  class Page < Content
+  end
+end

data/lib/adocsite/context.rb

@@ -0,0 +1,118 @@
+module Adocsite
+  class Context
+    attr_reader :type
+    def initialize(engine, request)
+      @engine = engine
+      @request = request
+      @type = request.type
+      @context_vars = Hash.new
+
+      build_vars
+    end
+
+    def build_vars()
+      # variables common to all contexts
+      @context_vars = {
+        :page_title => Adocsite::config[:SITE_TITLE],
+      }
+
+      if @type == "home"
+        # @context_vars[] = 'nil'
+        elsif @type == "page"
+          @context_vars[:page] = get_page
+        elsif @type == "article"
+          @context_vars[:article] = get_article
+        elsif @type == "category"
+          @context_vars[:category] = get_category
+        end
+    end
+
+    #--------------------------------------------------
+    # these methods load other templates and render them
+    # in the same context in which current document is rendered
+    def get_partial(partial_name)
+      tpl = @engine.templates.get_partial(partial_name)
+      tpl.render(self, @context_vars)
+    end
+
+    def get_include(include_name)
+      tpl = @engine.templates.get_include(include_name)
+      tpl.render(self, @context_vars)
+    end
+
+    def get_literal(literal_name)
+      @engine.templates.get_literal(literal_name)
+    end
+
+    def get_layout(layout_name = "default")
+      tpl = @engine.templates.get_layout(layout_name)
+      tpl.render(self, @context_vars)
+    end
+    #--------------------------------------------------
+
+    #--------------------------------------------------
+    # these methods behave the same in all contexts
+    # they are context independet
+    def is_context?(context_name)
+      @type == context_name
+    end
+
+    def get_pages()
+      @engine.content_loader.pages.values
+    end
+
+    def get_categories()
+      @engine.categories.values
+    end
+
+    def get_articles(category = nil)
+      if category
+      @engine.categories[category]
+      else
+      @engine.content_loader.articles.values
+      end
+    end
+
+    def sitenav(type, name)
+      request = Request.new(type, name)
+      @engine.sitenav(request)
+    end
+    #--------------------------------------------------
+
+    #--------------------------------------------------
+    # this is special kind of method that is used in layout template.
+    # it gets correct partial for the layout depending on context.
+    def get_content_for_layout()
+      get_partial(@type)
+    # if @type == "home"
+    # get_partial('home')
+    # elsif @type == "page"
+    # get_partial('page')
+    # elsif @type == "article"
+    # get_partial('article')
+    # elsif @type == "category"
+    # get_partial('category')
+    # end
+    end
+    #--------------------------------------------------
+
+    #--------------------------------------------------
+    # result of calling these depends on context in which
+    # they are used, it depends on request that is made
+    def get_article()
+      @engine.content_loader.articles[@request.name]
+    end
+
+    def get_category()
+      @engine.categories[@request.name]
+    end
+
+    def get_page()
+      @engine.content_loader.pages[@request.name]
+    end
+    #--------------------------------------------------
+
+    private :build_vars
+
+  end
+end

data/lib/adocsite/engine.rb

@@ -0,0 +1,147 @@
+module Adocsite
+  class Request
+    attr_reader :type, :name
+    def initialize(type = 'home', name = 'index')
+      @type = type
+      @name = name
+    end
+  end
+
+  class RequestProcessing
+    attr_accessor :rendered
+    attr_reader :request
+    def initialize(request)
+      @request = request
+      rendered = false
+    end
+  end
+
+  class Engine
+    LINK_DOCUMENT_EXTENSION = '.html'
+    OUTPUT_DOCUMENT_EXTENSION = '.html'
+    LOCATION_PAGE = ''
+    LOCATION_ARTICLE = ''
+    LOCATION_CATEGORY = ''
+    attr_reader :content_loader, :templates, :categories
+    def initialize
+      # Internal stuff
+      @page_context = Array.new
+      @request_processing_queue = Hash.new
+
+      # This is hashmap of Category objects.
+      @categories = Hash.new
+
+      @content_loader = ContentLoader.new
+      @content_loader.load_assets
+
+      @templates = Templates.new
+      @templates.load_assets
+
+      build_categories
+
+      @site = Site.new(self)
+      @site.prepare_output
+      @site.copy_content
+    end
+
+    def build_categories
+      # figure out categories and build hash of (category, articles)
+      @categories = Hash.new
+      @content_loader.articles.values.each {|article|
+        article_title = article.title
+
+        article.categories.each_index {|idx|
+          cat = article.categories[idx]
+          if @categories[cat] == nil
+            @categories[cat] = Category.new(cat, [article])
+          else
+          @categories[cat].articles.push(article)
+          end
+        }
+      }
+    end
+
+    def request_process_key(request)
+      request.type + ':' + request.name
+    end
+
+    def add_to_processing_queue(request)
+      # Add request into processing queue if it is not already there
+      rp_key = request_process_key(request)
+      if @request_processing_queue[rp_key] == nil
+        @request_processing_queue[rp_key] = RequestProcessing.new(request)
+      end
+      return rp_key
+    end
+
+    def get_next_from_processing_queue
+      if @request_processing_queue.empty?
+        nil
+      else
+      # Find first element that is not yet processed
+        idx = @request_processing_queue.values.index {|request_processing| !request_processing.rendered}
+        if idx
+        @request_processing_queue.values[idx]
+        else
+          nil
+        end
+      end
+    end
+
+    def process_requests(layout)
+      # Get request from queue
+
+      # request_processing = get_next_from_processing_queue
+
+      while request_processing = get_next_from_processing_queue
+        a_request = request_processing.request
+        puts "Processing - '" + a_request.name + "'..."
+        # Process request, which means render and save output
+        context = Context.new(self, a_request)
+
+        # this converts request into html page
+        # all the heavy lifting is hidden behind this call
+        output = context.get_layout(layout)
+        # save it, nah?
+        @site.write(output, a_request.name + OUTPUT_DOCUMENT_EXTENSION)
+
+        # Mark this one as done
+        request_processing.rendered = true
+      end
+    end
+
+    def build(layout = "default")
+      home = Request.new
+      add_to_processing_queue(home)
+      process_requests(layout)
+    end
+
+    def sitenav(request)
+      # remember to actually generate this document later
+      add_to_processing_queue(request)
+
+      # now just create link text and return it to caller
+      site_root = Adocsite::config[:SITE_URL]
+      if request.type == "home"
+        path = '/'
+      elsif request.type == "page"
+        path = LOCATION_PAGE + request.name + LINK_DOCUMENT_EXTENSION
+      elsif request.type == "article"
+        path = LOCATION_ARTICLE + request.name + LINK_DOCUMENT_EXTENSION
+      elsif request.type == "category"
+        path = LOCATION_CATEGORY + request.name + LINK_DOCUMENT_EXTENSION
+      else
+        path = ''
+      end
+      if site_root.empty?
+      path
+      else
+        URI::HTTP.build({:host => site_root, :path => path})
+      end
+    end
+
+    private :build_categories, :request_process_key, :process_requests, :add_to_processing_queue
+
+  end
+
+end

data/lib/adocsite/site.rb

@@ -0,0 +1,49 @@
+module Adocsite
+  class Site
+    attr_reader :styles, :scripts, :images, :files
+    def initialize(engine)
+      # Internal
+      @engine = engine
+      
+      # files to copy
+      @styles = Array.new
+      @scripts = Array.new
+      @images = Array.new
+      @files = Array.new
+    end
+    
+    def prepare_output
+      output_folder = File.join(Adocsite::config[:OUTPUT_FOLDER])
+      Dir.mkdir(output_folder) unless Dir.exists?(output_folder)
+      FileUtils.rm_rf(Dir.glob(File.join(output_folder,'*')))
+    end
+
+    def write(content, name)
+      f = File.new(File.join(Adocsite::config[:OUTPUT_FOLDER], name), "w")
+      f.write(content)
+      f.close()
+    end
+
+    def copy_content
+      styles_folder = File.join(Adocsite::config[:OUTPUT_FOLDER], Adocsite::config[:STYLES_FOLDER])
+      images_folder = File.join(Adocsite::config[:OUTPUT_FOLDER], Adocsite::config[:IMAGES_FOLDER])
+      scripts_folder = File.join(Adocsite::config[:OUTPUT_FOLDER], Adocsite::config[:SCRIPTS_FOLDER])
+      files_folder = File.join(Adocsite::config[:OUTPUT_FOLDER])
+
+      Dir.mkdir(files_folder) unless Dir.exists?(files_folder)
+      Dir.mkdir(styles_folder) unless Dir.exists?(styles_folder)
+      Dir.mkdir(scripts_folder) unless Dir.exists?(scripts_folder)
+      Dir.mkdir(images_folder) unless Dir.exists?(images_folder)
+
+      FileUtils.copy(@engine.content_loader.styles, styles_folder)
+      FileUtils.copy(@engine.content_loader.scripts, scripts_folder)
+      FileUtils.copy(@engine.content_loader.images, images_folder)
+      FileUtils.copy(@engine.content_loader.files, files_folder)
+
+      FileUtils.copy(@engine.templates.styles, styles_folder)
+      FileUtils.copy(@engine.templates.scripts, scripts_folder)
+      FileUtils.copy(@engine.templates.images, images_folder)
+      FileUtils.copy(@engine.templates.files, files_folder)
+    end
+  end
+end

data/lib/adocsite/templates.rb

@@ -0,0 +1,91 @@
+module Adocsite
+  class Templates
+    attr_reader :styles, :scripts, :images, :files, :layouts, :partials, :includes, :literals
+    def initialize
+      @options = {:remove_whitespace => true}
+      # files to copy
+      @styles = Array.new
+      @scripts = Array.new
+      @images = Array.new
+      @files = Array.new
+
+      # theme template files
+      # hashmap keys are template names without .haml extension and values are full paths
+      # literal names are full file names (without path portion) and values are full paths
+      @layouts = Hash.new
+      @partials = Hash.new
+      @includes = Hash.new
+      @literals = Hash.new
+    end
+
+    def find_all_files
+      Dir[File.join(Adocsite::config[:TEMPLATES_FOLDER], "**","*")].reject {|x| File.directory?(x)}
+    end
+
+    def load_assets
+      all_files = find_all_files
+
+      templates = all_files.select {|path| path.end_with?(*Adocsite::config[:TEMPLATES])}
+
+      @styles = all_files.select {|path| path.end_with?(*Adocsite::config[:STYLES])}
+      @scripts = all_files.select {|path| path.end_with?(*Adocsite::config[:SCRIPTS])}
+      @images = all_files.select {|path| path.end_with?(*Adocsite::config[:IMAGES])}
+      @files = all_files - @images - @scripts - @styles - templates
+
+      # loads layouts, partials, includes and literals into hashmaps.
+      # hashmap keys are template names without .haml extension and values are full paths
+      # literal names are full file names (without path portion) and values are full paths
+      theme_location = File.join(Adocsite::config[:TEMPLATES_FOLDER], Adocsite::config[:THEME])
+      layouts = templates.select {|path| path.start_with?(File.join(theme_location, "layouts")) }
+      layouts.each {|layout|
+        layout_name = File.basename(layout, '.*')
+        @layouts[layout_name] = layout
+      }
+      partials = templates.select {|path| path.start_with?(File.join(theme_location, "partials")) }
+      partials.each {|partial|
+        partial_name = File.basename(partial, '.*')
+        @partials[partial_name] = partial
+      }
+      includes = templates.select {|path| path.start_with?(File.join(theme_location, "includes")) }
+      includes.each {|include|
+        include_name = File.basename(include, '.*')
+        @includes[include_name] = include
+      }
+      literals = @files.select {|path| path.start_with?(File.join(theme_location, "literals")) }
+      literals.each {|literal|
+        literal_name = File.basename(literal)
+        @literals[literal_name] = literal
+      }
+      @files = @files - literals
+      all_files
+    end
+
+    def get_partial(partial_name)
+      partial_tpl = @partials[partial_name]
+      tpl = Tilt.new(partial_tpl, @options)
+      return tpl
+    end
+
+    def get_include(include_name)
+      include_tpl = @includes[include_name]
+      tpl = Tilt.new(include_tpl, @options)
+      return tpl
+    end
+
+    def get_literal(literal_name)
+      literal_tpl = @literals[literal_name]
+      # literals are not processed, they are literals
+      tpl = File.read(literal_tpl)
+      return tpl
+    end
+
+    def get_layout(layout_name = "default")
+      layout_tpl = @layouts[layout_name]
+      tpl = Tilt.new(layout_tpl, @options)
+      return tpl
+    end
+
+    private :find_all_files
+
+  end
+end