markdown_record 0.1.3 → 0.1.4

data/app/models/markdown_record/tests/other_child_model.rb

@@ -1,15 +0,0 @@
-module MarkdownRecord
-  module Tests
-    class OtherChildModel < ::MarkdownRecord::Base
-      attribute :string_field
-      attribute :int_field
-      attribute :float_field
-      attribute :bool_field
-      attribute :date_field
-      attribute :maybe_field
-      attribute :hash_field
-      
-      belongs_to_content :model
-    end
-  end
-end

data/lib/markdown_record/cli.rb

@@ -1,54 +0,0 @@
-require 'thor'
-
-module MarkdownRecord
-  
-  class Cli < Thor
-    include ::Thor::Actions
-    
-    source_root File.expand_path("../../spec/dummy", __dir__)
-
-    desc "install", "installs rendered comparison files for specs"
-    def install
-      # Install the gem in the dummy app
-      system "cd spec/dummy && rails g markdown_record"
-
-      # Run render_content thor task to generate content and save it
-      system "cd spec/dummy && thor render_content:all -s"
-
-      # Copy the generated content to the spec folder for the specs to use
-      copy_file "markdown_record/rendered/content/part_1/chapter_1/content.html", "spec/rendered/chapter_1/content.html"
-      copy_file "markdown_record/rendered/content/part_1/chapter_1/content.json", "spec/rendered/chapter_1/content.json"
-      copy_file "markdown_record/rendered/content/part_1/chapter_1/content_fragments.json", "spec/rendered/chapter_1/content_fragments.json"
-
-      copy_file "markdown_record/rendered/content/part_1/chapter_2/content.html", "spec/rendered/chapter_2/content.html"
-      copy_file "markdown_record/rendered/content/part_1/chapter_2/content.json", "spec/rendered/chapter_2/content.json"
-      copy_file "markdown_record/rendered/content/part_1/chapter_2/content_fragments.json", "spec/rendered/chapter_2/content_fragments.json"
-
-      copy_file "markdown_record/rendered/content.html", "spec/rendered/concatenated/content.html"
-      copy_file "markdown_record/rendered/content.json", "spec/rendered/concatenated/content.json"
-      copy_file "markdown_record/rendered/content_fragments.json", "spec/rendered/concatenated/content_fragments.json"
-
-      # Run render content again with a custom layout
-      system "cd spec/dummy && thor render_content:all -s -l \"_custom_layout.html.erb\" -r full"
-
-      # Copy the new files to the spec directory
-      copy_file "markdown_record/rendered/content.html", "spec/rendered/custom_layout/content.html"
-      copy_file "markdown_record/rendered/content/part_1/chapter_1/content.html", "spec/rendered/custom_layout/chapter_1/content.html"
-      
-      # Run render content again with a custom layout
-      system "cd spec/dummy && thor render_file:json -s -f part_1/chapter_1/content.md"
-      copy_file "markdown_record/rendered/content/part_1/chapter_1/content.json", "spec/rendered/chapter_1/no_frag_content.json"
-
-      # Remove generated content and installed files
-      FileUtils.remove_dir("spec/dummy/markdown_record/rendered", true)
-      FileUtils.remove_dir("spec/dummy/markdown_record/content", true)
-      FileUtils.remove_entry("spec/dummy/markdown_record/layouts/_concatenated_layout.html.erb", true)
-      FileUtils.remove_entry("spec/dummy/markdown_record/layouts/_file_layout.html.erb", true)
-      FileUtils.remove_entry("spec/dummy/lib/tasks/render_content.thor", true)
-      FileUtils.remove_entry("spec/dummy/lib/tasks/render_file.thor", true)
-      FileUtils.remove_entry("spec/dummy/config/initializers/markdown_record.rb", true)
-      FileUtils.remove_entry("spec/dummy/Thorfile", true)
-      gsub_file "spec/dummy/config/routes.rb", "\n  mount MarkdownRecord::Engine, at: MarkdownRecord.config.mount_path, as: \"markdown_record\"", ""
-    end
-  end
-end

data/lib/markdown_record/content_dsl/attribute.rb

@@ -1,22 +0,0 @@
-module MarkdownRecord
-  module ContentDsl
-    module Attribute
-      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*attribute\s*:\s*(\w+)\s*(?::((?:html|md|int|float|string)?))?-->(?!`|\\n`)/
-      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*attribute\s*:\s*(\w+)\s*(?::((?:html|md|int|float|string)?))?--&gt;(?!<\/code>)/
-
-      def attribute_dsl(text)
-        match = text.match(REGEX)
-
-        if match
-          [match[1].strip, match[2]&.strip]
-        else
-          nil
-        end
-      end
-
-      def self.remove_dsl(text)
-        text.gsub(ENCODED_REGEX, "")
-      end
-    end
-  end
-end

data/lib/markdown_record/content_dsl/model.rb

@@ -1,23 +0,0 @@
-module MarkdownRecord
-  module ContentDsl
-    module Model
-      TEMP = /<!--\s*model\s*({[\s"'\\\w:,.\[\]\{\}_\/]*})\s*-->/
-      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*model\s*({[\s"'\\\w:,.\[\]\{\}_\/]*})\s*-->(?!`|\\n`)/
-      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*model\s*({[\s"'\\\w:,.\[\]\{\}_\/]*})\s*--&gt;(?!<\/code>)/
-
-      def model_dsl(text)
-        match = text.match(REGEX)
-
-        if match  
-          JSON.parse(match[1])
-        else
-          nil
-        end
-      end
-
-      def self.remove_dsl(text)
-        text.gsub(ENCODED_REGEX, "")
-      end
-    end
-  end
-end

data/lib/markdown_record/content_dsl/render_format.rb

@@ -1,22 +0,0 @@
-module MarkdownRecord
-  module ContentDsl
-    module RenderFormat
-      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*render_format\s*:\s*(.*)\s*-->(?!`|\\n`)/
-      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*render_format\s*:\s*(.*)\s*--&gt;(?!<\/code>)/
-
-      def render_format_dsl(text)
-        match = text.match(REGEX)
-
-        if match
-          match[1].strip
-        else
-          nil
-        end
-      end
-
-      def self.remove_dsl(text)
-        text.gsub(ENCODED_REGEX, "")
-      end
-    end
-  end
-end

data/lib/markdown_record/content_dsl/render_strategy.rb

@@ -1,22 +0,0 @@
-module MarkdownRecord
-  module ContentDsl
-    module RenderStrategy
-      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*render_strategy\s*:\s*(.*)\s*-->(?!`|\\n`)/
-      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*render_strategy\s*:\s*(.*)\s*--&gt;(?!<\/code>)/
-
-      def render_strategy_dsl(text)
-        match = text.match(REGEX)
-
-        if match
-          match[1].strip
-        else
-          nil
-        end
-      end
-
-      def self.remove_dsl(text)
-        text.gsub(ENCODED_REGEX, "")
-      end
-    end
-  end
-end

data/lib/markdown_record/content_dsl.rb

@@ -1,37 +0,0 @@
-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/html_renderer.rb

@@ -1,194 +0,0 @@
-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/json_renderer.rb

@@ -1,270 +0,0 @@
-require "redcarpet"
-require "redcarpet/render_strip"
-
-module MarkdownRecord
-  class JsonRenderer
-    include ::MarkdownRecord::PathUtilities
-    include ::MarkdownRecord::ContentDsl
-
-    def initialize(file_saver: ::MarkdownRecord::FileSaver.new)
-      @indexer = MarkdownRecord::Indexer.new
-      @json_models = {}
-      @described_models = []
-      @file_saver = file_saver
-    end
-
-    def render_models_for_subdirectory(subdirectory: "", **options)
-      @directory_meta = {}
-      content = @indexer.index(subdirectory: subdirectory)
-
-      rendered_subdirectory = base_content_path.join(subdirectory)
-      json_hash, _ = render_models_recursively(content, rendered_subdirectory, options)
-
-      save_content_recursively(json_hash, options, Pathname.new(""))
-      json_hash
-    end
-
-    def render_models_for_file(file_path:, **options)
-      file = @indexer.file(file_path)
-      
-      # render json models
-      json = render_models(file, file_path, options)
-      
-      # save json
-      @file_saver.save_to_file(json.to_json, "#{clean_path(file_path)}.json", options)
-      
-      json
-    end
-
-  private
-
-    def render_models_recursively(file_or_directory, full_path, options)
-      case file_or_directory.class.name;
-      when Hash.name # if it is a directory
-        directory_hash, concat_hash = *render_nested_models(file_or_directory, full_path, options)
-
-        # concatenate child hashes if :concat = true
-        if options[:concat]
-          concatenate_nested_models(full_path, directory_hash, concat_hash, options)
-        end
-
-        [directory_hash, concat_hash]
-      when String.name # if it is a file
-        content = render_models(file_or_directory, full_path, options)
-
-        if options[:deep] && options[:render_content_fragment_json]
-          add_content_fragment_for_file(content, full_path, false, @fragment_meta)
-        end
-
-        content_hash = { full_path.basename.to_s => content }
-        result = [{}, {}]
-        result[0] = content_hash if options[:deep]
-        result[1] = content_hash if options[:concat]
-        result
-      end
-    end
-
-    def render_nested_models(file_or_directory, full_path, options)
-      directory_hash = { full_path.basename.to_s => {} } # hash representing the directory and its contents
-      concat_hash = { full_path.basename.to_s => {} }
-      # iterate through directory contents
-      file_or_directory.each do |child_file_or_directory_name, child_file_or_directory|
-        
-        # get full path for next recursion
-        child_full_path = full_path.join(child_file_or_directory_name)
-        # get response from next recursion
-        child_content_hash, child_concat_hash = render_models_recursively(
-                                                  child_file_or_directory, 
-                                                  child_full_path, 
-                                                  options
-                                                )
-        # merge response hashes                                                  
-        concat_hash[full_path.basename.to_s].merge!(child_concat_hash)
-        directory_hash[full_path.basename.to_s].merge!(child_content_hash)
-      end
-
-      [directory_hash, concat_hash]
-    end
-
-    def concatenate_nested_models(full_path, directory_hash, concat_hash, options)
-      concatenated_json = {}
-      concatenate_json_recursively(concat_hash, concatenated_json)
- 
-      # add content fragments if render_content_fragment_json = true
-      if options[:render_content_fragment_json]
-        filename, subdirectory = full_path_to_parts(full_path)
-        directory_meta = @directory_meta[clean_path("#{subdirectory}/#{filename}")] || {}
-
-        add_content_fragment_for_file(concat_hash[full_path.basename.to_s], full_path, true, directory_meta)
-        add_content_fragment_for_file(concatenated_json, full_path, true, directory_meta)
-      end
-
-      directory_hash["#{full_path.basename.to_s}.concat"] = concatenated_json
-    end
-
-    def render_models(content, full_path, options)
-      
-      filename, subdirectory = full_path_to_parts(full_path)
-
-      @described_models = []
-      @json_models = {}
-      @fragment_meta = {}
-      enabled = true
-
-      content.split(HTML_COMMENT_REGEX).each do |text|
-        dsl_command = HTML_COMMENT_REGEX =~ text
-
-        if dsl_command 
-          enabled = false if disable_dsl(text)
-          enabled = true if enable_dsl(text)
-        end
-
-        if dsl_command && enabled
-          extract_model(text, filename, subdirectory)
-          extract_fragment_meta(text, subdirectory)
-          extract_attribute(text)
-          pop_attribute(text)
-          pop_model(text)
-        else
-          append_to_attribute(text) 
-        end
-      end
-
-      @described_models.each do |model|
-        finalize_attribute(model)
-      end
-
-      @json_models.dup
-    end
-
-    def add_content_fragment_for_file(json, full_path, concatenated, meta)
-      content_fragment = fragment_attributes_from_path(full_path).merge("meta" => meta, "concatenated" => concatenated)
-
-      json["markdown_record/content_fragment"] ||= []
-      json["markdown_record/content_fragment"] << content_fragment
-    end
-
-    def concatenate_json_recursively(directory_hash, concatenated_json)
-      directory_hash.each do |key, value|
-        case value.class.name
-        when Hash.name
-          concatenate_json_recursively(value, concatenated_json)
-        when Array.name
-          concatenated_json[key] ||= []
-          concatenated_json[key] += value
-        end
-      end
-    end
-
-    def save_content_recursively(content, options, rendered_subdirectory)
-      if content&.values&.first.is_a?(Array)
-        fragments = content.slice("markdown_record/content_fragment")
-        non_fragments = content.except("markdown_record/content_fragment")
-        path = clean_path(rendered_subdirectory.to_s)
-        @file_saver.save_to_file(non_fragments.to_json, "#{path}.json", options)
-        @file_saver.save_to_file(fragments.to_json, "#{path}.json", options, true)
-      else
-        content.each do |key, value|
-          child_path = rendered_subdirectory.join(key)
-          save_content_recursively(value, options, child_path)
-        end
-      end
-    end
-
-    def extract_model(html, filename, subdirectory)
-      model = model_dsl(html)
-
-      if model
-        return unless model["type"].present?
-
-        model["subdirectory"] = clean_path(subdirectory)
-        model["filename"] = clean_path(filename)
-
-        # reset "type" to not have a prefix, in order to ensure
-        # consistent results between the internal only :klass filter
-        # which is used as an index in a hash (and has the prefix removed 
-        # for consistency and deterministic behavior)
-        # and the externally filterable :type field.
-        model["type"] = model["type"].delete_prefix("::").strip
-        
-        @json_models[model["type"]] ||= []
-        @json_models[model["type"]] << model
-  
-        @described_models.push(model)
-      end
-    end
-
-    def extract_fragment_meta(html, subdirectory)
-      meta = fragment_dsl(html)
-
-      if meta
-        @fragment_meta = meta
-      end
-
-      directory_meta = directory_fragment_dsl(html)
-
-      if directory_meta
-        @directory_meta[subdirectory] = directory_meta
-      end
-    end
-
-    def extract_attribute(text)
-      attribute, type = attribute_dsl(text)
-      type ||= "md"
-
-      if @described_models.last && attribute
-        model = @described_models.last
-        model[:described_attribute_type] = type
-        model[:described_attribute] = attribute
-        model[model[:described_attribute]] = []
-      end
-    end
-
-    def append_to_attribute(text)
-      return if text.match(HTML_COMMENT_REGEX)
-
-      @described_models.each do |model|
-        next unless model[:described_attribute].present?
-
-        model[model[:described_attribute]] ||= []
-        model[model[:described_attribute]] << text
-      end
-    end
-
-    def pop_attribute(text)
-      if @described_models.last && end_attribute_dsl(text)
-        finalize_attribute(@described_models.last)
-      end
-    end
-
-    def pop_model(html)      
-      if end_model_dsl(html)
-        @described_models.pop
-      end
-    end
-
-    def finalize_attribute(model)
-      return if model[:described_attribute].nil?
-
-      attribute_name = model.delete(:described_attribute)
-      attribute = model[attribute_name].join("\n")
-      type = model.delete(:described_attribute_type)
-
-      case type
-      when "html"
-        renderer = Redcarpet::Render::HTML.new
-        attribute = Redcarpet::Markdown.new(renderer).render(attribute)
-      when "md"
-        attribute = attribute.strip
-      when "int"
-        attribute = attribute.strip.gsub("\n", "").to_i
-      when "float"
-        attribute = attribute.strip.gsub("\n", "").to_f
-      when "string"
-        attribute = Redcarpet::Markdown.new(::Redcarpet::Render::StripDown).render(attribute).strip
-      end
-
-      model[attribute_name] = attribute
-    end
-  end
-end