markdown_record 0.1.3

data/lib/markdown_record/content_dsl.rb

@@ -0,0 +1,37 @@
+require "markdown_record/content_dsl/model"
+require "markdown_record/content_dsl/attribute"
+require "markdown_record/content_dsl/end_attribute"
+require "markdown_record/content_dsl/end_model"
+require "markdown_record/content_dsl/fragment"
+require "markdown_record/content_dsl/directory_fragment"
+require "markdown_record/content_dsl/use_layout"
+require "markdown_record/content_dsl/disable"
+require "markdown_record/content_dsl/enable"
+
+module MarkdownRecord
+  module ContentDsl
+    include Model
+    include Attribute
+    include EndAttribute
+    include EndModel
+    include DirectoryFragment
+    include Fragment
+    include UseLayout
+    include Disable
+    include Enable
+
+    HTML_COMMENT_REGEX = /(<!--(?:(?:\s|.)(?!-->))*(?:.|\s)-->)/
+
+    def remove_dsl(text)
+      text = Model.remove_dsl(text)
+      text = Attribute.remove_dsl(text)
+      text = EndAttribute.remove_dsl(text)
+      text = EndModel.remove_dsl(text)
+      text = Fragment.remove_dsl(text)
+      text = UseLayout.remove_dsl(text)
+      text = Disable.remove_dsl(text)
+      text = Enable.remove_dsl(text)
+      text
+    end
+  end
+end

data/lib/markdown_record/content_fragment.rb

@@ -0,0 +1,123 @@
+module MarkdownRecord
+  class ContentFragment < MarkdownRecord::Base
+    include MarkdownRecord::PathUtilities
+
+    attribute :meta, :type => Object
+    attribute :concatenated, :type => Boolean
+
+    def initialize(attributes = nil, options = {})
+      super
+
+      if self.meta.class == Hash
+        self.meta = self.meta.with_indifferent_access
+      end
+    end
+
+    # Override the new_association method on MarkdownRecord::Base
+    # to force all association queries to only look for fragments
+    def self.new_association(base_filters = {}, search_filters = {})
+      MarkdownRecord::Association.new(base_filters, search_filters).fragmentize
+    end
+
+    def fragment_id
+      id
+    end
+
+    def name
+      meta[:name]
+    end
+
+    def exists?
+      json_exists? || html_exists?
+    end
+
+    def json_exists?
+      Pathname.new(json_path).exist?
+    end
+
+    def html_exists?
+      Pathname.new(html_path).exist?
+    end
+
+    def read_json
+      File.read(json_path) if json_exists?
+    end
+
+    def read_html
+      File.read(html_path) if html_exists?
+    end
+
+    def json_path
+      path("json")
+    end
+
+    def json_route
+      route("json", id)
+    end
+
+    def html_path
+      path("html")
+    end
+
+    def html_route
+      route("html", id)
+    end
+
+    # Associations
+    def ancestors
+      ancestors_from(::MarkdownRecord.config.content_root.basename.to_s)
+    end
+
+    def parent
+      self.class.find(meta[:parent_id] || subdirectory)
+    end
+
+    def ancestors_from(ancestor)
+      ancestor = self.class.find(ancestor) if ancestor.is_a?(String)
+      
+      parents = []
+      current_parent = self.class.find(subdirectory)
+
+      while current_parent
+        if current_parent.id == ancestor.id
+          parents.unshift(current_parent)
+          current_parent = nil
+        else
+          parents.unshift(current_parent)
+          current_parent = self.class.find(current_parent.subdirectory)
+        end
+      end
+
+      parents
+    end
+
+    def parents_from(ancestor)
+      ancestor = self.class.find(ancestor) if ancestor.is_a?(String)
+
+      parents = []
+      current_parent = self
+
+      while current_parent
+        if current_parent.id == ancestor&.id
+          parents.unshift(current_parent)
+          current_parent = nil
+        else
+          parents.unshift(current_parent)
+          current_parent = current_parent.parent
+        end
+      end
+
+      parents
+    end
+
+  private
+
+    def path(ext)
+      "#{::MarkdownRecord.config.rendered_content_root.join(id).to_s}.#{ext}"
+    end
+
+    def route(ext, path)
+      "#{ext}/#{path}"
+    end
+  end
+end

data/lib/markdown_record/engine.rb

@@ -0,0 +1,13 @@
+module MarkdownRecord
+  class Engine < ::Rails::Engine
+    isolate_namespace MarkdownRecord
+
+    initializer "markdown_record.view_helpers" do
+      ActiveSupport.on_load(:action_view) { include MarkdownRecord::ViewHelpers }
+    end
+
+    initializer 'markdown_record.controller_helpers' do
+      ActiveSupport.on_load(:action_controller) { include ::MarkdownRecord::ControllerHelpers }
+    end
+  end
+end

data/lib/markdown_record/errors/base.rb

@@ -0,0 +1,6 @@
+module MarkdownRecord
+  module Errors
+    class Base < StandardError
+    end
+  end
+end

data/lib/markdown_record/errors/duplicate_filename_error.rb

@@ -0,0 +1,21 @@
+require "markdown_record/errors/base"
+
+module MarkdownRecord
+  module Errors
+    class DuplicateFilenameError < MarkdownRecord::Errors::Base
+      def initialize(filenames)
+        msgs = []
+
+        filenames.each do |f|
+          if MarkdownRecord.config.ignore_numeric_prefix
+            msgs << "There are multiple files that resolve to [#{f}] after numeric prefixes are ignored."
+          else
+            msgs << "There are multiple files that resolve to [#{f}]."
+          end
+        end
+
+        super(msgs.join("\n"))
+      end
+    end
+  end
+end

data/lib/markdown_record/errors/duplicate_id_error.rb

@@ -0,0 +1,11 @@
+require "markdown_record/errors/base"
+
+module MarkdownRecord
+  module Errors
+    class DuplicateIdError < MarkdownRecord::Errors::Base
+      def initialize(type, id)
+        super("There are multiple models of type #{type} with id: #{id}.")
+      end
+    end
+  end
+end

data/lib/markdown_record/errors/missing_parent_error.rb

@@ -0,0 +1,11 @@
+require "markdown_record/errors/base"
+
+module MarkdownRecord
+  module Errors
+    class MissingParentError < MarkdownRecord::Errors::Base
+      def initialize(parent_id)
+        super("No content fragment matched parent_id: #{parent_id}.")
+      end
+    end
+  end
+end

data/lib/markdown_record/file_saver.rb

@@ -0,0 +1,39 @@
+module MarkdownRecord
+  class FileSaver
+    include ::MarkdownRecord::PathUtilities
+
+    attr_accessor :saved_files
+
+    def initialize
+      @saved_files = {:html => [], :json => []}
+    end
+
+    def save_to_file(content, rendered_subdirectory, options, fragments = false)
+      filename, subdirectory, extension = full_path_to_parts(rendered_subdirectory)
+      filename = file_name(filename, extension, fragments)
+
+      save_path = ::MarkdownRecord.config.rendered_content_root.join(subdirectory).join(filename)
+      relative_path = save_path.to_s.gsub(Rails.root.to_s, "")
+
+      @saved_files[extension.to_sym].unshift(relative_path)
+
+      if options[:save]
+        save_path.dirname.mkpath
+
+        save_path.open('wb') do |file|
+          file << content
+        end
+      end
+    end
+
+    def base_content_name
+      ::MarkdownRecord.config.content_root.basename
+    end
+
+    def file_name(subdirectory, extension, fragments)
+      base_name = ::MarkdownRecord.config.content_root.join(subdirectory).basename.to_s
+      base_name += "_fragments" if fragments
+      "#{base_name}.#{extension}"
+    end
+  end
+end

data/lib/markdown_record/html_renderer.rb

@@ -0,0 +1,194 @@
+require "redcarpet"
+require "htmlbeautifier"
+
+module MarkdownRecord
+  class HtmlRenderer < ::Redcarpet::Render::HTML
+    include ::MarkdownRecord::PathUtilities
+    include ::MarkdownRecord::ContentDsl
+
+    HTML_SUBSTITUTIONS = {
+      /<!---/ => "<!--",
+      /&lt;!---/ => "&lt;!--"
+    }
+
+    def initialize(
+        file_saver: ::MarkdownRecord::FileSaver.new)
+      super(::MarkdownRecord.config.html_render_options)
+      @indexer = ::MarkdownRecord::Indexer.new
+      @markdown = ::Redcarpet::Markdown.new(self, ::MarkdownRecord.config.markdown_extensions)
+      @file_saver = file_saver
+    end
+
+    def render_html_for_subdirectory(subdirectory: "", **options)
+      content = @indexer.index(subdirectory: subdirectory)
+      rendered_subdirectory = base_content_path.join(subdirectory)
+
+      html_content = render_html_recursively(content, rendered_subdirectory.to_s)
+      processed_html = process_html_recursively(html_content[rendered_subdirectory.to_s], rendered_subdirectory, options)
+      final_html = finalize_html_recursively(processed_html, rendered_subdirectory)
+
+      save_content_recursively(final_html, options, rendered_subdirectory)
+      { :html_content => processed_html, :saved_files => @file_saver.saved_files }
+      nil
+    end
+
+  private
+
+    def render_html_recursively(file_or_directory, file_or_directory_name)
+      case file_or_directory.class.name
+      when Hash.name # if it is a directory
+        directory_hash = { file_or_directory_name => {} } # hash representing the directory and its contents
+
+        file_or_directory.each do |child_file_or_directory_name, child_file_or_directory|
+          child_content_hash = render_html_recursively(child_file_or_directory, child_file_or_directory_name)
+          directory_hash[file_or_directory_name].merge!(child_content_hash)
+        end
+
+        directory_hash
+      when String.name # if it is a file
+        { file_or_directory_name => render_html(file_or_directory) }
+      end
+    end
+
+    def render_html(html)
+      rendered_html = @markdown.render(html)
+      remove_dsl(rendered_html) 
+    end
+
+    def process_html_recursively(file_or_directory, full_path, options)
+      case file_or_directory.class.name
+      when Hash.name
+        directory_hash = { full_path.to_s => {} } # hash representing the directory and its contents
+
+        file_or_directory.each do |child_file_or_directory_name, child_file_or_directory|
+          child_content_hash = process_html_recursively(child_file_or_directory, full_path.join(child_file_or_directory_name), options)
+          directory_hash[full_path.to_s].merge!(child_content_hash)
+        end
+
+        if options[:concat]
+          concatenated_html = concatenate_html_recursively(directory_hash[full_path.to_s], []).join("\r\n")
+          directory_hash["#{full_path.to_s}.concat"] = process_html(concatenated_html, full_path.to_s, concatenated_layout)
+        end
+
+        directory_hash.compact
+      when String.name # if it is a file
+        if options[:deep]
+          { full_path.to_s => process_html(file_or_directory, full_path, custom_layout(file_or_directory) || file_layout) }
+        else
+          { }
+        end
+      end
+    end
+
+    def process_html(html, full_path, layout = nil)
+      processed_html = html.gsub(/<p>(\&lt;%(\S|\s)*?%\&gt;)<\/p>/){ CGI.unescapeHTML($1) }
+      processed_html = processed_html.gsub(/(\&lt;%(\S|\s)*?%\&gt;)/){ CGI.unescapeHTML($1) }
+      locals = erb_locals_from_path(full_path.to_s)
+      processed_html = render_erb(processed_html, locals) if full_path.to_s.ends_with?(".md.erb")
+      processed_html = render_erb(layout, locals.merge(html: processed_html)) if layout
+      processed_html
+    end
+
+    def render_erb(html, locals)
+      render_controller = ::MarkdownRecord.config.render_controller || ::ApplicationController
+      rendered_html = render_controller.render(
+        inline: html,
+        locals: locals
+      ).to_str
+      rendered_html
+    end
+
+    def concatenate_html_recursively(content, html)
+      case content.class.name
+      when Hash.name
+        sorted_hash_values(content).each do |v|
+          concatenate_html_recursively(v, html)
+        end
+      when String.name
+        html << content
+      end
+      html
+    end
+
+    def sorted_hash_values(hash)
+      values = []
+      keys = hash.keys.sort_by do |k|
+        basename = k.split("/").last
+        m = basename.match(/^(\d+)_/)
+        m.try(:[], 1).to_i || k
+      end
+
+      keys.each do |k|
+        values << hash[k] if !k.include?(".concat")
+      end
+      values
+    end
+
+    def custom_layout(html)
+      layout = use_layout_dsl(html)
+      return unless layout
+
+      File.read(::MarkdownRecord.config.layout_directory.join(layout))
+    end
+
+    def global_layout
+      global_layout_path = ::MarkdownRecord.config.global_layout_path
+      @global_layout ||= global_layout_path ? layout(global_layout_path) : nil
+    end
+
+    def concatenated_layout
+      concatenated_layout_path = ::MarkdownRecord.config.concatenated_layout_path
+      @concatenated_layout ||= concatenated_layout_path ? layout(concatenated_layout_path) : nil
+    end
+
+    def file_layout
+      file_layout_path = ::MarkdownRecord.config.file_layout_path
+      @file_layout ||= file_layout_path ? layout(file_layout_path) : nil
+    end
+
+    def layout(path)
+      File.read(::MarkdownRecord.config.layout_directory.join(path))
+    end
+
+    def finalize_html_recursively(content, rendered_subdirectory)
+      case content.class.name
+      when Hash.name
+        final_hash = {}
+        content.each do |key, value|
+          child_path = rendered_subdirectory.join(key)
+          final_hash[key] = finalize_html_recursively(value, child_path)
+        end
+        final_hash
+      when String.name
+        finalize_html(content, rendered_subdirectory)
+      end
+    end
+
+    def finalize_html(html, full_path)
+      locals = erb_locals_from_path(full_path)
+      final_html = html
+      final_html = render_erb(global_layout, locals.merge(html: final_html)) if global_layout
+      
+      HTML_SUBSTITUTIONS.each do |find, replace|
+        final_html = final_html.gsub(find, replace)
+      end
+
+      final_html = final_html.squeeze("\n")
+      final_html = HtmlBeautifier.beautify(final_html)
+      final_html
+    end
+
+    def save_content_recursively(content, options, rendered_subdirectory)
+      case content.class.name
+      when Hash.name
+        content.each do |key, value|
+          child_path = rendered_subdirectory.join(key)
+          save_content_recursively(value, options, child_path)
+        end
+      when String.name
+        path = clean_path(rendered_subdirectory.to_s)
+        @file_saver.save_to_file(content, "#{path}.html", options)
+      end
+    end
+  end
+end

data/lib/markdown_record/indexer.rb

@@ -0,0 +1,34 @@
+module MarkdownRecord
+  class Indexer
+
+    def index(subdirectory: "")
+      content_path = ::MarkdownRecord.config.content_root.join(subdirectory)
+      index = {}
+      recursive_index(content_path, index)
+      index
+    end
+
+    def file(path)
+      file_path = ::MarkdownRecord.config.content_root.join(path)
+
+      if Pathname.new(path).extname == ".md" && file_path.exist?
+        File.read(file_path)
+      else
+        nil
+      end
+    end
+
+    def recursive_index(parent_dir_path, index)
+      parent_root = Dir.new(parent_dir_path)
+      parent_root.children.each do |child|
+        pathname = Pathname.new("#{parent_dir_path}/#{child}")
+        if pathname.directory?
+          index[child] = {}
+          recursive_index(pathname, index[child])
+        else
+          index[child] = File.read(pathname) if (pathname.extname == ".md" || pathname.to_s =~ /\.md\.erb$/)
+        end
+      end
+    end
+  end
+end