lotusrb 0.1.0 → 0.2.0

data/lib/lotus/application.rb

@@ -14,22 +14,47 @@ module Lotus
   #   require 'lotus'
   #
   #   module Bookshelf
-  #     Application < Lotus::Application
+  #     class Application < Lotus::Application
   #     end
   #   end
   class Application
-    include Lotus::Utils::ClassAttribute
+    # Override Ruby's Class#inherited
+    #
+    # @since 0.2.0
+    # @api private
+    #
+    # @see http://www.ruby-doc.org/core/Class.html#method-i-inherited
+    def self.inherited(base)
+      super
+
+      base.class_eval do
+        include Lotus::Utils::ClassAttribute
 
-    # Application configuration
+        class_attribute :configuration
+        self.configuration = Configuration.new
+      end
+
+      synchronize do
+        applications.add(base)
+      end
+    end
+
+    # Registry of Lotus applications in the current Ruby process
     #
-    # @since 0.1.0
+    # @return [Set] a set of all the registered applications
+    #
+    # @since 0.2.0
     # @api private
-    class_attribute :configuration
-    self.configuration = Configuration.new
+    def self.applications
+      synchronize do
+        @@applications ||= Set.new
+      end
+    end
 
     # Configure the application.
     # It yields the given block in the context of the configuration
     #
+    # @param environment [Symbol,nil] the configuration environment name
     # @param blk [Proc] the configuration block
     #
     # @since 0.1.0
@@ -46,8 +71,8 @@ module Lotus
     #       end
     #     end
     #   end
-    def self.configure(&blk)
-      configuration.configure(&blk)
+    def self.configure(environment = nil, &blk)
+      configuration.configure(environment, &blk)
     end
 
     # Return the routes for this application
@@ -67,16 +92,68 @@ module Lotus
     # @api private
     attr_writer :routes
 
+    # Rendering policy
+    #
+    # @param [Lotus::RenderingPolicy]
+    #
+    # @since 0.2.0
+    # @api private
+    attr_accessor :renderer
+
     # Initialize and load a new instance of the application
     #
     # @return [Lotus::Application] a new instance of the application
     #
     # @since 0.1.0
     def initialize
-      @loader = Lotus::Loader.new(self)
-      @loader.load!
+      self.class.load!(self)
+    end
 
-      @rendering_policy = RenderingPolicy.new(configuration)
+    # Eager load the application configuration, by activating the framework
+    # duplication mechanisms.
+    #
+    # @param application [Lotus::Application, Class<Lotus::Application>]
+    # @return void
+    #
+    # @since 0.1.1
+    #
+    # @example
+    #   require 'lotus'
+    #
+    #   module OneFile
+    #     class Application < Lotus::Application
+    #       configure do
+    #         routes do
+    #           get '/', to: 'dashboard#index'
+    #         end
+    #       end
+    #
+    #       load!
+    #     end
+    #
+    #     module Controllers::Dashboard
+    #       include OneFile::Controller
+    #
+    #       action 'Index' do
+    #         def call(params)
+    #           self.body = 'Hello!'
+    #         end
+    #       end
+    #     end
+    #   end
+    def self.load!(application = self)
+      Lotus::Loader.new(application).load!
+    end
+
+    # Preload all the registered applications
+    #
+    # @return [void]
+    #
+    # @since 0.2.0
+    def self.preload!
+      synchronize do
+        applications.each(&:load!)
+      end
     end
 
     # Return the configuration for this application
@@ -89,6 +166,14 @@ module Lotus
       self.class.configuration
     end
 
+    # Return the application name
+    #
+    # @since 0.2.0
+    # @api private
+    def name
+      self.class.name
+    end
+
     # Process a request.
     # This method makes Lotus applications compatible with the Rack protocol.
     #
@@ -101,9 +186,8 @@ module Lotus
     # @see http://rack.github.io
     # @see Lotus::Application#middleware
     def call(env)
-      middleware.call(env).tap do |response|
-        @rendering_policy.render(response)
-      end
+      renderer.render(env,
+                      middleware.call(env))
     end
 
     # Rack middleware stack
@@ -115,7 +199,19 @@ module Lotus
     #
     # @see Lotus::Middleware
     def middleware
-      @middleware ||= Lotus::Middleware.new(self)
+      @middleware ||= configuration.middleware
+    end
+
+    private
+
+    # Yields the given block in a critical section
+    #
+    # @since 0.2.0
+    # @api private
+    def self.synchronize
+      Mutex.new.synchronize do
+        yield
+      end
     end
   end
 end

data/lib/lotus/cli.rb

@@ -0,0 +1,85 @@
+require 'thor'
+require 'lotus/environment'
+require 'lotus/version'
+
+module Lotus
+  class Cli < Thor
+    include Thor::Actions
+
+    desc 'version', 'prints Lotus version'
+    def version
+      puts Lotus::VERSION
+    end
+
+    desc 'server', 'starts a lotus server'
+    method_option :port,      aliases: '-p', desc: 'The port to run the server on, '
+    method_option :server,                   desc: 'choose a specific Rack::Handler, e.g. webrick, thin etc'
+    method_option :rackup,                   desc: 'a rackup configuration file path to load (config.ru)'
+    method_option :host,                     desc: 'the host address to bind to'
+    method_option :debug,                    desc: 'turn on debug output'
+    method_option :warn,                     desc: 'turn on warnings'
+    method_option :daemonize,                desc: 'if true, the server will daemonize itself (fork, detach, etc)'
+    method_option :pid,                      desc: 'path to write a pid file after daemonize'
+    method_option :environment,              desc: 'path to environment configuration (config/environment.rb)'
+    method_option :code_reloading,           desc: 'code reloading', type: :boolean, default: true
+    method_option :help,      aliases: '-h', desc: 'displays the usage message'
+
+    def server
+      if options[:help]
+        invoke :help, ['server']
+      else
+        require 'lotus/commands/server'
+        Lotus::Commands::Server.new(environment).start
+      end
+    end
+
+    desc 'console', 'starts a lotus console'
+    method_option :environment,           desc: 'path to environment configuration (config/environment.rb)'
+    method_option :engine,                desc: 'choose a specific console engine: irb/pry/ripl (irb)'
+    method_option :help,   aliases: '-h', desc: 'displays the usage method'
+
+    def console
+      if options[:help]
+        invoke :help, ['console']
+      else
+        require 'lotus/commands/console'
+        Lotus::Commands::Console.new(environment).start
+      end
+    end
+
+    desc 'routes', 'prints routes'
+    method_option :environment,                 desc: 'path to environment configuration (config/environment.rb)'
+    method_option :help,         aliases: '-h', desc: 'displays the usage method'
+
+    def routes
+      if options[:help]
+        invoke :help, ['routes']
+      else
+        require 'lotus/commands/routes'
+        Lotus::Commands::Routes.new(environment).start
+      end
+    end
+
+    desc 'new', 'generates a new application'
+    method_option :architecture,   aliases: '-a', desc: 'application architecture', type: :string,  default: 'container'
+    method_option :application,                   desc: 'application name',         type: :string,  default: 'web'
+    method_option :application_base_url,          desc: 'application base url',     type: :string,  default: '/'
+    method_option :lotus_head,                    desc: 'use Lotus HEAD',           type: :boolean, default: false
+    method_option :help,           aliases: '-h', desc: 'displays the usage method'
+
+    def new(name = nil)
+      if options[:help]
+        invoke :help, ['new']
+      else
+        require 'lotus/commands/new'
+        Lotus::Commands::New.new(name, environment, self).start
+      end
+    end
+
+    private
+
+    def environment
+      Lotus::Environment.new(options)
+    end
+  end
+end

data/lib/lotus/commands/console.rb

@@ -0,0 +1,62 @@
+module Lotus
+  module Commands
+    class Console
+      module Methods
+        def reload!
+          puts 'Reloading...'
+          Kernel.exec "#{$0} console"
+        end
+      end
+
+      ENGINES = {
+        'pry'  => 'Pry',
+        'ripl' => 'Ripl',
+        'irb'  => 'IRB'
+      }.freeze
+
+      attr_reader :options
+
+      def initialize(environment)
+        @environment = environment
+        @options     = environment.to_options
+      end
+
+      def start
+        # Clear out ARGV so Pry/IRB don't attempt to parse the rest
+        ARGV.shift until ARGV.empty?
+        require @environment.env_config.to_s
+
+        # Add convenience methods to the main:Object binding
+        TOPLEVEL_BINDING.eval('self').send(:include, Methods)
+        Lotus::Application.preload!
+
+        engine.start
+      end
+
+      def engine
+        load_engine options.fetch(:engine) { engine_lookup }
+      end
+
+      private
+
+      def engine_lookup
+        (ENGINES.find { |_, klass| Object.const_defined?(klass) } || default_engine).first
+      end
+
+      def default_engine
+        ENGINES.to_a.last
+      end
+
+      def load_engine(engine)
+        require engine
+      rescue LoadError
+      ensure
+        return Object.const_get(
+          ENGINES.fetch(engine) {
+            raise ArgumentError.new("Unknown console engine: #{ engine }")
+          }
+        )
+      end
+    end
+  end
+end

data/lib/lotus/commands/new.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+require 'lotus/utils/string'
+require 'lotus/utils/class'
+
+module Lotus
+  module Commands
+    class New
+      GENERATORS_NAMESPACE = "Lotus::Generators::Application::%s".freeze
+
+      attr_reader :app_name, :source, :target, :cli, :options
+
+      def initialize(app_name, environment, cli)
+        @app_name = app_name
+        @options  = environment.to_options
+        @arch     = @options.fetch(:architecture)
+
+        @target   = Pathname.pwd.join(@app_name)
+        @source   = Pathname.new(@options.fetch(:source) { ::File.dirname(__FILE__) + '/../generators/application/' }).join(@arch)
+
+        @cli      = cli
+
+        require "lotus/generators/application/#{ @arch }"
+        command  = Utils::String.new(@arch).classify
+        @command = Utils::Class.load!(GENERATORS_NAMESPACE % command).new(self)
+      end
+
+      def start
+        @command.start
+      end
+    end
+  end
+end

data/lib/lotus/commands/routes.rb

@@ -0,0 +1,14 @@
+module Lotus
+  module Commands
+    class Routes
+      def initialize(environment)
+        @environment = environment
+      end
+
+      def start
+        require @environment.env_config
+        puts Lotus::Container.new.routes.inspector.to_s
+      end
+    end
+  end
+end

data/lib/lotus/commands/server.rb

@@ -0,0 +1,65 @@
+require 'rack'
+
+module Lotus
+  module Commands
+    # Rack compatible server.
+    #
+    # It is run with:
+    #
+    #   `bundle exec lotus server`
+    #
+    # It runs the application, by using the server specified in your `Gemfile`
+    # (eg. Puma or Unicorn).
+    #
+    # It enables code reloading by default.
+    # This feature is implemented via process fork and requires `shotgun` gem.
+    #
+    # @since 0.1.0
+    # @api private
+    class Server < ::Rack::Server
+      attr_reader :options
+
+      def initialize(env)
+        @_env    = env
+        @options = _extract_options(@_env)
+
+        if code_reloading?
+          require 'shotgun'
+          @app = Shotgun::Loader.new(@_env.rackup.to_s)
+        end
+      end
+
+      # Primarily this removes the ::Rack::Chunked middleware
+      # which is the cause of Safari content-length bugs.
+      def middleware
+        mw = Hash.new { |e, m| e[m] = [] }
+        mw["deployment"].concat([::Rack::ContentLength, ::Rack::CommonLogger])
+        mw["development"].concat(mw["deployment"] + [::Rack::ShowExceptions, ::Rack::Lint])
+        mw
+      end
+
+      def start
+        if code_reloading?
+          Shotgun.enable_copy_on_write
+          Shotgun.preload
+        end
+
+        super
+      end
+
+      private
+      def _extract_options(env)
+        env.to_options.merge(
+          config:      env.rackup.to_s,
+          Host:        env.host,
+          Port:        env.port,
+          AccessLog:   []
+        )
+      end
+
+      def code_reloading?
+        @_env.code_reloading?
+      end
+    end
+  end
+end

data/lib/lotus/config/assets.rb

@@ -4,26 +4,40 @@ module Lotus
     #
     # @since 0.1.0
     # @api private
-    class Assets
+    class Assets  < Utils::LoadPaths
       DEFAULT_DIRECTORY = 'public'.freeze
 
-      def initialize(root, directory)
-        @path = root.join(directory || DEFAULT_DIRECTORY)
+      # @since 0.1.0
+      # @api private
+      def initialize(root)
+        @root = root
+        @paths = Array(DEFAULT_DIRECTORY)
       end
 
+      # @since 0.1.0
+      # @api private
       def entries
-        if @path.exist?
-          @path.children.map {|child| "/#{ child.basename }" }
-        else
-          []
+        hash = Hash.new { |k, v| k[v] = [] }
+        each do |path|
+          if path.exist?
+            hash[path.to_s] = path.children.map { |child| "/#{ child.basename }" }
+          end
         end
+        hash
       end
 
-      def to_s
-        @path.to_s
+      # @since 0.2.0
+      # @api private
+      def any?
+        @paths.any?
       end
 
-      alias_method :to_str, :to_s
+      protected
+      # @since 0.1.0
+      # @api private
+      def realpath(path)
+        @root.join(path).realpath
+      end
     end
   end
 end

data/lib/lotus/config/configure.rb

@@ -0,0 +1,17 @@
+require 'lotus/config/mapper'
+
+module Lotus
+  module Config
+    # Define configuration of application of
+    # a specific environment
+    #
+    # @since 0.2.0
+    # @api private
+    class Configure < Mapper
+      private
+      def error_message
+        'You must specify a block or a file for configuration definition'
+      end
+    end
+  end
+end

data/lib/lotus/config/framework_configuration.rb

@@ -0,0 +1,30 @@
+module Lotus
+  module Config
+    # Collects all the settings for a given framework configuration and then
+    # forwards them when the application is loaded.
+    #
+    # @since 0.2.0
+    # @api private
+    class FrameworkConfiguration < BasicObject
+      # @since 0.2.0
+      # @api private
+      def initialize
+        @settings = []
+      end
+
+      # @since 0.2.0
+      # @api private
+      def __apply(configuration)
+        @settings.each do |(m, args, blk)|
+          configuration.public_send(m, *args, &blk)
+        end
+      end
+
+      # @since 0.2.0
+      # @api private
+      def method_missing(m, *args, &blk)
+        @settings.push([m, args, blk])
+      end
+    end
+  end
+end

data/lib/lotus/config/load_paths.rb

@@ -13,7 +13,7 @@ module Lotus
         @root = root
 
         each do |path|
-          Dir.glob(path.join(PATTERN)).each {|file| require file }
+          Dir.glob(path.join(PATTERN)).each { |file| require file }
         end
       end
 

data/lib/lotus/config/sessions.rb

@@ -0,0 +1,97 @@
+require 'ipaddr'
+require 'lotus/utils/string'
+
+module Lotus
+  module Config
+    # Sessions configuration
+    #
+    # @since 0.2.0
+    # @api private
+    class Sessions
+
+      # Ruby namespace for Rack session adapters
+      #
+      # @since 0.2.0
+      # @api private
+      RACK_NAMESPACE = 'Rack::Session::%s'.freeze
+
+      # Localhost string for detecting localhost host configuration
+      #
+      # @since x.x.x
+      # @api private
+      BLACKLISTED_DOMAINS = %w(localhost).freeze
+
+      # HTTP sessions configuration
+      #
+      # @param adapter [Symbol,String,Class] the session adapter
+      # @param options [Hash] the optional session options
+      # @param configuration [Lotus::Configuration] the application configuration
+      #
+      # @since 0.2.0
+      # @api private
+      #
+      # @see http://www.rubydoc.info/github/rack/rack/Rack/Session/Abstract/ID
+      def initialize(adapter = nil, options = {}, configuration = nil)
+        @adapter       = adapter
+        @options       = options
+        @configuration = configuration
+      end
+
+      # Check if the sessions are enabled
+      #
+      # @return [FalseClass,TrueClass] the result of the check
+      #
+      # @since 0.2.0
+      # @api private
+      def enabled?
+        !!@adapter
+      end
+
+      # Returns the Rack middleware and the options
+      #
+      # @return [Array] Rack middleware and options
+      #
+      # @since 0.2.0
+      # @api private
+      def middleware
+        middleware = case @adapter
+                     when Symbol
+                       RACK_NAMESPACE % Utils::String.new(@adapter).classify
+                     else
+                       @adapter
+                     end
+
+        [middleware, options]
+      end
+
+      private
+
+      # @since 0.2.0
+      # @api private
+      def options
+        default_options.merge(@options)
+      end
+
+      # @since 0.2.0
+      # @api private
+      def default_options
+        if @configuration
+          { domain: domain, secure: @configuration.ssl? }
+        else
+          {}
+        end
+      end
+
+      def domain
+        domain = @configuration.host
+        if !BLACKLISTED_DOMAINS.include?(domain) && !ip_address?(domain)
+          domain
+        end
+      end
+
+      def ip_address?(string)
+        !!IPAddr.new(string) rescue false
+      end
+    end
+  end
+end