markdown_record 0.1.3

data/lib/markdown_record/association.rb

@@ -0,0 +1,131 @@
+require "markdown_record/errors/duplicate_id_error"
+
+module MarkdownRecord
+  class Association
+    attr_accessor :base_filters
+    attr_accessor :search_filters
+    attr_reader :fulfilled
+
+    def initialize(base_filters, search_filters = {})
+      @base_filters = base_filters
+      @include_fragments = false
+      @search_filters = search_filters
+      @data = []
+      @fulfilled = false
+    end
+
+    def execute
+      reset
+      final_filters = self.search_filters.merge(self.base_filters)
+      if @include_fragments
+        final_filters.merge!(:klass => ::MarkdownRecord::ContentFragment)
+      else
+        final_filters.merge!(:exclude_fragments => true)
+      end
+      results = MarkdownRecord::ModelInflator.new.where(final_filters)
+      @data.push(*results)
+      @fulfilled = true
+    end
+
+    def fragmentize
+      reset
+      @include_fragments = true
+      self
+    end
+
+    def to_fragments
+      execute unless fulfilled
+      return @data if @include_fragments
+
+      @data.map { |m| m.fragment }
+    end
+    
+    def reset
+      @data = []
+      @fulfilled = false
+    end
+
+    def all
+      execute unless fulfilled
+      @data
+    end
+
+    def to_a
+      execute unless fulfilled
+      @data
+    end
+
+    def not(filters = {})
+      search_filters[:__not__] ||= {}
+      search_filters[:__not__].merge!(filters)
+      execute
+      self
+    end
+
+    def where(filters = {})
+      search_filters.merge!(filters)
+      execute
+      self
+    end
+
+    def each(...)
+      execute unless fulfilled
+      all unless fulfilled
+      @data.each(...)
+    end
+
+    def map(...)
+      execute unless fulfilled
+      execute
+      @data.map(...)
+    end
+
+    def count(...)
+      execute unless fulfilled
+      @data.count(...)
+    end
+
+    def any?(...)
+      execute unless fulfilled
+      @data.any?(...)
+    end
+
+    def empty?(...)
+      execute unless fulfilled
+      @data.empty?(...)
+    end
+
+    def first(...)
+      execute unless fulfilled
+      @data.first(...)
+    end
+
+    def last(...)
+      execute unless fulfilled
+      @data.first(...)
+    end
+
+    def second(...)
+      execute unless fulfilled
+      @data.second(...)
+    end
+
+    def third(...)
+      execute unless fulfilled
+      @data.third(...)
+    end
+
+    def fourth(...)
+      execute unless fulfilled
+      @data.fourth(...)
+    end
+
+    def __find__(id)
+      reset
+      search_filters.merge!({:id => id})
+      execute
+      raise ::MarkdownRecord::Errors::DuplicateIdError.new(@base_filters[:klass].name, id) if @data.count > 1
+      @data.first
+    end
+  end
+end

data/lib/markdown_record/associations.rb

@@ -0,0 +1,106 @@
+module MarkdownRecord
+  module Associations
+    extend ActiveSupport::Concern
+    include ::MarkdownRecord::PathUtilities
+  
+    class_methods do
+      def has_many_content(association, **options)
+        klass = infer_klass(association, options)
+        raise ArgumentError.new("The association class name could not be inferred, and was not provided") if klass.nil?
+
+        foreign_key = "#{self.name.demodulize.underscore}_id".to_sym
+        
+        define_method(association) do
+          klass.new_association({:klass => klass, foreign_key => self.id})
+        end
+      end
+
+      def has_one_content(association, **options)
+        klass = infer_klass(association, options)
+        raise ArgumentError.new("The association class name could not be inferred, and was not provided") if klass.nil?
+
+        foreign_key = "#{self.name.demodulize.underscore}_id".to_sym
+        
+        define_method(association) do
+          results = klass.new_association({:klass => klass, foreign_key => self.id}).all
+          if results.count > 1
+            raise ArgumentError.new("Multiple MarkdownRecords belong to the same record in a has_one_content assocition: #{self.class.name} has a has_one_content #{association} and the following records ids were found #{ results.map(&:id) } ")
+          end
+
+          results.first
+        end
+      end
+
+      def belongs_to_content(association, **options)
+        klass = infer_klass(association, options)
+
+        raise ArgumentError.new("The association class name could not be inferred, and was not provided") if klass.nil?
+        
+        foreign_key = "#{association}_id".to_sym
+        self.attribute foreign_key unless self.attributes[foreign_key].present?
+        
+        define_method(association) do
+          klass.find(self[foreign_key])
+        end
+      end
+
+      def all
+        new_association({ :klass => self }).all
+      end
+
+      def where(filters = {})
+        new_association({ :klass => self }, filters)
+      end
+
+      def find(id)
+        new_association({ :klass => self }).__find__(id)
+      end
+
+      def infer_klass(association, options)
+        class_name = options[:class_name]
+        class_name ||= association.to_s.singularize.camelize
+        
+        if self.name.include?("::") && !class_name.include?("::")
+          klass = "#{self.name.split('::')[0...-1].join("::")}::#{class_name}".safe_constantize
+        end
+
+        klass ||= class_name.camelize.safe_constantize
+      end
+    end
+
+    def siblings(filters = {})
+      self.class.new_association(filters.merge({:subdirectory => subdirectory}).merge!(not_self))
+    end
+
+    def class_siblings(filters = {})
+      self.class.new_association(filters.merge({:klass => self.class, :subdirectory => subdirectory, :__not__ => { :id => self.id }}))
+    end
+
+    def children(filters = {})
+      sub_start = "#{subdirectory}/".delete_prefix("/")
+      self.class.new_association(filters.merge({:subdirectory => Regexp.new("#{sub_start}[\\S|\\w]+")}).merge!(not_self))
+    end
+
+    def fragment
+      self.class.new_association.fragmentize.__find__(fragment_id)
+    end
+
+  private
+    
+    def not_self
+      {
+        :__or__ => [
+          { :__not__ => { 
+              :id => self.id
+            }
+          }, 
+          {
+            :__not__ => { 
+              :type => self.type 
+            }
+          }
+        ]
+      }
+    end
+  end
+end

data/lib/markdown_record/base.rb

@@ -0,0 +1,25 @@
+require "active_attr"
+
+module MarkdownRecord
+  class Base
+    include ::ActiveAttr::Model
+    include ::MarkdownRecord::Associations
+
+    attribute :id
+    attribute :type, :type => String
+    attribute :subdirectory, :type => String
+    attribute :filename, :type => String
+
+    def self.new_association(base_filters = {}, search_filters = {})
+      MarkdownRecord::Association.new(base_filters, search_filters)
+    end
+
+    def fragment_id
+      Pathname.new(subdirectory).join(filename).to_s
+    end
+
+    def self.json_klass
+      name.underscore
+    end
+  end
+end

data/lib/markdown_record/cli.rb

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

@@ -0,0 +1,66 @@
+module MarkdownRecord
+  class Configuration
+    include Singleton
+
+    attr_accessor :content_root
+    attr_accessor :rendered_content_root
+    attr_accessor :layout_directory
+    attr_accessor :concatenated_layout_path
+    attr_accessor :file_layout_path
+    attr_accessor :global_layout_path
+    attr_accessor :markdown_extensions
+    attr_accessor :html_render_options
+    attr_accessor :public_layout
+    attr_accessor :render_strategy
+    attr_accessor :html_routes
+    attr_accessor :json_routes
+    attr_accessor :content_routes
+    attr_accessor :mount_path
+    attr_accessor :render_content_fragment_json
+    attr_accessor :render_controller
+    attr_accessor :ignore_numeric_prefix
+
+    RENDER_STRATEGIES = [:full, :directory, :file]
+
+    def initialize
+      @content_root = Rails.root.join("markdown_record","content")
+      @rendered_content_root = Rails.root.join("markdown_record","rendered")
+      @layout_directory = Rails.root.join("markdown_record","layouts")
+      @html_render_options = {}
+      @markdown_extensions = { :fenced_code_blocks => true, :disable_indented_code_blocks => true, :no_intra_emphasis => true}
+      @concatenated_layout_path = "_concatenated_layout.html.erb"
+      @file_layout_path = "_file_layout.html.erb"
+      @global_layout_path = "_global_layout.html.erb"
+      @public_layout = "layouts/application"
+      @render_strategy = :full
+      @html_routes = [:show]
+      @json_routes = [:show]
+      @content_routes = [:show]
+      @mount_path = "mdr"
+      @render_content_fragment_json = true
+      @render_controller = nil
+      @ignore_numeric_prefix = true
+    end
+
+    def render_strategy_options(strategy = nil)
+      strat = strategy || @render_strategy
+
+      unless RENDER_STRATEGIES.include?(strat)
+        raise ::ArgumentError.new("Invalide render strategy.")
+      end
+
+      case strategy || @render_strategy
+      when :full
+        {:concat => true, :deep => true}
+      when :directory
+        {:concat => true, :deep => false}
+      when :file
+        {:concat => false, :deep => true}
+      end
+    end
+
+    def routing
+      { :html => html_routes, :json => json_routes, :content => content_routes}
+    end
+  end
+end

data/lib/markdown_record/content_associations.rb

@@ -0,0 +1,46 @@
+module MarkdownRecord
+  module ContentAssociations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_many_content(association, **options)
+        klass = infer_klass(association, options)
+        raise ArgumentError.new("The association class name could not be inferred, and was not provided") if klass.nil?
+
+        foreign_key = "#{association.to_s.singularize}_ids"
+        raise ArgumentError.new("#{self} does not have the #{foreign_key} attribute required for this association.") unless self.attribute_names.include?(foreign_key)
+
+        define_method(association) do
+          klass.new_association({:klass => klass, :id => self[foreign_key.to_sym]})
+        end
+      end
+
+      def has_one_content(association, **options)
+        belongs_to_content(association, **options)
+      end
+
+      def belongs_to_content(association, **options)
+        klass = infer_klass(association, options)
+        raise ArgumentError.new("The association class name could not be inferred, and was not provided") if klass.nil?
+
+        foreign_key = "#{association.to_s.singularize}_id"
+        raise ArgumentError.new("#{self} does not have the #{foreign_key} attribute required for this association.") unless self.attribute_names.include?(foreign_key)
+        
+        define_method(association) do
+          klass.find(self[foreign_key])
+        end
+      end
+
+      def infer_klass(association, options)
+        class_name = options[:class_name]
+        class_name ||= association.to_s.singularize.camelize
+        
+        if self.name.include?("::") && !class_name.include?("::")
+          klass = "#{self.name.split('::')[0...-1].join("::")}::#{class_name}".safe_constantize
+        end
+
+        klass ||= class_name.camelize.safe_constantize
+      end
+    end
+  end
+end

data/lib/markdown_record/content_dsl/attribute.rb

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

@@ -0,0 +1,22 @@
+module MarkdownRecord
+  module ContentDsl
+    module DirectoryFragment
+      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*directory_fragment\s*({[\s"'\\\w:,.\[\]\{\}_\/]*})\s*-->(?!`|\\n`)/
+      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*directory_fragment\s*({[\s"'\\\w:,.\[\]\{\}_\/]*})\s*--&gt;(?!<\/code>)/
+
+      def directory_fragment_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/disable.rb

@@ -0,0 +1,22 @@
+module MarkdownRecord
+  module ContentDsl
+    module Disable
+      REGEX = /<!--\s*disable\s*-->/
+      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*disable\s*--&gt;(?!<\/code>)/
+
+      def disable_dsl(text)
+        match = text.match(REGEX)
+
+        if match
+          true
+        else
+          false
+        end
+      end
+
+      def self.remove_dsl(text)
+        text.gsub(ENCODED_REGEX, "")
+      end
+    end
+  end
+end

data/lib/markdown_record/content_dsl/enable.rb

@@ -0,0 +1,22 @@
+module MarkdownRecord
+  module ContentDsl
+    module Enable
+      REGEX = /<!--\s*enable\s*-->/
+      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*enable\s*--&gt;(?!<\/code>)/
+
+      def enable_dsl(text)
+        match = text.match(REGEX)
+
+        if match
+          true
+        else
+          false
+        end
+      end
+
+      def self.remove_dsl(text)
+        text.gsub(ENCODED_REGEX, "")
+      end
+    end
+  end
+end

data/lib/markdown_record/content_dsl/end_attribute.rb

@@ -0,0 +1,22 @@
+module MarkdownRecord
+  module ContentDsl
+    module EndAttribute
+      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*end_attribute\s*-->(?!`|\\n`)/
+      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*end_attribute\s*--&gt;(?!<\/code>)/
+
+      def end_attribute_dsl(text)
+        match = text.match(REGEX)
+        
+        if match
+          true
+        else
+          false
+        end
+      end
+
+      def self.remove_dsl(text)
+        text.gsub(ENCODED_REGEX, "")
+      end
+    end
+  end
+end

data/lib/markdown_record/content_dsl/end_model.rb

@@ -0,0 +1,22 @@
+module MarkdownRecord
+  module ContentDsl
+    module EndModel
+      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*end_model\s*-->(?!`|\\n`)/
+      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*end_model\s*--&gt;(?!<\/code>)/
+
+      def end_model_dsl(text)
+        match = text.match(REGEX)
+
+        if match
+          true
+        else
+          false
+        end
+      end
+
+      def self.remove_dsl(text)
+        text.gsub(ENCODED_REGEX, "")
+      end
+    end
+  end
+end

data/lib/markdown_record/content_dsl/fragment.rb

@@ -0,0 +1,22 @@
+module MarkdownRecord
+  module ContentDsl
+    module Fragment
+      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*fragment\s*({[\s"'\\\w:,.\[\]\{\}_\/]*})\s*-->(?!`|\\n`)/
+      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*fragment\s+({[\s"'\\\w:,.\[\]\{\}_\/]*})\s*--&gt;(?!<\/code>)/
+
+      def fragment_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/model.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,22 @@
+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

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

@@ -0,0 +1,22 @@
+module MarkdownRecord
+  module ContentDsl
+    module UseLayout
+      REGEX = /(?<!`|`\\n|`html\\n)<!--\s*use_layout\s*:\s*(.*)\s*-->(?!`|\\n`)/
+      ENCODED_REGEX = /(?<!<code>|<code class="html">)&lt;!--\s*use_layout\s*:\s*(.*)\s*--&gt;(?!<\/code>)/
+
+      def use_layout_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