markdown_record 0.1.3 → 0.1.5

data/lib/markdown_record/rendering/nodes/html_base.rb

@@ -0,0 +1,95 @@
+module MarkdownRecord
+  module Rendering
+    module Nodes
+      class HtmlBase
+        include ::MarkdownRecord::PathUtilities
+        include ::MarkdownRecord::ContentDsl
+
+        attr_reader :name
+        attr_reader :rendered_html
+        attr_reader :processed_html
+
+        HTML_SUBSTITUTIONS = {
+          /<!---/ => "<!--",
+          /&lt;!---/ => "&lt;!--"
+        }
+
+        def initialize(pathname, markdown, options)
+          @markdown = markdown
+          @pathname = pathname
+          @options = options
+          @name = @pathname.relative_path_from(MarkdownRecord.config.content_root.parent).to_s
+          @sorter = MarkdownRecord.config.filename_sorter
+        end
+
+        def render(file_saver)
+          @rendered_html = ""
+          process_html
+          finalize_html
+          save(file_saver)
+        end
+
+        def process_html
+          @processed_html = render_erbs(@rendered_html)
+        end
+
+        def finalize_html
+          return unless @processed_html.present?
+
+          locals = erb_locals_from_path(@name)
+          final_html = remove_html_dsl_command(@processed_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)
+        end
+
+        def save(file_saver)
+          return unless @final_html.present?
+
+          path = clean_path(@name)
+          file_saver.save_to_file(@final_html, "#{path}.html", @options)
+        end
+
+        def render_erbs(html)
+          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(name)
+          processed_html = render_erb(processed_html, locals) if name.ends_with?(".md.erb")
+          processed_html = render_erb(layout, locals.merge(html: processed_html)) if layout
+          processed_html
+        end
+
+        def layout
+          nil
+        end
+
+        def render_erb(html, locals)
+          render_controller = ::MarkdownRecord.config.render_controller || ::ApplicationController
+          rendered_erb = render_controller.render(
+            inline: html,
+            locals: locals
+          ).to_str
+          rendered_erb
+        end
+
+        def global_layout
+          global_layout_path = ::MarkdownRecord.config.global_layout_path
+          @global_layout ||= global_layout_path ? load_layout(global_layout_path) : nil
+        end
+
+        def load_layout(path)
+          File.read(::MarkdownRecord.config.layout_directory.join(path))
+        end
+
+        def sort_value
+          @sorter.path_to_sort_value(@name)
+        end
+      end
+    end
+  end
+end

data/lib/markdown_record/rendering/nodes/html_directory.rb

@@ -0,0 +1,51 @@
+module MarkdownRecord
+  module Rendering
+    module Nodes
+      class HtmlDirectory < MarkdownRecord::Rendering::Nodes::HtmlBase
+
+        def render(file_saver)
+          children.each do |child|
+            child.render(file_saver)
+          end
+
+          concatenate_html
+          process_html
+          finalize_html
+
+          if @options[:concat]
+            save(file_saver) 
+          end
+        end
+
+        def concatenate_html
+          return @rendered_html if @rendered_html.present?
+
+          sorted_children = children.sort_by(&:sort_value)
+          @rendered_html = sorted_children.map(&:concatenated_html).compact.join("\r\n")
+        end
+
+        def concatenated_html
+          @rendered_html
+        end
+
+      private
+
+        def children
+          @children ||= Dir.new(@pathname).children.map do |child|
+            pathname = @pathname.join(child)
+            if pathname.directory?
+              self.class.new(pathname, @markdown, @options)
+            else
+              MarkdownRecord::Rendering::Nodes::HtmlFile.new(pathname, @markdown, @options)
+            end
+          end
+        end
+
+        def layout
+          concatenated_layout_path = ::MarkdownRecord.config.concatenated_layout_path
+          concatenated_layout_path ? load_layout(concatenated_layout_path) : nil
+        end
+      end
+    end
+  end
+end

data/lib/markdown_record/rendering/nodes/html_file.rb

@@ -0,0 +1,48 @@
+module MarkdownRecord
+  module Rendering
+    module Nodes
+      class HtmlFile < MarkdownRecord::Rendering::Nodes::HtmlBase
+
+        def render(file_saver)
+          render_html
+          process_html
+          finalize_html
+
+          if @options[:deep]
+            save(file_saver)
+          end
+        end
+
+        def render_html
+          html = @markdown.render(raw_content)
+          html = remove_json_dsl_commands(html) 
+          @rendered_html = html
+        end
+
+        def raw_content
+          @raw_content ||= File.read(@pathname)
+        end
+
+        def concatenated_html
+          @processed_html
+        end
+
+        def layout
+          @layout ||= custom_layout(@rendered_html) || file_layout
+        end
+
+        def custom_layout(html)
+          cust_layout = use_layout_dsl(html)
+          return nil unless cust_layout
+    
+          load_layout(cust_layout)
+        end
+    
+        def file_layout
+          file_layout_path = ::MarkdownRecord.config.file_layout_path
+          @file_layout ||= file_layout_path ? load_layout(file_layout_path) : nil
+        end
+      end
+    end
+  end
+end

data/lib/markdown_record/rendering/nodes/json_base.rb

@@ -0,0 +1,55 @@
+module MarkdownRecord
+  module Rendering
+    module Nodes
+      class JsonBase
+        include ::MarkdownRecord::PathUtilities
+        include ::MarkdownRecord::ContentDsl
+
+        attr_reader :name
+        attr_reader :json_models
+        attr_reader :concatenated
+        
+        def initialize(pathname, options)
+          @pathname = pathname
+          @options = options
+          @name = @pathname.relative_path_from(MarkdownRecord.config.content_root.parent).to_s
+          @json_models = {}
+          @concatenated = nil
+          @scope = nil
+        end
+
+        def render(file_saver, inherited_scope = nil)
+          # This method defines an interface and should be overridden by a subclass.
+          add_content_fragment
+          save(file_saver)
+        end
+
+        def fragment_meta
+          # This method defines an interface and should be overridden by a subclass.
+          {}
+        end
+
+        def scope
+          @scope
+        end
+
+        def add_content_fragment
+          return unless @options[:render_content_fragment_json]
+
+          content_fragment_hash = fragment_attributes_from_path(name).merge("meta" => fragment_meta, "concatenated" => concatenated, "__scope__" => scope)
+          
+          @json_models["markdown_record/content_fragment"] ||= []
+          @json_models["markdown_record/content_fragment"] << content_fragment_hash
+        end
+
+        def save(file_saver)
+          fragments = @json_models.slice("markdown_record/content_fragment")
+          non_fragments = @json_models.except("markdown_record/content_fragment")
+          path = clean_path(@name)
+          file_saver.save_to_file(non_fragments.to_json, "#{path}.json", @options)
+          file_saver.save_to_file(fragments.to_json, "#{path}.json", @options, true)
+        end        
+      end
+    end
+  end
+end

data/lib/markdown_record/rendering/nodes/json_directory.rb

@@ -0,0 +1,69 @@
+module MarkdownRecord
+  module Rendering
+    module Nodes
+      class JsonDirectory < MarkdownRecord::Rendering::Nodes::JsonBase
+
+        def initialize(pathname, options, top_level = false)
+          super(pathname, options)
+          @concatenated = true
+          @top_level = top_level
+        end
+
+        def render(file_saver, inherited_scope = nil)
+          # Only override scope if this directory
+          # doesn't have its own scope defined
+          # First call to scope will search files
+          # and get the scope if defined.
+          @scope = inherited_scope unless scope
+
+          children.each do |child|
+            child.render(file_saver, scope)
+          end
+
+          concatenate_json
+          save(file_saver) if @options[:concat] || (@options[:concat_top_level] && @top_level)
+        end
+
+        def fragment_meta
+          @fragment_meta ||= children.select {|c| c.respond_to?(:directory_meta) }.reduce({}) { |meta, child| meta.merge(child.directory_meta) }
+        end
+
+        def scope
+          @scope ||= children.select {|c| c.respond_to?(:directory_scope) }.find(&:directory_scope)&.directory_scope
+        end
+
+      private
+
+        def concatenate_json
+          return unless @options[:concat] || (@options[:concat_top_level] && @top_level)
+        
+          children.each do |child|
+            @json_models.merge!(child.json_models) do |key, oldval, newval|
+              oldval + newval
+            end
+          end
+
+          # IMPORTANT: Unattach from children's json_models
+          # This node's json_models may share references
+          # after the merge, so we need to detach them
+          @json_models.keys.each do |k|
+            @json_models[k] = @json_models[k].dup
+          end
+
+          add_content_fragment
+        end
+
+        def children
+          @children ||= Dir.new(@pathname).children.map do |child|
+            pathname = @pathname.join(child)
+            if pathname.directory?
+              self.class.new(pathname, @options)
+            else
+              MarkdownRecord::Rendering::Nodes::JsonFile.new(pathname, @options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markdown_record/rendering/nodes/json_file.rb

@@ -0,0 +1,172 @@
+module MarkdownRecord
+  module Rendering
+    module Nodes
+      class JsonFile < MarkdownRecord::Rendering::Nodes::JsonBase
+
+        def initialize(...)
+          super(...)
+          @concatenated = false
+        end
+
+        def render(file_saver, inherited_scope = nil)
+          @scope ||= inherited_scope
+          render_json
+          apply_scope
+          save(file_saver) if @options[:deep]
+        end
+
+        def fragment_meta
+          @fragment_meta ||= fragment_dsl(raw_content)
+          @fragment_meta ||= {}
+        end
+
+        def scope
+          @scope ||= scope_dsl(raw_content)
+        end
+
+        def directory_scope
+          @directory_scope ||= scope
+        end
+
+        def directory_meta
+          @directory_meta ||= directory_fragment_dsl(raw_content)
+          @directory_meta ||= {}
+        end
+
+      private
+
+        def apply_scope
+          @json_models.each do |klass, array|
+            next if klass == MarkdownRecord::ContentFragment.name.underscore
+            array.each do |model|
+              model["scope"] = scope
+              model["scoped_id"] = to_scoped_id(scope, model["id"])
+            end
+          end
+        end
+        
+        def raw_content
+          @raw_content ||= File.read(@pathname)
+        end
+        
+        def render_json
+          return unless @options[:deep] || @options[:concat_top_level]
+
+          filename, subdirectory = full_path_to_parts(name)
+
+          described_models = []
+          enabled = true
+    
+          raw_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, described_models)
+              extract_attribute(text, described_models)
+              pop_attribute(text,described_models)
+              pop_model(text, described_models)
+            else
+              append_to_attribute(text, described_models) 
+            end
+          end
+    
+          described_models.each do |model|
+            finalize_attribute(model)
+          end
+
+          add_content_fragment if @options[:deep]
+        end
+
+        def extract_model(text, described_models)
+          model = model_dsl(text)
+    
+          if model
+            return unless model["type"].present?
+            return unless model["id"].present?
+
+            filename, subdirectory = full_path_to_parts(name)
+    
+            model["subdirectory"] = subdirectory
+            model["filename"] = 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_attribute(text, described_models)
+          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, described_models)
+          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, described_models)
+          if described_models.last && end_attribute_dsl(text)
+            finalize_attribute(described_models.last)
+          end
+        end
+    
+        def pop_model(text, described_models)      
+          if end_model_dsl(text)
+            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
+  end
+end

data/lib/markdown_record/{rendering.rb → rendering/rendering.rb}

@@ -1,5 +1,5 @@
 module MarkdownRecord
-  module Rendering
+  module RenderingHelpers
     def generate_render_strategy_options(options)
 
       strategy_options = if options[:strat].present?

data/lib/markdown_record/{validator.rb → rendering/validator.rb}

@@ -19,7 +19,7 @@ module MarkdownRecord
 
     def validate_filenames(val)
       if val.is_a?(Hash)
-        temp_keys = val.keys.map { |v| remove_numeric_prefixes(v) }
+        temp_keys = val.keys.map { |v| remove_prefix(v) }
         
         dups = temp_keys.group_by{|e| clean_path(e)}.keep_if{|_, e| e.length > 1}
         if dups.any?
@@ -33,8 +33,8 @@ module MarkdownRecord
     end
 
     def validate_models
-      @json["#{base_content_path.basename}.concat"].each do |klass, array|
-        ids = array.map { |o| o["id"] }
+      @json.each do |klass, array|
+        ids = array.map { |o| [o["id"], o["scope"]] }
         dups = ids.group_by{|e| e}.keep_if{|_, e| e.length > 1}
         if dups.any?
           raise ::MarkdownRecord::Errors::DuplicateIdError.new(klass, dups.keys.first)
@@ -43,7 +43,7 @@ module MarkdownRecord
     end
 
     def validate_fragments
-      frags = @json["#{base_content_path.basename}.concat"]["markdown_record/content_fragment"]
+      frags = @json["markdown_record/content_fragment"]
       frags.each do |frag|
         parent_id = frag.dig("meta", "parent_id")
         if parent_id

data/lib/markdown_record/version.rb

@@ -1,3 +1,3 @@
 module MarkdownRecord
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/lib/markdown_record.rb

@@ -2,20 +2,27 @@ require "markdown_record/version"
 require "markdown_record/engine"
 require "markdown_record/configuration"
 require "markdown_record/path_utilities"
-require "markdown_record/validator"
-require "markdown_record/rendering"
-require "markdown_record/cli"
-require "markdown_record/content_dsl"
-require "markdown_record/indexer"
-require "markdown_record/file_saver"
-require "markdown_record/html_renderer"
-require "markdown_record/json_renderer"
-require "markdown_record/model_inflator"
-require "markdown_record/association"
-require "markdown_record/associations"
-require "markdown_record/content_associations"
-require "markdown_record/base"
-require "markdown_record/content_fragment"
+require "markdown_record/file_sorting/base"
+require "markdown_record/file_sorting/date_sorter"
+require "markdown_record/file_sorting/sem_ver_sorter"
+require "markdown_record/rendering/validator"
+require "markdown_record/rendering/rendering"
+require "markdown_record/rendering/content_dsl"
+require "markdown_record/rendering/indexer"
+require "markdown_record/rendering/file_saver"
+require "markdown_record/rendering/json_renderer"
+require "markdown_record/rendering/html_renderer"
+require "markdown_record/rendering/nodes/json_base"
+require "markdown_record/rendering/nodes/json_file"
+require "markdown_record/rendering/nodes/json_directory"
+require "markdown_record/rendering/nodes/html_base"
+require "markdown_record/rendering/nodes/html_file"
+require "markdown_record/rendering/nodes/html_directory"
+require "markdown_record/models/filtering"
+require "markdown_record/models/model_inflator"
+require "markdown_record/models/association"
+require "markdown_record/models/associations"
+require "markdown_record/models/content_associations"
 
 module MarkdownRecord
   def self.config

data/templates/demo/content/10_custom_models_and_associations.md.erb

@@ -1,5 +1,5 @@
-<!--fragment { "author": "Bryant Morrill", "parent_id": "content/home", "name": "Custom Models and Associations" } -->
-<!---model { "type": "markdown_record/demo/section", "id":   8, "name": "Custom Models and Associations" } -->
+<!--fragment { "author": "Bryant Morrill", "relative_parent_id": "home", "name": "Custom Models and Associations" } -->
+<!--model { "type": "section", "id": 9, "name": "Custom Models and Associations" } -->
 
 # Custom Models and Associations
 
@@ -43,24 +43,44 @@ end
 Once the associations are defined, you will want to make sure your JSON objects in your markdown have the required fields. For the example above, the DslCommand model will automatically be given a `section_id` field that will need to be populated in your markdown like so:
 
 ```html
-<!---model { "type": "markdown_record/demo/dsl_command", "id": 6, "name": "directory_fragment", "section_id": 1 } -->
+<!---model { "type": "dsl_command", "id": 6, "name": "directory_fragment", "section_id": 1 } -->
 ```
 
 Then you can use the association in your code just like ActiveRecord associations:
 
 ```ruby
-MarkdownRecord::Demo::Section.find(3).dsl_commands.all
+Section.find(3).dsl_commands.all
  => 
-[#<MarkdownRecord::Demo::DslCommand section_id: 1, description: "...", ...>, ...]
+[#<DslCommand section_id: 1, description: "...", ...>, ...]
 ```
 
 ```ruby
-MarkdownRecord::Demo::DslCommand.find(1).section
- => #<MarkdownRecord::Demo::Section filename: "content_dsl", id: 3, name: "Content DSL", subdirectory: "content", type: "markdown_record/demo/section">
+DslCommand.find(1).section
+ => #<Section filename: "content_dsl", id: 3, name: "Content DSL", subdirectory: "content", type: "section">
 ```
 
 `has_many_content` will define a method that returns an `MarkdownRecord::Association` object, which you can then chain queries onto. `belongs_to_content`  and `has_one_content` will define methods that returns a single MarkdownContent model.
 
+### Scopes
+
+If a model is defined within a scope (using the `scope` Content DSL command), then all its associations are assumed to be within that scope, and must point to other models that are within that scope.
+
+Furthermore, when querying for models that are defined within a scope without using associations, you will need to provide the scope like so:
+
+```ruby
+DslCommand.find(1, "v_0_1_3")
+ => #<DslCommand description: "model is the main command...", scope: "v_0_1_3", scoped_id: "v_0_1_3:s:1", section_id: 3, subdirectory: "content", type: "dsl_command"> 
+```
+
+Or
+
+```ruby
+DslCommand.where(:section_id => 3, :scope => "v_0_1_3").all
+ => [#<DslCommand >,...]
+````
+
+Association methods do not need the `scope` provided, since they are assumed to be in the same scope as the model instance you call them on.
+
 ### Associations on ActiveRecord Models
 
 You can easily integrate MarkdownRecord and ActiveRecord models together using the `MarkdownRecord::ContentAssociations` module. Just include it in your ActiveRecord model like so:

data/templates/demo/content/11_controller_helpers.md.erb

@@ -1,5 +1,5 @@
-<!--fragment { "author": "Bryant Morrill", "parent_id": "content/home", "name": "Controller Helpers" } -->
-<!---model { "type": "markdown_record/demo/section", "id":   9, "name": "Controller Helpers" } -->
+<!--fragment { "author": "Bryant Morrill", "relative_parent_id": "home", "name": "Controller Helpers" } -->
+<!--model { "type": "section", "id": 10, "name": "Controller Helpers" } -->
 
 # Controller Helpers
 

data/templates/demo/content/12_configuration.md.erb

@@ -1,5 +1,5 @@
-<!--fragment { "author": "Bryant Morrill", "parent_id": "content/home", "name": "Configuration" } -->
-<!---model { "type": "markdown_record/demo/section", "id":   9, "name": "Configuration" } -->
+<!--fragment { "author": "Bryant Morrill", "relative_parent_id": "home", "name": "Configuration" } -->
+<!--model { "type": "section", "id": 11, "name": "Configuration" } -->
 
 # Configuration
 
@@ -23,4 +23,23 @@ You can configure `MarkdownRecord` in the initializer that is generated upon ins
 - `mount_path`: the path where the MarkdownRecord engine is mounted inside the host application. It is `mdr` by default.
 - `render_content_fragment_json`: a boolean value that determines whether MarkdownRecord renders content fragments and saves them to the `rendered_content_root` in JSON files with the `_fragments` suffix. If this is set to `false`, then MarkdownRecord will render your markdown content each time MarkdownRecord models queries are executed. This is set to `true` by default.
 - `render_controller`: the controller used to render ERB content during the rendering process. If this isn't set, then the host application's `ApplicationController` will be used. By default this is `nil`.
-- `ignore_numeric_prefix`: configures whether or not MarkdownRecord ignores the numeric prefixes of filenames. The default value is `true`. When it is set to `false`, the numeric prefixes will be included in the `filename` attribute of models, the `id` attribute of content fragments, and the `content_path` parameter of requests to the routes for rendered content.
+- `ignore_numeric_prefix`: configures whether or not MarkdownRecord ignores the numeric prefixes of filenames. The default value is `true`. When it is set to `false`, the numeric prefixes will be included in the `filename` attribute of models, the `id` attribute of content fragments, and the `content_path` parameter of requests to the routes for rendered content.
+- `filename_sorter`: the file sorting instance to be used to organized concatenated content. The default value is `MarkdownRecord::FileSorting::Base.new`
+
+## File sorting
+
+MarkdownRecord uses an instance of `MarkdownRecord::FileSorting::Base` by default to sort files in order to determine concatenation order of the markdown content it renders. This class is also responsible for trimming the numeric prefix prefixes off filenames. However, two additional classes are available for this purpose to allow the use of different kinds of prefixes and sort orders. They are:
+
+- `MarkdownRecord::FileSorting::DateSorter`: this class sorts files by a date prefix. By default it expects to find a prefix matching the regular expression: `/^(\d\d\d\d?_\d\d?_\d\d?)/` and parses that prefix using the data pattern: `"%Y_%m_%d"`. However you can override both of these upon instantiation like so:
+
+    ```ruby
+      MarkdownRecord::FileSorting::DateSorter.new(<regexp>, <date_pattern_string>)
+    ````
+
+- `MarkdownRecord::FileSorting::SemVerSorter`: this class sorts files by a semantive version prefix. By default it expects to find a prefix matching the regular expression: `/(\d+(?:_\d+)*)(?:_|$)/`. This allows any number of version parts, including just a single number, which would make it functionally equivalent to the default file sorter `MarkdownRecord::FileSorting::Base`. However, you can override the regex used like so:
+
+    ```ruby
+      MarkdownRecord::FileSorting::SemVerSorter.new(<regexp>)
+    ````
+
+You may also implement your own file sorter. It only needs to implement a `to_sort_value(value)` method which returns an object that responds to `<=>`.