flora 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b44217297cbd020d161b21d49829be840dd7ec4b99327108aa1b0c14e4f3286
-  data.tar.gz: 32871444dfee770b17d99e57aa4753e1f8a40e02d3743e7e52e3a1ef77098a8d
+  metadata.gz: 2a7d4bc41b49cc7dba0f424be3b8c3bd62ba19fae76d1d1129dad0875f38ab2c
+  data.tar.gz: a52d14ffc096179aba36b232fa76826d29a28ab5f2283cde85b533c2c2bba959
 SHA512:
-  metadata.gz: 6567dab062a120dca84dabec2246266c5f482fcc2ba8899c541f2d4fd5a0801f7e6c7a9ef8f4af47896495dcf1768ce6eb763eea9df8b33db935a70fdc561617
-  data.tar.gz: f24f358cb9c3da51053b2c1301f2d5c0f85aaebadf1956558f623839e8c24acc241157b77962f7772e83a6e7d3542a768e488d0efbd6785878ba5431386dd747
+  metadata.gz: 92282602b69d8dcdea03660ff8d3446d59b1555d994abf6c7643d1a4ae688c6f1d88b09732d68d40d8c877d9feb39b6067451e4473d281e4e948c1640a9a5fde
+  data.tar.gz: de0ae5863a9f75933528d14ee8e8034a16154a207831f958372214990cf544ad2ffc6b1b909454feae15ab62b401120d95bf25b46b92048ea8189a83f93dda71

data/lib/flora/app.rb

@@ -2,6 +2,62 @@ require 'rack'
 
 class Flora::App
 
+  # TODO: make this support multiple apps.
+  OUT_DIR = '/tmp/flora/'
+
+
+  class Rebuilder
+
+    def initialize(app, dir, flora)
+      @app = app
+      @dir = Pathname.new(dir)
+      @flora = flora
+      @last_built = Time.at(0)
+    end
+
+
+    def call(env)
+      if should_rebuild?
+        @flora.build(OUT_DIR)
+        @last_built = Time.now.utc
+        # TODO: also trigger a reload in the browser
+      end
+
+      @app.call(env)
+    end
+
+
+    private
+
+      def should_rebuild?
+        # TODO: this is probably slow. I'm sure there's an easier kqueue-esq way
+        # of doing this.
+        @dir.find do |file|
+          return true if file.stat.mtime > @last_built
+        end
+
+        false
+      end
+
+  end
+
+
+  class Reloader
+
+    def initialize(app, flora)
+      @app = app
+      @flora = flora
+    end
+
+    def call(env)
+      @flora.reload_blueprint
+
+      @app.call(env)
+    end
+
+  end
+
+
   # UGLY. Is there a better way to do this?
   class StaticWithoutHtml
 
@@ -25,12 +81,13 @@ class Flora::App
 
   def self.app(path)
     flora = Flora.new(path)
-    # TODO: rebuild every req?
-    flora.build('/tmp/flora/')
 
     Rack::Builder.new do
-      use StaticWithoutHtml, '/tmp/flora'
-      use Rack::Static, urls: [''], root: '/tmp/flora', index: 'index.html'
+      use Rebuilder, path, flora
+      use Reloader, flora
+      use StaticWithoutHtml, OUT_DIR
+      use Rack::Static, urls: [''], root: OUT_DIR, index: 'index.html'
+
       map "/" do
         run ->(env) do
           [404, {'Content-Type' => 'text/plain'}, ['Page Not Found!']]

data/lib/flora/{engine → blueprint}/page/html.rb

@@ -1,4 +1,4 @@
-module Flora::Engine::Page::Html
+module Flora::Blueprint::Page::Html
 
   TAGS = %i[
     a abbr address area article aside audio

data/lib/flora/{engine → blueprint}/page/layout.rb

@@ -1,4 +1,4 @@
-class Flora::Engine::Page::Layout
+class Flora::Blueprint::Page::Layout
 
   def initialize(layouts)
     @layouts = layouts

data/lib/flora/{engine → blueprint}/page/markdown_page.rb

@@ -1,13 +1,13 @@
-class Flora::Engine::Page::MarkdownPage < Flora::Engine::Page
+class Flora::Blueprint::Page::MarkdownPage < Flora::Blueprint::Page
 
-  def render
-    silence_warnings do
-      raw_html(Kramdown::Document.new(@file.read).to_html)
-    end
-  end
+  private
 
+    def render_tree
+      silence_warnings do
+        raw_html(Kramdown::Document.new(@file.read).to_html)
+      end
+    end
 
-  private
 
     # Remove this if kramdown ever fixes its one warning.
     def silence_warnings

data/lib/flora/blueprint/page/ruby_page.rb

@@ -0,0 +1,12 @@
+class Flora::Blueprint::Page::RubyPage < Flora::Blueprint::Page
+
+  private
+
+    def render_tree
+      # The Html DSL uses a global variable internally that needs to be reset every time.
+      $flora_added = []
+
+      instance_eval(@file.read)
+    end
+
+end

data/lib/flora/blueprint/page.rb

@@ -0,0 +1,49 @@
+# A page is something can be turned into HTML.
+class Flora::Blueprint::Page
+
+  attr_reader(:blueprint, :file, :route)
+
+
+  def self.for(file)
+    # TODO: make this a little more extensible so plugins can implement new page
+    # types.
+    case file.extname
+    when '.rb'
+      RubyPage
+    when '.md'
+      MarkdownPage
+    end
+  end
+
+
+  def initialize(blueprint, file, route)
+    @blueprint = blueprint
+    @file = file
+    @route = route
+    @layout = find_layouts
+  end
+
+
+  def render
+    tree = @layout.render do
+      render_tree
+    end
+
+    Html.to_html(tree)
+  end
+
+
+  private
+
+    def find_layouts
+      layouts = []
+
+      @file.ascend do |dir|
+        maybe_layout = dir.join('_layout.rb')
+        layouts << maybe_layout if maybe_layout.exist?
+      end
+
+      Layout.new(layouts)
+    end
+
+end

data/lib/flora/blueprint.rb

@@ -0,0 +1,64 @@
+class Flora::Blueprint
+
+  attr_reader(:dir)
+
+  IGNORES = ['.git/*', 'lib/*', '**_layout.rb', '_config.rb']
+
+
+  def initialize(dir, config, page_modules)
+    @dir = dir
+    @config = config
+    @page_modules = page_modules
+
+    @pages = load_pages
+
+    @loader = Zeitwerk::Loader.new
+    if has_supporting_code?
+      @loader.push_dir(@dir.join('lib').to_s)
+    end
+    @loader.enable_reloading
+    @loader.setup
+  end
+
+
+  def each_page(&block)
+    @pages.each(&block)
+  end
+
+
+  def reload
+    @loader.reload
+    @pages = load_pages
+  end
+
+
+  private
+
+    def load_pages
+      pages = []
+
+      @dir.find do |file|
+        next if IGNORES.any? { file.fnmatch((@dir / it).to_s) }
+        next if file.directory?
+        next unless supported_file_type?(file)
+
+        route = file.relative_path_from(@dir).sub_ext('.html').to_s
+        page = Page.for(file).new(self, file, route)
+        @page_modules.each { |mod| page.extend(mod) }
+        pages << page
+      end
+
+      pages
+    end
+
+
+    def supported_file_type?(file)
+      file.extname == '.rb' || file.extname == '.md'
+    end
+
+
+    def has_supporting_code?
+      @dir.join('lib').exist?
+    end
+
+end

data/lib/flora/config.rb

@@ -0,0 +1,21 @@
+class Flora::Config
+
+  def initialize(file, flora)
+    @file = file
+    @flora = flora
+    load if @file.exist?
+  end
+
+
+  def plugin(mod)
+    @flora.load_plugin(mod)
+  end
+
+
+  private
+
+    def load
+      instance_eval(@file.read)
+    end
+
+end

data/lib/flora/factory.rb

@@ -0,0 +1,20 @@
+class Flora::Factory
+
+  def initialize(blueprint, config)
+    @blueprint = blueprint
+    @config = config
+  end
+
+
+  # Assemble a blueprint and put it into a directory.
+  def assemble(out_dir)
+    out_dir.mkdir unless out_dir.exist?
+
+    @blueprint.each_page do |page|
+      out_filename = out_dir.join(page.route)
+      out_filename.dirname.mkdir unless out_filename.dirname.exist?
+      out_filename.write(page.render)
+    end
+  end
+
+end

data/lib/flora/plugins/blog.rb

@@ -3,7 +3,7 @@ module Flora::Plugins::Blog
   module PageMethods
 
     def posts
-      @root.glob('posts/**').map { Post.new(it, @root) }
+      @blueprint.dir.glob('posts/**').map { Post.new(it, @blueprint.dir) }
     end
 
   end

data/lib/flora/plugins/redirector.rb

@@ -1,12 +1,12 @@
 module Flora::Plugins::Redirector
 
-  module EngineMethods
+  module FactoryMethods
 
-    def build(*)
+    def assemble(out_dir)
       super
 
       @config.redirects.each do |src, dest|
-        out_filename = @out_dir.join(src + '.html')
+        out_filename = out_dir.join(src + '.html')
         out_filename.dirname.mkdir unless out_filename.dirname.exist?
         out_filename.write(build_redir_file(dest))
       end

data/lib/flora/plugins/static_files.rb

@@ -20,14 +20,14 @@ module Flora::Plugins::StaticFiles
   end
 
 
-  module EngineMethods
+  module FactoryMethods
 
-    def build(*)
+    def assemble(out_dir)
       super
 
       base = @config.static_files_dir || 'public'
-      copier = Copier.new(@path.join(base))
-      copier.copy_to(@out_dir.join(base))
+      copier = Copier.new(@blueprint.dir.join(base))
+      copier.copy_to(out_dir.join(base))
     end
 
   end

data/lib/flora/version.rb

@@ -1,3 +1,3 @@
 class Flora
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/flora.rb

@@ -8,14 +8,45 @@ loader.setup
 class Flora
 
   def initialize(dir)
-    # A new class so plugins only affect one instance.
-    @engine = Class.new(Engine).new(dir)
-    @engine.configure
+    dir = Pathname.new(dir)
+
+    # Inject HTML helpers into Kernel so they're available everywhere. Just
+    # instance_eval isn't enough because they'll be missing in lib/ code.
+    #
+    # TODO: is there a less disruptive way to do this?
+    Kernel.prepend(Flora::Blueprint::Page::Html)
+
+    # The classes that are pluggable get their own instances to avoid conflicting
+    # with other instances of Flora in the same process. This is mostly for the
+    # unit tests. Maybe one day we can use Ruby::Box or something here instead.
+    @config_class = Class.new(Config)
+    @factory_class = Class.new(Factory)
+
+    # Page plugins get mixed in directly to the page instances by Blueprint.
+    @page_modules = []
+
+    @config = @config_class.new(dir.join('_config.rb'), self)
+    @blueprint = Blueprint.new(dir, @config, @page_modules)
+    @factory = @factory_class.new(@blueprint, @config)
   end
 
 
   def build(out)
-    @engine.build(out)
+    @factory.assemble(Pathname.new(out))
+  end
+
+
+  def reload_blueprint
+    @blueprint.reload
+  end
+
+
+  # TODO: it would be nice if this wasn't exposed here. It's just for Config#plugin.
+  def load_plugin(mod)
+    @factory_class.include(mod::FactoryMethods) if defined?(mod::FactoryMethods)
+    @config_class.include(mod::Config) if defined?(mod::Config)
+
+    @page_modules << mod::PageMethods if defined?(mod::PageMethods)
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flora
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Nick Vladimiroff
@@ -106,14 +106,15 @@ files:
 - exe/flora
 - lib/flora.rb
 - lib/flora/app.rb
+- lib/flora/blueprint.rb
+- lib/flora/blueprint/page.rb
+- lib/flora/blueprint/page/html.rb
+- lib/flora/blueprint/page/layout.rb
+- lib/flora/blueprint/page/markdown_page.rb
+- lib/flora/blueprint/page/ruby_page.rb
 - lib/flora/cli.rb
-- lib/flora/engine.rb
-- lib/flora/engine/config.rb
-- lib/flora/engine/page.rb
-- lib/flora/engine/page/html.rb
-- lib/flora/engine/page/layout.rb
-- lib/flora/engine/page/markdown_page.rb
-- lib/flora/engine/page/ruby_page.rb
+- lib/flora/config.rb
+- lib/flora/factory.rb
 - lib/flora/plugins/blog.rb
 - lib/flora/plugins/blog/post.rb
 - lib/flora/plugins/redirector.rb

data/lib/flora/engine/config.rb

@@ -1,12 +0,0 @@
-class Flora::Engine::Config
-
-  def initialize(plugin_loader)
-    @plugin_loader = plugin_loader
-  end
-
-
-  def plugin(mod)
-    @plugin_loader.load_plugin(mod)
-  end
-
-end

data/lib/flora/engine/page/ruby_page.rb

@@ -1,8 +0,0 @@
-class Flora::Engine::Page::RubyPage < Flora::Engine::Page
-
-  def render
-    super
-    instance_eval(@file.read)
-  end
-
-end

data/lib/flora/engine/page.rb

@@ -1,64 +0,0 @@
-# A page is something can be turned into HTML. It might also have a layout to render into.
-class Flora::Engine::Page
-
-  IGNORES = ['.git/*', 'lib/*', '**_layout.rb', '_config.rb']
-
-
-  class << self
-
-    def each(path)
-      path.find do |file|
-        next if IGNORES.any? { file.fnmatch((path / it).to_s) }
-        next if file.directory?
-        next unless supported_file_type?(file)
-
-        yield(self.for(path, file))
-      end
-    end
-
-
-    def for(root, file)
-      case file.extname
-      when '.rb'
-        RubyPage.new(root, file)
-      when '.md'
-        MarkdownPage.new(root, file)
-      end
-    end
-
-
-    private
-
-      def supported_file_type?(file)
-        file.extname == '.rb' || file.extname == '.md'
-      end
-
-  end
-
-
-  def initialize(root, file)
-    @root = root
-    @file = file
-  end
-
-
-  def render
-  end
-
-
-  def outname
-    # TODO: this might sub something in the middle instead of just the ext.
-    @file.relative_path_from(@root).sub(@file.extname, '.html')
-  end
-
-
-  def url
-    @file.relative_path_from(@root).sub(@file.extname, '')
-  end
-
-
-  def dir
-    @file.dirname
-  end
-
-end

data/lib/flora/engine.rb

@@ -1,69 +0,0 @@
-class Flora::Engine
-
-  def initialize(path)
-    @path = Pathname.new(path)
-    @config = Config.new(self)
-
-    @site_loader = Zeitwerk::Loader.new
-
-    if site_has_supporting_code?
-      setup_site_loader
-    end
-
-    Kernel.prepend(Flora::Engine::Page::Html)
-  end
-
-
-  def configure
-    config_file = @path.join('_config.rb')
-    @config.instance_eval(config_file.read)  if config_file.exist?
-  end
-
-
-  def build(out_dir)
-    @out_dir = Pathname.new(out_dir)
-    @out_dir.mkdir unless @out_dir.exist?
-
-    Page.each(@path) do |page|
-      layouts = []
-      page.dir.ascend do |dir|
-        maybe_layout = dir.join('_layout.rb')
-        layouts << maybe_layout if maybe_layout.exist?
-        break if dir == @path
-      end
-
-      $flora_added = []
-      tree = Page::Layout.new(layouts).render do
-        page.render
-      end
-      html = Page::Html.to_html(tree)
-
-      out_filename = @out_dir.join(page.outname)
-      out_filename.dirname.mkdir unless out_filename.dirname.exist?
-      out_filename.write(html)
-    end
-
-  end
-
-
-  def load_plugin(mod)
-    self.class.include(mod::EngineMethods) if defined?(mod::EngineMethods)
-    Page::RubyPage.include(mod::PageMethods) if defined?(mod::PageMethods)
-    Config.include(mod::Config) if defined?(mod::Config)
-  end
-
-
-  private
-
-    def site_has_supporting_code?
-      @path.join('lib').exist?
-    end
-
-
-    def setup_site_loader
-      @site_loader.push_dir(@path.join('lib').to_s)
-      @site_loader.enable_reloading
-      @site_loader.setup
-    end
-
-end