lotusrb 0.1.0 → 0.2.0

data/lib/lotus/generators/slice/.gitkeep.tt

@@ -0,0 +1 @@
+#

data/lib/lotus/generators/slice/action.rb.tt

@@ -0,0 +1,8 @@
+module <%= config[:classified_slice_name] %>::Controllers::Home
+  class Index
+    include <%= config[:classified_slice_name] %>::Action
+
+    def call(params)
+    end
+  end
+end

data/lib/lotus/generators/slice/application.rb.tt

@@ -0,0 +1,182 @@
+module <%= config[:classified_slice_name] %>
+  class Application < Lotus::Application
+    configure do
+      ##
+      # BASIC
+      #
+
+      # Define the root path of this application.
+      # All the paths specified in this configuration are relative to this one.
+      #
+      root __dir__
+
+      # Relative load paths where this application will recursively load the code.
+      # Remember to add directories here when you create new.
+      #
+      load_paths << [
+        'controllers',
+        'views'
+      ]
+
+      # Handle exceptions with HTTP statuses (true) or don't catch them (false).
+      # Defaults to true.
+      # See: http://www.rubydoc.info/gems/lotus-controller/#Exceptions_management
+      #
+      # handle_exceptions true
+
+      ##
+      # HTTP
+      #
+
+      # Routes definitions for this application
+      # See: http://www.rubydoc.info/gems/lotus-router#Usage
+      #
+      routes 'config/routes'
+
+      # URI scheme used by the routing system to generate absolute URLs
+      # Defaults to "http"
+      #
+      # scheme 'https'
+
+      # URI host used by the routing system to generate absolute URLs
+      # Defaults to "localhost"
+      #
+      # host 'example.org'
+
+      # URI port used by the routing system to generate absolute URLs
+      # Argument: An object coercible to integer, default to 80 if the scheme is http and 443 if it's https
+      # This SHOULD be configured only in case the application listens to that non standard ports
+      #
+      # port 443
+
+      # Enable cookies
+      #
+      # cookies true
+
+      # Enable sessions
+      # Argument: Symbol the Rack session adapter
+      #           A Hash with options
+      #
+      # See: http://www.rubydoc.info/gems/rack/Rack/Session/Cookie
+      #
+      # sessions :cookie, secret: ENV['<%= config[:upcase_slice_name] %>_SESSIONS_SECRET']
+
+      # Configure Rack middleware for this application
+      #
+      # middleware.use Rack::Protection
+
+      # Default format for the requests that don't specify an HTTP_ACCEPT header
+      # Argument: A symbol representation of a mime type, default to :html
+      #
+      # default_format :html
+
+      # HTTP Body parsers
+      # Parse non GET responses body for a specific mime type
+      # Argument: Symbol, which represent the format of the mime type (only `:json` is supported)
+      #           Object, the parser
+      #
+      # body_parsers :json
+
+      ##
+      # DATABASE
+      #
+
+      # Configure a database adapter
+      # Argument: A Hash with the settings
+      #           type: Symbol, :file_system, :memory and :sql
+      #           uri:  String, 'file:///db/bookshelf'
+      #                         'memory://localhost/bookshelf'
+      #                         'sqlite:memory:'
+      #                         'sqlite://db/bookshelf.db'
+      #                         'postgres://localhost/bookshelf'
+      #                         'mysql://localhost/bookshelf'
+      #
+      # adapter type: :file_system, uri: ENV['<%= config[:upcase_slice_name] %>_DATABASE_URL']
+
+      # Configure a database mapping
+      # See: http://www.rubydoc.info/gems/lotus-model#Data_Mapper
+      #
+      # mapping 'config/mapping'
+
+      ##
+      # TEMPLATES
+      #
+
+      # The layout to be used by all the views
+      #
+      layout :application # It will load <%= config[:classified_slice_name] %>::Views::ApplicationLayout
+
+      # The relative path where to find the templates
+      #
+      # templates 'templates'
+
+      ##
+      # ASSETS
+      #
+
+      # Specify sources for assets
+      # The directory `public/` is added by default
+      #
+      # assets << [
+      #   'vendor/javascripts'
+      # ]
+
+      # Enabling serving assets
+      # Defaults to false
+      #
+      # serve_assets false
+
+      ##
+      # FRAMEWORKS
+      #
+
+      # Configure the code to be yielded each time <%= config[:classified_slice_name] %>::Action will be included
+      # This is useful for share common functionalities
+      #
+      # See: http://www.rubydoc.info/gems/lotus-controller#Configuration
+      controller.prepare do
+        # include MyAuthentication # included in all the actions
+        # before :authenticate!    # run an authentication before callback
+      end
+
+      # Configure the code to be yielded each time <%= config[:classified_slice_name] %>::View will be included
+      # This is useful for share common functionalities
+      #
+      # See: http://www.rubydoc.info/gems/lotus-view#Configuration
+      view.prepare do
+        # include MyRoutingHelpers # included in all the views
+      end
+    end
+
+    ##
+    # DEVELOPMENT
+    #
+    configure :development do
+      # Don't handle exceptions, render the stack trace
+      handle_exceptions false
+
+      # Serve static assets during development
+      serve_assets      true
+    end
+
+    ##
+    # TEST
+    #
+    configure :test do
+      # Don't handle exceptions, render the stack trace
+      handle_exceptions false
+
+      # Serve static assets during development
+      serve_assets      true
+    end
+
+    ##
+    # PRODUCTION
+    #
+    configure :production do
+      # scheme 'https'
+      # host   'example.org'
+      # port   443
+    end
+  end
+end

data/lib/lotus/generators/slice/config/mapping.rb.tt

@@ -0,0 +1,10 @@
+# Configure your database mapping here
+# See: http://www.rubydoc.info/gems/lotus-model/#Usage
+#
+# collection :users do
+#   entity     User
+#   repository UserRepository
+#
+#   attribute :id,   Integer
+#   attribute :name, String
+# end

data/lib/lotus/generators/slice/config/routes.rb.tt

@@ -0,0 +1,8 @@
+# Configure your routes here
+# See: http://www.rubydoc.info/gems/lotus-router/#Usage
+#
+#
+#
+# This route will look for `<%= config[:classified_slice_name] %>::Controllers::Home::Index` action in `apps/<%= config[:slice_name] %>/controllers/home/index.rb`.
+# Please, uncomment the following line to have a working example.
+# get '/', to: 'home#index'

data/lib/lotus/generators/slice/templates/application.html.erb

@@ -0,0 +1,9 @@
+<!doctype HTML>
+<html>
+  <head>
+    <title>Chirp!</title>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/lib/lotus/generators/slice/templates/application.html.erb.tt

@@ -0,0 +1,9 @@
+<!doctype HTML>
+<html>
+  <head>
+    <title><%= config[:classified_slice_name] %></title>
+  </head>
+  <body>
+    <%%= yield %>
+  </body>
+</html>

data/lib/lotus/generators/slice/templates/template.html.erb.tt

@@ -0,0 +1,2 @@
+<h1>Welcome to Lotus!</h1>
+<h3>This template is rendered by <code><%= config[:classified_slice_name] %>::Views::Home::Index</code> and it's available at: <code>apps/<%= config[:slice_name] %>/templates/home/index.html.erb</code></h3>

data/lib/lotus/generators/slice/view.rb.tt

@@ -0,0 +1,5 @@
+module <%= config[:classified_slice_name] %>::Views::Home
+  class Index
+    include <%= config[:classified_slice_name] %>::View
+  end
+end

data/lib/lotus/generators/slice/views/application_layout.rb.tt

@@ -0,0 +1,7 @@
+module <%= config[:classified_slice_name] %>
+  module Views
+    class ApplicationLayout
+      include <%= config[:classified_slice_name] %>::Layout
+    end
+  end
+end

data/lib/lotus/generators/slice.rb

@@ -0,0 +1,103 @@
+require 'securerandom'
+require 'lotus/generators/abstract'
+require 'lotus/utils/string'
+
+module Lotus
+  module Generators
+    class Slice < Abstract
+      def initialize(command)
+        super
+
+        @slice_name            = options.fetch(:application)
+        @upcase_slice_name     = @slice_name.upcase
+        @classified_slice_name = Utils::String.new(@slice_name).classify
+
+        @source                = Pathname.new(::File.dirname(__FILE__) + '/../generators/slice')
+        @target                = target.join('apps', @slice_name)
+
+        @slice_base_url        = options.fetch(:application_base_url)
+
+        cli.class.source_root(@source)
+      end
+
+      def start
+        opts = {
+          slice_name:            @slice_name,
+          upcase_slice_name:     @upcase_slice_name,
+          classified_slice_name: @classified_slice_name,
+          slice_base_url:        @slice_base_url
+        }
+
+        templates = {
+          'application.rb.tt'                 => 'application.rb',
+          'config/routes.rb.tt'               => 'config/routes.rb',
+          'config/mapping.rb.tt'              => 'config/mapping.rb',
+          'action.rb.tt'                      => 'controllers/home/index.rb',
+          'views/application_layout.rb.tt'    => 'views/application_layout.rb',
+          'templates/application.html.erb.tt' => 'templates/application.html.erb',
+          'view.rb.tt'                        => 'views/home/index.rb',
+          'templates/template.html.erb.tt'    => 'templates/home/index.html.erb',
+        }
+
+        empty_directories = [
+          "public/javascripts",
+          "public/stylesheets"
+        ]
+
+        case options[:test]
+        when 'rspec'
+        else # minitest (default)
+          empty_directories << [
+            "../../spec/#{ opts[:slice_name] }/features",
+            "../../spec/#{ opts[:slice_name] }/controllers",
+            "../../spec/#{ opts[:slice_name] }/views"
+          ]
+        end
+
+        ##
+        # config/environment.rb
+        #
+
+        # Add "require_relative '../apps/web/application'"
+        cli.gsub_file target.join('config/environment.rb'), /require_relative (.*)/ do |match|
+          match << "\nrequire_relative '../apps/#{ opts[:slice_name] }/application'"
+        end
+
+        # Mount slice inside "Lotus::Container.configure"
+        cli.gsub_file target.join('config/environment.rb'), /(mount (.*)|Lotus::Container.configure do)/ do |match|
+          match << "\n  mount #{ opts[:classified_slice_name] }::Application, at: '#{ opts[:slice_base_url] }'"
+        end
+
+        ##
+        # Per environment .env
+        #
+        ['development', 'test'].each do |environment|
+          # Add WEB_DATABASE_URL="file:///db/web_development"
+          cli.append_to_file target.join("config/.env.#{ environment }") do
+            %(#{ opts[:upcase_slice_name] }_DATABASE_URL="file:///db/#{ opts[:slice_name] }_#{ environment }"\n)
+          end
+
+          # Add WEB_SESSIONS_SECRET="abc123" (random hex)
+          cli.append_to_file target.join("config/.env.#{ environment }") do
+            %(#{ opts[:upcase_slice_name] }_SESSIONS_SECRET="#{ SecureRandom.hex(32) }"\n)
+          end
+        end
+
+        ##
+        # New files
+        #
+        templates.each do |src, dst|
+          cli.template(@source.join(src), @target.join(dst), opts)
+        end
+
+        ##
+        # Empty directories
+        #
+        empty_directories.flatten.each do |dir|
+          gitkeep = '.gitkeep'
+          cli.template(@source.join(gitkeep), @target.join(dir, gitkeep), opts)
+        end
+      end
+    end
+  end
+end

data/lib/lotus/loader.rb

@@ -3,6 +3,8 @@ require 'lotus/utils/kernel'
 require 'lotus/utils/string'
 require 'lotus/routes'
 require 'lotus/routing/default'
+require 'lotus/action/cookies'
+require 'lotus/action/session'
 
 module Lotus
   # Load an application
@@ -20,9 +22,10 @@ module Lotus
     def load!
       @mutex.synchronize do
         load_configuration!
+        configure_frameworks!
+        load_configuration_load_paths!
+        load_rack!
         load_frameworks!
-        load_application!
-        finalize!
       end
     end
 
@@ -33,34 +36,109 @@ module Lotus
       configuration.load!(application_module)
     end
 
-    def load_frameworks!
+    def configure_frameworks!
+      _configure_model_framework! if defined?(Lotus::Model)
+      _configure_controller_framework!
+      _configure_view_framework!
+    end
+
+    def _configure_controller_framework!
       config = configuration
+      unless namespace.const_defined?('Controller')
+        controller = Lotus::Controller.duplicate(namespace) do
+          handle_exceptions config.handle_exceptions
+          default_format    config.default_format
 
-      unless application_module.const_defined?('Controller')
-        controller = Lotus::Controller.duplicate(application_module) do
-          default_format config.default_format
+          prepare { include Lotus::Action::Cookies } if config.cookies
+          prepare { include Lotus::Action::Session } if config.sessions.enabled?
+
+          config.controller.__apply(self)
         end
 
-        application_module.const_set('Controller', controller)
+        namespace.const_set('Controller', controller)
       end
+    end
 
-      unless application_module.const_defined?('View')
-        view = Lotus::View.duplicate(application_module) do
+    def _configure_view_framework!
+      config = configuration
+      unless namespace.const_defined?('View')
+        view = Lotus::View.duplicate(namespace) do
           root   config.templates
           layout config.layout
+
+          config.view.__apply(self)
         end
 
-        application_module.const_set('View', view)
+        namespace.const_set('View', view)
+      end
+    end
+
+    def _configure_model_framework!
+      config = configuration
+      if _lotus_model_loaded? && !application_module.const_defined?('Model')
+        model = Lotus::Model.duplicate(application_module) do
+          adapter(config.adapter)  if config.adapter
+          mapping(&config.mapping) if config.mapping
+
+          config.model.__apply(self)
+        end
+
+        application_module.const_set('Model', model)
+      end
+    end
+
+
+    def load_frameworks!
+      _load_view_framework!
+      _load_model_framework!
+    end
+
+    def _load_view_framework!
+      namespace.module_eval %{
+        #{ namespace }::View.load!
+      }
+    end
+
+    def _load_model_framework!
+      return unless _load_model_framework?
+
+      application_module.module_eval %{
+        #{ application_module }::Model.load!
+      }
+    end
+
+    def _load_model_framework?
+      if _lotus_model_loaded? && application_module.const_defined?('Model')
+        model = application_module.const_get('Model')
+        model.configuration.adapter
       end
     end
 
-    def load_application!
+    def _lotus_model_loaded?
+      defined?(Lotus::Model)
+    end
+
+    def load_configuration_load_paths!
       configuration.load_paths.load!(configuration.root)
-      namespace = configuration.namespace || application_module
+    end
 
+    def load_rack!
+      return if application.is_a?(Class)
+      _assign_rendering_policy!
+      _assign_rack_routes!
+      _load_rack_middleware!
+      _assign_routes_to_application_module!
+    end
+
+    def _assign_rendering_policy!
+      application.renderer = RenderingPolicy.new(configuration)
+    end
+
+    def _assign_rack_routes!
       resolver    = Lotus::Routing::EndpointResolver.new(pattern: configuration.controller_pattern, namespace: namespace)
       default_app = Lotus::Routing::Default.new
       application.routes = Lotus::Router.new(
+        parsers:     configuration.body_parsers,
         resolver:    resolver,
         default_app: default_app,
         scheme:      configuration.scheme,
@@ -68,25 +146,27 @@ module Lotus
         port:        configuration.port,
         &configuration.routes
       )
+    end
 
-      application.middleware # preload
+    def _load_rack_middleware!
+      configuration.middleware.load!(application, namespace)
     end
 
-    def finalize!
+    def _assign_routes_to_application_module!
       unless application_module.const_defined?('Routes')
         routes = Lotus::Routes.new(application.routes)
         application_module.const_set('Routes', routes)
       end
-
-      application_module.module_eval %{
-        #{ application_module }::View.load!
-      }
     end
 
     def application_module
       @application_module ||= Utils::Class.load!(
-        Utils::String.new(application.class).namespace
+        Utils::String.new(application.name).namespace
       )
     end
+
+    def namespace
+      configuration.namespace || application_module
+    end
   end
 end

data/lib/lotus/middleware.rb

@@ -6,7 +6,7 @@ module Lotus
   class Middleware
     # Instantiate a middleware stack
     #
-    # @param application [Lotus::Application] the application
+    # @param configuration [Lotus::Configuration] the application's configuration
     #
     # @return [Lotus::Middleware] the new stack
     #
@@ -14,16 +14,29 @@ module Lotus
     # @api private
     #
     # @see Lotus::Configuration
-    # @see http://rdoc.info/gems/rack/Rack/Builder
-    def initialize(application)
-      configuration = application.configuration
-      routes        = application.routes
+    def initialize(configuration)
+      @stack = []
+      @configuration = configuration
+    end
 
+    # Load the middleware stack
+    #
+    # @param application [Lotus::Application] the application loading the middleware
+    #
+    # @return [Lotus::Middleware] the loaded middleware stack
+    #
+    # @since 0.2.0
+    # @api private
+    #
+    # @see http://rdoc.info/gems/rack/Rack/Builder
+    def load!(application, namespace)
+      @namespace = namespace
       @builder = ::Rack::Builder.new
-      @builder.use Rack::Static,
-        urls: configuration.assets.entries,
-        root: configuration.assets
-      @builder.run routes
+      load_default_stack(application)
+      @stack.each { |m, args, block| @builder.use load_middleware(m), *args, &block }
+      @builder.run application.routes
+
+      self
     end
 
     # Process a request.
@@ -38,5 +51,75 @@ module Lotus
     def call(env)
       @builder.call(env)
     end
+
+    # Add a middleware to the stack.
+    #
+    # @param middleware [Object] a Rack middleware
+    # @param *args [Array] optional arguments to pass to the Rack middleware
+    # @param &blk [Proc] an optional block to pass to the Rack middleware
+    #
+    # @return [Array] the middleware that was added
+    #
+    # @since 0.2.0
+    def use(middleware, *args, &blk)
+      @stack << [middleware, args, blk]
+    end
+
+    # @api private
+    # @since 0.2.0
+    def load_middleware(middleware)
+      case middleware
+      when String
+        @namespace.const_get(middleware)
+      else
+        middleware
+      end
+    end
+
+    # @api private
+    # @since 0.2.0
+    def load_default_stack(application)
+      @default_stack_loaded ||= begin
+        _load_session_middleware
+        _load_asset_middlewares
+        _load_default_welcome_page_for(application)
+        use Rack::MethodOverride
+
+        true
+      end
+    end
+
+    # Default welcome page
+    #
+    # @api private
+    # @since 0.2.0
+    def _load_default_welcome_page_for(application)
+      unless application.routes.defined?
+        require 'lotus/welcome'
+        use Lotus::Welcome
+      end
+    end
+
+    # Add session middleware
+    #
+    # @api private
+    # @since 0.2.0
+    def _load_session_middleware
+      if @configuration.sessions.enabled?
+        use(*@configuration.sessions.middleware)
+      end
+    end
+
+    # Add asset middlewares
+    #
+    # @api private
+    # #since 0.2.0
+    def _load_asset_middlewares
+      if @configuration.serve_assets
+        @configuration.assets.entries.each do |path, children|
+          use Rack::Static, urls: children, root: path
+        end
+      end
+    end
   end
 end