middleman-apps 0.1.0 → 0.2.0

data/lib/middleman/apps/base.rb

@@ -1,35 +1,91 @@
 require 'sinatra'
+require 'middleman/apps'
 
 module Middleman
   module Apps
     # Base application class for creating child applications.
     #
-    # Inheriting from this class should provide better syncronization with the
-    # static middleman app.
+    # Inheriting from this class provides better integration with the static
+    # middleman app.
     #
     class Base < ::Sinatra::Base
-      # set :static, true
+      # @!attribute [r] static
+      #   Serve static assets from #public_folder, if found
+      set :static, true
 
-      # set :mm_root, File.dirname(File.dirname(__FILE__))
-      # set :mm_dir, settings.development? ? 'source' : 'build'
-      # set :public_folder, File.join(settings.mm_root, settings.mm_dir)
-      # set :views, settings.public_folder
+      set :environment, (ENV['RACK_ENV'] || 'development').to_sym
+
+      # @!attribute [r] mm_app
+      #   Middleman Application instance for references to config, sitemap, etc.
+      #
+      #   Lazily evaluated since this is a bit costly.
+      #
+      set :mm_app, Middleman::Apps.middleman_app
+
+      # @!attribute [r] views
+      #   Path to the directory containing our layout files.
+      set :views, File.join(settings.mm_app.root, 'source', 'layouts')
+
+      configure :production do
+        # @!attribute [r] public_folder
+        #   Path to the directory containing our layout files.
+        set :public_folder, File.join(settings.mm_app.root, 'build')
+      end
+
+      configure :development do
+        set :show_exceptions, true
+        set :public_folder, File.join(settings.mm_app.root, 'source')
+      end
 
       not_found do
-        send_file path_for_not_found, status: 404
+        status 404
+        Middleman::Apps.not_found(settings.mm_app)
+      end
+
+      def self.app_resource
+        Middleman::Apps.find_app_resource_for(self, settings.mm_app)
+      end
+
+      def self.metadata
+        res  = app_resource
+        data = res ? res.locals : {}
+        keys = %i[routes html_description]
+        data = keys.map { |key| [key, res.send(key)] }.to_h.merge(data) if res
+        Hashie::Mash.new(data)
+      rescue NameError
+        data
+      end
+
+      def self.set_metadata(key, val, overwrite: false)
+        return if !overwrite && settings.respond_to?("app_#{key}")
+        set "app_#{key}", val
+        app_resource && app_resource.update_locals(key, val)
+      end
+
+      def self.add_routes_to_metadata(*verbs)
+        verbs = %i[get post put patch delete] if verbs.empty?
+        app_routes = verbs.map do |verb|
+          (routes[verb.to_s.upcase] || []).map do |route|
+            "##{verb.to_s.upcase} #{route[0]}"
+          end
+        end.flatten
+        set_metadata :routes, app_routes, overwrite: true
       end
 
       protected
 
-      def middleman_app
-        Middleman::Apps.middleman_app
+      def metadata
+        self.class.metadata
       end
 
-      def path_for_not_found
-        Middleman::Apps.within_extension do
-          path = find_resource(options.not_found)
-          app.root_path.join(app.config.build_dir, path).to_s
-        end
+      # Render a MM layout with the given name.
+      #
+      def middleman_layout(name, opts = {})
+        locs = opts.delete(:locals) || {}
+        opts[:layout] ||= name
+
+        res = self.class.app_resource
+        res.render(opts, res.locals.merge(locs))
       end
     end
   end

data/lib/middleman/apps/extension.rb

@@ -1,3 +1,4 @@
+require 'forwardable'
 require 'middleman-core'
 require 'middleman-core/load_paths'
 
@@ -11,6 +12,10 @@ module Middleman
     # Usage examples can be seen in README for this extension.
     #
     class Extension < ::Middleman::Extension
+      extend Forwardable
+      attr_reader :collection
+      def_delegators :@collection, :apps_list
+      expose_to_template :apps_list
 
       # @!group Options for Extension
 
@@ -22,6 +27,9 @@ module Middleman
       option :namespace, nil, 'Namespace for the child apps'
       option :map, {}, 'Mappings for differently named child apps'
       option :verbose, false, 'Displays list of child apps that were ignored'
+      option :mount_path, '/', 'Root mount path for child apps'
+      option :app_dir, ENV['MM_APPS_DIR'] || 'apps',
+             'The directory child apps are stored in'
 
       # @!endgroup
 
@@ -29,61 +37,11 @@ module Middleman
         super
         # useful for converting file names to ruby classes
         require 'active_support/core_ext/string/inflections'
-      end
-
-      # Mount all child apps on a specific Rack app (or current app)
-      #
-      # @param [Rack::App] rack_app app on which to mount child apps
-      #                             Default: app from MM configuration
-      #
-      # @return [Rack::App] rack_app with child apps mounted on top
-      #
-      def mount_child_apps(rack_app = nil)
-        rack_app ||= app
-        child_apps.each do |url, klass|
-          rack_app.map(url) { run klass }
-        end
-        rack_app
-      end
-
-      # Get a hash of all child applications URLs paths matched to corresponding
-      # Ruby classes.
-      #
-      # Warning is raised (if `verbose` option is `true`) when a child app was
-      # found, but could not be mapped due to the specified config.
-      #
-      # @return [Hash] - child application URL vs Ruby class
-      #
-      def child_apps
-        apps_list.map do |mapp|
-          require mapp
-          klass = get_application_class_for(mapp)
-          warn "Ignored child app: #{mapp}" unless klass
-          [get_application_url_for(mapp), klass] if klass
-        end.compact.to_h
-      end
-
-      # Get a Rack::App that can serve the MM app's build directory.
-      #
-      # Directory paths, and 404 error page are deduced from extensions' options.
-      #
-      # @return [Rack::App] Rack::TryStatic app for MM app's build directory.
-      #
-      def middleman_static_app
-        not_found = options.not_found
-        return create_static_app(root) unless not_found
-
-        not_found_path = File.join(build_dir, find_resource(not_found))
-        create_static_app build_dir, not_found_path
-      end
+        require 'middleman/sitemap/app_resource'
+        require 'middleman/sitemap/app_collection'
 
-      # Get a list of all child apps that are found in `MM_ROOT/apps` directory.
-      #
-      def apps_list
-        pattern = File.join(app.root, 'apps', '*.rb')
-        Dir[pattern].map do |file|
-          File.realpath(file) if File.file?(file)
-        end.compact
+        # get a reference to all the apps
+        @collection = Sitemap::AppCollection.new(app, self, options)
       end
 
       # Run `after_configuration` hook passed on by MM
@@ -99,8 +57,27 @@ module Middleman
       #
       def after_configuration
         create_config_ru
+        return if app.build?
+
+        app.sitemap.register_resource_list_manipulator(:child_apps, @collection)
         return unless app.server?
-        mount_child_apps(app)
+
+        watch_child_apps
+        @collection.mount_child_apps(app)
+      end
+
+      # Set a watcher to reload MM when files change in the directory for the
+      # child apps.
+      #
+      # @return [nil]
+      #
+      def watch_child_apps
+        # Make sure it exists, or `listen` will explode.
+        app_path = File.expand_path(options.app_dir, app.root)
+        ::FileUtils.mkdir_p(app_path)
+        watcher = app.files.watch :reload, path: app_path, only: /\.rb$/
+        list = @collection
+        watcher.on_change { list.mount_child_apps(app) }
       end
 
       # Create a `config.ru` file, if one does not exist, yet.
@@ -117,115 +94,14 @@ module Middleman
         path = File.join(app.root, 'config.ru')
         return if File.exist?(path)
 
-        content = <<-CONTENT.gsub(/^ {6}/, '')
-        ENV['RACK_ENV'] = 'production'
+        content = <<-CONTENT.gsub(/^ {8}/, '')
+        ENV['RACK_ENV'] ||= 'production'
         require 'middleman/apps'
         run Middleman::Apps.rack_app
         CONTENT
 
         File.open(path, 'wb') { |file| file.puts content }
       end
-
-      # Create a Rack::TryStatic application for the given directory root.
-      #
-      # @param [String] root - path to directory root
-      # @param [String] path - path to not found error page
-      #                        If not provided, default 404 response from Rack
-      #                        is served.
-      #
-      # @return [Rack::App] static app for the `root` directory
-      #
-      # @api private
-      #
-      def create_static_app(root, path = nil)
-        unless File.exist?(path)
-          warn("Could not find: #{path}")
-          path = nil
-        end
-
-        # require 'rack/contrib'
-        require 'middleman/apps/rack_contrib'
-        ::Rack::Builder.new do
-          use ::Rack::TryStatic, urls: ['/'], root: root,
-            try: ['.html', 'index.html', '/index.html']
-          run ::Rack::NotFound.new(path)
-        end
-      end
-
-      # Find a resource given its path, destination path, or page_id.
-      #
-      # @param [String] name - identifier for this resource
-      # @return [String] relative path to resource
-      #
-      # @api private
-      #
-      def find_resource(name)
-        sitemap    = app.sitemap
-        resource   = sitemap.find_resource_by_path(name)
-        resource ||= sitemap.find_resource_by_destination_path(name)
-        resource ||= sitemap.find_resource_by_page_id(name)
-        resource ? resource.destination_path : name
-      end
-
-      private
-
-      # Warn user about message if `verbose` option is on.
-      #
-      # @param [String] message - message to display
-      #
-      # @private
-      # @api private
-      #
-      def warn(message)
-        logger.warn(message) if logger && options.verbose
-      end
-
-      # Get path to MM's build dir.
-      #
-      # @return [String] path to build dir
-      #
-      def build_dir
-        File.expand_path(app.config.build_dir.to_s)
-      end
-
-      # Convert options data to a hash for easy searches.
-      #
-      # @api private
-      # @return [Hash] options data
-      #
-      def mappings
-        options.map.map { |key, val| [key.to_s, val] }.to_h
-      end
-
-      # Get URL at which given child app should be mounted.
-      #
-      # @api private
-      # @param [String] file - path to child app
-      # @return [String] url component for the child app
-      #
-      def get_application_url_for(file)
-        name = File.basename(file, '.rb')
-        url  = mappings[name]
-        url  = url[:url] if url.is_a?(Hash)
-        '/' + (url ? url.to_s.gsub(%r{^\/}, '') : name.titleize.parameterize)
-      end
-
-      # Get Application Class for the child app.
-      #
-      # @api private
-      # @param [String] file - path to child app
-      # @return [Class, nil] Class for the child app, if exists.
-      #
-      def get_application_class_for(file)
-        name = File.basename(file, '.rb')
-        namespace = options.namespace
-
-        klass   = mappings[name][:class] if mappings[name].is_a?(Hash)
-        klass ||= namespace ? "#{namespace}/#{name}" : name
-        klass.to_s.classify.constantize
-      rescue NameError
-        return nil
-      end
     end
   end
 end

data/lib/middleman/apps/version.rb

@@ -1,5 +1,6 @@
 module Middleman
   module Apps
-    VERSION = '0.1.0'.freeze
+    # current version for this gem
+    VERSION = '0.2.0'.freeze
   end
 end

data/lib/middleman/sitemap/app_collection.rb

@@ -0,0 +1,225 @@
+module Middleman
+  module Sitemap
+    # Resource manipulator class that handles list of all our child app
+    # resources.
+    #
+    # To evaluate anything in the context of an instance of this class, use:
+    #
+    #   Middleman::Apps.with_app_list do
+    #     apps_list # => this will be returned by the block
+    #   end
+    #
+    class AppCollection
+      def initialize(app, _extension, options = {})
+        @app = app
+        @options = options
+        @sitemap = app.sitemap
+        @app_dir = app.root_path.join(options.app_dir)
+      end
+
+      # Add our child apps to the list of resources managed by MM.
+      #
+      # @param [Array<Middleman::Sitemap::Resource>] resources - resource list
+      # @return [Array<Middleman::Sitemap::Resource>] updated resource list
+      #
+      def manipulate_resource_list(resources)
+        resources + apps_list
+      end
+
+      # Get a list of all child app resources found in child apps directory.
+      #
+      # All child apps will be reloaded everytime this method is called.
+      #
+      # @return [Array<Middleman::Sitemap::AppResource>] array of child apps
+      #
+      def apps_list
+        Dir[@app_dir.join('*.rb').to_s].map do |file|
+          path = Pathname.new(file)
+          resource = create_app(path) if path.file?
+          warn "Ignored child app: #{path}" unless resource
+          resource
+        end.compact
+      end
+
+      # Create or reload child app resource for each found child app.
+      #
+      # @param [String] path to the child app source file
+      # @return [Middleman::Sitemap::AppResource] app resource
+      #
+      def create_app(path)
+        reload_resource_at path
+        url    = get_application_url_for(path)
+        klass  = get_application_class_for(path)
+        return unless klass
+
+        source = get_source_file(path, @app_dir, :app)
+        title  = (klass || url).to_s.titleize
+        AppResource.new(@sitemap, url.gsub(%r{^\/}, ''), source).tap do |p|
+          p.add_metadata locals: { url: url, klass: klass, title: title }
+        end
+      end
+
+      # Mount all child apps on a specific Rack app (or current app)
+      #
+      # Warning is raised (if `verbose` option is `true`) when a child app was
+      # found, but could not be mapped due to the specified config.
+      #
+      # @param [Rack::App] rack_app app on which to mount child apps
+      #                             Default: app from MM configuration
+      #
+      # @return [Rack::App] rack_app with child apps mounted on top
+      #
+      def mount_child_apps(rack_app = nil)
+        rack_app ||= @app
+        apps_list.each do |res|
+          rack_app.map(res.url) { run res.klass } if res.klass
+        end
+        rack_app
+      end
+
+      # Get a Rack::App that can serve the MM app's build directory.
+      #
+      # Directory paths, and 404 error page are deduced from extensions'
+      # options.
+      #
+      # @return [Rack::App] Rack::TryStatic app for MM app's build directory.
+      #
+      def middleman_static_app
+        not_found = @options.not_found
+        return create_static_app(build_dir) unless not_found
+
+        not_found_path = File.join(build_dir, find_resource(not_found))
+        create_static_app build_dir, not_found_path
+      end
+
+      protected
+
+      # Create a Rack::TryStatic application for the given directory root.
+      #
+      # @param [String] root - path to directory root
+      # @param [String] path - path to not found error page
+      #                        If not provided, default 404 response from Rack
+      #                        is served.
+      #
+      # @return [Rack::App] static app for the `root` directory
+      #
+      # @api private
+      #
+      def create_static_app(root, path = nil)
+        unless File.exist?(path)
+          warn("Could not find: #{path}")
+          path = nil
+        end
+
+        # require 'rack/contrib'
+        require 'middleman/apps/rack_contrib'
+        ::Rack::Builder.new do
+          use ::Rack::TryStatic, urls: ['/'], root: root,
+                                 try: ['.html', 'index.html', '/index.html']
+          run ::Rack::NotFound.new(path)
+        end
+      end
+
+      # Find a resource given its path, destination path, or page_id.
+      #
+      # @param [String] name - identifier for this resource
+      # @return [String] relative path to resource
+      #
+      # @api private
+      #
+      def find_resource(name)
+        sitemap    = @app.sitemap
+        resource   = sitemap.find_resource_by_path(name)
+        resource ||= sitemap.find_resource_by_destination_path(name)
+        resource ||= sitemap.find_resource_by_page_id(name)
+        resource ? resource.destination_path : name
+      end
+
+      private
+
+      # Warn user about message if `verbose` option is on.
+      #
+      # @param [String] message - message to display
+      #
+      # @private
+      # @api private
+      #
+      def warn(message)
+        @app.logger.warn(message) if @app.logger && @options.verbose
+      end
+
+      # Get path to MM's build dir.
+      #
+      # @return [String] path to build dir
+      #
+      def build_dir
+        @app.root_path.join(@app.config.build_dir.to_s)
+      end
+
+      # Convert options data to a hash for easy searches.
+      #
+      # @api private
+      # @return [Hash] options data
+      #
+      def mappings
+        @options.map.map { |key, val| [key.to_s, val] }.to_h
+      end
+
+      # Get URL at which given child app should be mounted.
+      #
+      # @api private
+      # @param [String] path - path to child app
+      # @return [String] url component for the child app
+      #
+      def get_application_url_for(path)
+        name  = path.basename('.rb').to_s
+        url   = mappings[name]
+        url   = url[:url] if url.is_a?(Hash)
+        url ||= name.to_s.titleize.parameterize
+        "#{@options.mount_path}/#{url}".gsub(%r{\/+}, '/')
+      end
+
+      # Get Application Class for the child app.
+      #
+      # @api private
+      # @param [String] path - path to child app
+      # @return [Class, nil] Class for the child app, if exists.
+      #
+      def get_application_class_for(path)
+        name = path.basename('.rb').to_s
+        namespace = @options.namespace
+
+        klass   = mappings[name][:class] if mappings[name].is_a?(Hash)
+        klass ||= namespace ? "#{namespace}/#{name}" : name
+        klass.to_s.classify.safe_constantize
+      end
+
+      # Get SourceFile instance from the given path.
+      #
+      # @api private
+      # @param [String] path - path to the source file
+      # @return [Middleman::SourceFile]
+      def get_source_file(path, dir, name)
+        ::Middleman::SourceFile.new(path.relative_path_from(dir),
+                                    path, path.dirname.to_s, Set.new([name]), 0)
+      end
+
+      # Reload resource at a given file path
+      #
+      # @api private
+      # @param [String] path - path to the source file
+      # @return [nil]
+      #
+      def reload_resource_at(path)
+        if $LOADED_FEATURES.include?(path.to_s)
+          klass = get_application_class_for(path)
+          container = klass.to_s.deconstantize.safe_constantize || Object
+          container.send(:remove_const, klass.to_s.demodulize) if klass
+          $LOADED_FEATURES.delete(path.to_s)
+        end
+
+        require path
+      end
+    end
+  end
+end