lotusrb 0.0.0 → 0.1.0

data/lib/lotus/frameworks.rb

@@ -0,0 +1,40 @@
+require 'lotus/router'
+require 'lotus/controller'
+require 'lotus/view'
+
+# FIXME Ideally, this should be done like this:
+#
+# module Lotus
+#   module Frameworks
+#     module Action
+#       module Rack
+#         protected
+#         def response
+#           [super, self].flatten
+#         end
+#       end
+#     end
+#   end
+# end
+#
+# Lotus::Action::Rack.class_eval do
+#   include Lotus::Frameworks::Action::Rack
+# end
+#
+# ..but it doesn't work and I want to ship it!
+
+Lotus::Action::Rack.class_eval do
+  DEFAULT_RESPONSE_CODE = 200
+  DEFAULT_RESPONSE_BODY = []
+
+  protected
+  def response
+    [ @_status || DEFAULT_RESPONSE_CODE, headers, @_body || DEFAULT_RESPONSE_BODY.dup, self ]
+  end
+end
+
+Lotus::Action.class_eval do
+  def to_rendering
+    exposures.merge(format: format)
+  end
+end

data/lib/lotus/loader.rb

@@ -0,0 +1,92 @@
+require 'lotus/utils/class'
+require 'lotus/utils/kernel'
+require 'lotus/utils/string'
+require 'lotus/routes'
+require 'lotus/routing/default'
+
+module Lotus
+  # Load an application
+  #
+  # @since 0.1.0
+  # @api private
+  class Loader
+    def initialize(application)
+      @application   = application
+      @configuration = @application.configuration
+
+      @mutex = Mutex.new
+    end
+
+    def load!
+      @mutex.synchronize do
+        load_configuration!
+        load_frameworks!
+        load_application!
+        finalize!
+      end
+    end
+
+    private
+    attr_reader :application, :configuration
+
+    def load_configuration!
+      configuration.load!(application_module)
+    end
+
+    def load_frameworks!
+      config = configuration
+
+      unless application_module.const_defined?('Controller')
+        controller = Lotus::Controller.duplicate(application_module) do
+          default_format config.default_format
+        end
+
+        application_module.const_set('Controller', controller)
+      end
+
+      unless application_module.const_defined?('View')
+        view = Lotus::View.duplicate(application_module) do
+          root   config.templates
+          layout config.layout
+        end
+
+        application_module.const_set('View', view)
+      end
+    end
+
+    def load_application!
+      configuration.load_paths.load!(configuration.root)
+      namespace = configuration.namespace || application_module
+
+      resolver    = Lotus::Routing::EndpointResolver.new(pattern: configuration.controller_pattern, namespace: namespace)
+      default_app = Lotus::Routing::Default.new
+      application.routes = Lotus::Router.new(
+        resolver:    resolver,
+        default_app: default_app,
+        scheme:      configuration.scheme,
+        host:        configuration.host,
+        port:        configuration.port,
+        &configuration.routes
+      )
+
+      application.middleware # preload
+    end
+
+    def finalize!
+      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
+      )
+    end
+  end
+end

data/lib/lotus/middleware.rb

@@ -0,0 +1,42 @@
+module Lotus
+  # Rack middleware stack for an application
+  #
+  # @since 0.1.0
+  # @api private
+  class Middleware
+    # Instantiate a middleware stack
+    #
+    # @param application [Lotus::Application] the application
+    #
+    # @return [Lotus::Middleware] the new stack
+    #
+    # @since 0.1.0
+    # @api private
+    #
+    # @see Lotus::Configuration
+    # @see http://rdoc.info/gems/rack/Rack/Builder
+    def initialize(application)
+      configuration = application.configuration
+      routes        = application.routes
+
+      @builder = ::Rack::Builder.new
+      @builder.use Rack::Static,
+        urls: configuration.assets.entries,
+        root: configuration.assets
+      @builder.run routes
+    end
+
+    # Process a request.
+    # This method makes the middleware stack compatible with the Rack protocol.
+    #
+    # @param env [Hash] a Rack env
+    #
+    # @return [Array] a serialized Rack response
+    #
+    # @since 0.1.0
+    # @api private
+    def call(env)
+      @builder.call(env)
+    end
+  end
+end

data/lib/lotus/rendering_policy.rb

@@ -0,0 +1,69 @@
+require 'lotus/utils/class'
+require 'lotus/views/default'
+require 'lotus/views/null_view'
+
+module Lotus
+  # Rendering policy
+  #
+  # @since 0.1.0
+  # @api private
+  class RenderingPolicy
+    STATUS  = 0
+    HEADERS = 1
+    BODY    = 2
+
+    RACK_RESPONSE_SIZE = 3
+
+    SUCCESSFUL_STATUSES   = (200..201).freeze
+    STATUSES_WITHOUT_BODY = Set.new((100..199).to_a << 204 << 205 << 301 << 302 << 304).freeze
+    RENDERABLE_FORMATS    = [:all, :html].freeze
+    CONTENT_TYPE          = 'Content-Type'.freeze
+
+    def initialize(configuration)
+      @controller_pattern = %r{#{ configuration.controller_pattern.gsub(/\%\{(controller|action)\}/) { "(?<#{ $1 }>(.*))" } }}
+      @view_pattern       = configuration.view_pattern
+      @namespace          = configuration.namespace
+    end
+
+    def render(response)
+      if renderable?(response)
+        action = response.pop
+
+        body = if successful?(response)
+          view_for(response, action).render(
+            action.to_rendering
+          )
+        else
+          if render_status_page?(response, action)
+            Lotus::Views::Default.render(response: response, format: :html)
+          end
+        end
+
+        response[BODY] = Array(body) if body
+      end
+    end
+
+    private
+    def renderable?(response)
+      response.size > RACK_RESPONSE_SIZE
+    end
+
+    def successful?(response)
+      SUCCESSFUL_STATUSES.include?(response[STATUS])
+    end
+
+    def render_status_page?(response, action)
+      RENDERABLE_FORMATS.include?(action.format) &&
+        !STATUSES_WITHOUT_BODY.include?(response[STATUS])
+    end
+
+    def view_for(response, action)
+      if response[BODY].empty?
+        captures = @controller_pattern.match(action.class.name)
+        Utils::Class.load!(@view_pattern % { controller: captures[:controller], action: captures[:action] }, @namespace)
+      else
+        Views::NullView.new(response[BODY])
+      end
+    end
+  end
+end

data/lib/lotus/routes.rb

@@ -0,0 +1,95 @@
+module Lotus
+  # Routes factory
+  #
+  # A Lotus application has this factory instantiated by default and associated
+  # to the `Routes` constant, under the application namespace.
+  #
+  # @since 0.1.0
+  class Routes
+    # Initialize the factory
+    #
+    # @param routes [Lotus::Router] a routes set
+    #
+    # @return [Lotus::Routes] the factory
+    #
+    # @since 0.1.0
+    def initialize(routes)
+      @routes = routes
+    end
+
+    # Return a relative path for the given route name
+    #
+    # @param name [Symbol] the route name
+    # @param args [Array,nil] an optional set of arguments that is passed down
+    #   to the wrapped route set.
+    #
+    # @return [String] the corresponding relative URL
+    #
+    # @raise Lotus::Routing::InvalidRouteException
+    #
+    # @since 0.1.0
+    #
+    # @see http://rdoc.info/gems/lotus-router/Lotus/Router#path-instance_method
+    #
+    # @example
+    #   require 'lotus'
+    #
+    #   module Bookshelf
+    #     class Application < Lotus::Application
+    #       configure do
+    #         routes do
+    #           get '/login', to: 'sessions#new', as: :login
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   Bookshelf::Routes.path(:login)
+    #     # => '/login'
+    #
+    #   Bookshelf::Routes.path(:login, return_to: '/dashboard')
+    #     # => '/login?return_to=%2Fdashboard'
+    def path(name, *args)
+      @routes.path(name, *args)
+    end
+
+    # Return an absolute path for the given route name
+    #
+    # @param name [Symbol] the route name
+    # @param args [Array,nil] an optional set of arguments that is passed down
+    #   to the wrapped route set.
+    #
+    # @return [String] the corresponding absolute URL
+    #
+    # @raise Lotus::Routing::InvalidRouteException
+    #
+    # @since 0.1.0
+    #
+    # @see http://rdoc.info/gems/lotus-router/Lotus/Router#url-instance_method
+    #
+    # @example
+    #   require 'lotus'
+    #
+    #   module Bookshelf
+    #     class Application < Lotus::Application
+    #       configure do
+    #         routes do
+    #           scheme 'https'
+    #           host   'bookshelf.org'
+    #
+    #           get '/login', to: 'sessions#new', as: :login
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   Bookshelf::Routes.url(:login)
+    #     # => 'https://bookshelf.org/login'
+    #
+    #   Bookshelf::Routes.url(:login, return_to: '/dashboard')
+    #     # => 'https://bookshelf.org/login?return_to=%2Fdashboard'
+    def url(name, *args)
+      @routes.url(name, *args)
+    end
+  end
+end

data/lib/lotus/routing/default.rb

@@ -0,0 +1,25 @@
+module Lotus
+  module Routing
+    # The default Rack application that responds when a resource cannot be found.
+    #
+    # @since 0.1.0
+    # @api private
+    class Default
+      DEFAULT_CODE = 404
+      DEFAULT_BODY = ['Not Found'].freeze
+      CONTENT_TYPE = 'Content-Type'.freeze
+
+      class NullAction
+        include Lotus::Action
+
+        def call(env)
+        end
+      end
+
+      def call(env)
+        action = NullAction.new.tap {|a| a.call(env) }
+        [ DEFAULT_CODE, {CONTENT_TYPE => action.content_type}, DEFAULT_BODY, action ]
+      end
+    end
+  end
+end

data/lib/lotus/templates/default.html.erb

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%= title %></title>
+  </head>
+  <body>
+    <h1><%= title %></h1>
+  </body>
+</html>

data/lib/lotus/version.rb

@@ -0,0 +1,6 @@
+module Lotus
+  # Defines the version
+  #
+  # @since 0.1.0
+  VERSION = '0.1.0'.freeze
+end

data/lib/lotus/views/default.rb

@@ -0,0 +1,20 @@
+module Lotus
+  module Views
+    # The default view that is rendered for non successful responses (200 and 201)
+    #
+    # @since 0.1.0
+    # @api private
+    class Default
+      include Lotus::View
+      configuration.reset!
+
+      layout nil
+      root Pathname.new(File.dirname(__FILE__)).join('../templates').realpath
+      template 'default'
+
+      def title
+        response[2].first
+      end
+    end
+  end
+end

data/lib/lotus/views/null_view.rb

@@ -0,0 +1,17 @@
+module Lotus
+  module Views
+    # Null Object pattern for views
+    #
+    # @since 0.1.0
+    # @api private
+    class NullView
+      def initialize(body)
+        @body = body
+      end
+
+      def render(context)
+        @body
+      end
+    end
+  end
+end

data/lib/lotusrb.rb

@@ -1,5 +1 @@
-require "lotusrb/version"
-
-module Lotusrb
-  # Your code goes here...
-end
+require_relative 'lotus'

data/lotusrb.gemspec

@@ -1,23 +1,30 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'lotusrb/version'
+require 'lotus/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "lotusrb"
-  spec.version       = Lotusrb::VERSION
-  spec.authors       = ["Luca Guidi"]
-  spec.email         = ["me@lucaguidi.com"]
-  spec.summary       = %q{Full stack web framework for Ruby}
-  spec.description   = %q{Full stack web framework for Ruby}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.name          = 'lotusrb'
+  spec.version       = Lotus::VERSION
+  spec.authors       = ['Luca Guidi']
+  spec.email         = ['me@lucaguidi.com']
+  spec.summary       = %q{A complete web framework for Ruby}
+  spec.description   = %q{A complete web framework for Ruby}
+  spec.homepage      = 'http://lotusrb.org'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files -z -- lib/* LICENSE.md README.md lotusrb.gemspec`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.test_files    = spec.files.grep(%r{^(test)/})
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
+  spec.add_dependency 'lotus-utils',      '~> 0.2'
+  spec.add_dependency 'lotus-router',     '~> 0.1', '>= 0.1.1'
+  spec.add_dependency 'lotus-controller', '~> 0.2'
+  spec.add_dependency 'lotus-view',       '~> 0.2'
+
+  spec.add_development_dependency 'bundler',   '~> 1.6'
+  spec.add_development_dependency 'rake',      '~> 10'
+  spec.add_development_dependency 'minitest',  '~> 5'
+  spec.add_development_dependency 'rack-test', '~> 0.6'
 end