hanami 0.0.0 → 0.7.0

data/lib/hanami/mailer/glue.rb

@@ -0,0 +1,68 @@
+require 'hanami/utils/basic_object'
+
+module Hanami::Mailer
+  # @since 0.5.0
+  # @api private
+  class Delivery < ::Hanami::Utils::BasicObject
+    # @since 0.5.0
+    # @api private
+    def initialize(env, &blk)
+      @env = env
+      instance_eval(&blk)
+    end
+
+    # @since 0.5.0
+    # @api private
+    def to_config
+      @config
+    end
+
+    # @since 0.5.0
+    # @api private
+    def test(*args)
+      __setup_config(:test, *args)
+    end
+
+    private
+
+    # @since 0.5.0
+    # @api private
+    def method_missing(m, *args)
+      __setup_config(m, *args)
+    end
+
+    # @since 0.5.0
+    # @api private
+    def __setup_config(env, *args)
+      if env.to_s == @env
+        @config = args
+      end
+    end
+  end
+
+
+  # @since 0.5.0
+  # @api private
+  module Glue
+
+    # @since 0.5.0
+    # @api private
+    def delivery(&blk)
+      raise ArgumentError unless block_given?
+      delivery_method(*Hanami::Mailer::Delivery.new(Hanami.env, &blk).to_config)
+    end
+  end
+
+  Configuration.class_eval do
+    include Glue
+  end
+end
+
+# @since 0.5.0
+# @api private
+module Mailers
+end
+
+Hanami::Mailer.configure do
+  namespace Mailers
+end

data/lib/hanami/middleware.rb

@@ -0,0 +1,143 @@
+module Hanami
+  # Rack middleware stack for an application
+  #
+  # @since 0.1.0
+  # @api private
+  class Middleware
+    # Instantiate a middleware stack
+    #
+    # @param configuration [Hanami::Configuration] the application's configuration
+    #
+    # @return [Hanami::Middleware] the new stack
+    #
+    # @since 0.1.0
+    # @api private
+    #
+    # @see Hanami::Configuration
+    def initialize(configuration)
+      @stack = []
+      @configuration = configuration
+    end
+
+    # Load the middleware stack
+    #
+    # @param application [Hanami::Application] the application loading the middleware
+    #
+    # @return [Hanami::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
+      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.
+    # 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
+
+    # Append 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
+    #
+    # @see Hanami::Middleware#prepend
+    def use(middleware, *args, &blk)
+      @stack.push [middleware, args, blk]
+    end
+
+    # Prepend 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.6.0
+    #
+    # @see Hanami::Middleware#use
+    def prepend(middleware, *args, &blk)
+      @stack.unshift [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_assets_middleware
+        _load_session_middleware
+        _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 Hanami.env?(:test) || application.routes.defined?
+        require 'hanami/welcome'
+        use Hanami::Welcome
+      end
+    end
+
+    # Add session middleware
+    #
+    # @api private
+    # @since 0.2.0
+    def _load_session_middleware
+      if @configuration.sessions.enabled?
+        prepend(*@configuration.sessions.middleware)
+      end
+    end
+
+    # Use static assets middleware
+    #
+    # @api private
+    # @since 0.6.0
+    def _load_assets_middleware
+      env = Hanami.environment
+
+      if !env.container? && env.serve_static_assets?
+        require 'hanami/static'
+        use Hanami::Static
+      end
+    end
+  end
+end

data/lib/hanami/rake_helper.rb

@@ -0,0 +1,68 @@
+require 'rake'
+
+module Hanami
+  # Install Rake tasks in projects
+  #
+  # @since 0.6.0
+  # @api private
+  class RakeHelper
+    include Rake::DSL
+
+    # @since 0.6.0
+    # @api private
+    def self.install_tasks
+      new.install
+    end
+
+    # @since 0.6.0
+    # @api private
+    def install
+      desc "Preload project configuration"
+      task :preload do
+        require 'hanami/environment'
+        Hanami::Environment.new
+      end
+
+      desc "Load the full project"
+      task environment: :preload do
+        require Hanami::Environment.new.env_config
+        Hanami::Application.preload_applications!
+      end
+
+      # Ruby ecosystem compatibility
+      #
+      # Most of the SaaS automatic tasks are designed after Ruby on Rails.
+      # They expect the following Rake tasks to be present:
+      #
+      #   * db:migrate
+      #   * assets:precompile
+      #
+      # See https://github.com/heroku/heroku-buildpack-ruby/issues/442
+      #
+      # ===
+      #
+      # These Rake tasks aren't listed when someone runs `rake -T`, because we
+      # want to encourage developers to use `hanami` commands.
+      #
+      # In order to migrate the database or precompile assets a developer should
+      # use:
+      #
+      #   * hanami db migrate
+      #   * hanami assets precompile
+      #
+      # This is the preferred way to run Hanami command line tasks.
+      # Please use them when you're in control of your deployment environment.
+      namespace :db do
+        task :migrate do
+          system "bundle exec hanami db migrate"
+        end
+      end
+
+      namespace :assets do
+        task :precompile do
+          system "bundle exec hanami assets precompile"
+        end
+      end
+    end
+  end
+end

data/lib/hanami/rake_tasks.rb

@@ -0,0 +1,2 @@
+require 'hanami/rake_helper'
+Hanami::RakeHelper.install_tasks

data/lib/hanami/rendering_policy.rb

@@ -0,0 +1,77 @@
+require 'hanami/utils/class'
+require 'hanami/views/default'
+require 'hanami/views/null_view'
+
+module Hanami
+  # Rendering policy
+  #
+  # @since 0.1.0
+  # @api private
+  class RenderingPolicy
+    STATUS  = 0
+    HEADERS = 1
+    BODY    = 2
+
+    HANAMI_ACTION = 'hanami.action'.freeze
+
+    SUCCESSFUL_STATUSES = (200..201).freeze
+    RENDERABLE_FORMATS  = [:all, :html].freeze
+
+    def initialize(configuration)
+      @controller_pattern = %r{#{ configuration.controller_pattern.gsub(/\%\{(controller|action)\}/) { "(?<#{ $1 }>(.*))" } }}
+      @view_pattern       = configuration.view_pattern
+      @namespace          = configuration.namespace
+      @templates          = configuration.templates
+    end
+
+    def render(env, response)
+      body = _render(env, response)
+
+      response[BODY] = Array(body) unless body.nil? || body.respond_to?(:each)
+      response
+    end
+
+    private
+    def _render(env, response)
+      if action = renderable?(env)
+        _render_action(action, response) ||
+          _render_status_page(action, response)
+      end
+    end
+
+    def _render_action(action, response)
+      if successful?(response)
+        view_for(action, response).render(
+          action.exposures
+        )
+      end
+    end
+
+    def _render_status_page(action, response)
+      if render_status_page?(action, response)
+        Hanami::Views::Default.render(@templates, response[STATUS], response: response, format: :html)
+      end
+    end
+
+    def renderable?(env)
+      ((action = env.delete(HANAMI_ACTION)) && action.renderable? ) and action
+    end
+
+    def successful?(response)
+      SUCCESSFUL_STATUSES.include?(response[STATUS])
+    end
+
+    def render_status_page?(action, response)
+      RENDERABLE_FORMATS.include?(action.format)
+    end
+
+    def view_for(action, response)
+      if response[BODY].respond_to?(:empty?) && 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/hanami/repositories/car_repository.rb

@@ -0,0 +1,3 @@
+class CarRepository
+  include Hanami::Repository
+end

data/lib/hanami/repositories/name_repository.rb

@@ -0,0 +1,3 @@
+class NameRepository
+  include Hanami::Repository
+end

data/lib/hanami/root.rb

@@ -0,0 +1,7 @@
+require 'hanami/environment'
+
+module Hanami
+  def self.root
+    Hanami::Environment.new.root
+  end    
+end

data/lib/hanami/routes.rb

@@ -0,0 +1,151 @@
+require 'hanami/utils/escape'
+
+module Hanami
+  # Routes factory
+  #
+  # A Hanami 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 [Hanami::Router] a routes set
+    #
+    # @return [Hanami::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 [Hanami::Utils::Escape::SafeString] the corresponding relative URL
+    #
+    # @raise Hanami::Routing::InvalidRouteException
+    #
+    # @since 0.1.0
+    #
+    # @see http://rdoc.info/gems/hanami-router/Hanami/Router#path-instance_method
+    #
+    # @example Basic example
+    #   require 'hanami'
+    #
+    #   module Bookshelf
+    #     class Application < Hanami::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'
+    #
+    # @example Dynamic finders
+    #   require 'hanami'
+    #
+    #   module Bookshelf
+    #     class Application < Hanami::Application
+    #       configure do
+    #         routes do
+    #           get '/login', to: 'sessions#new', as: :login
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   Bookshelf::Routes.login_path
+    #     # => '/login'
+    #
+    #   Bookshelf::Routes.login_path(return_to: '/dashboard')
+    #     # => '/login?return_to=%2Fdashboard'
+    def path(name, *args)
+      Utils::Escape::SafeString.new(@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 [Hanami::Utils::Escape::SafeString] the corresponding absolute URL
+    #
+    # @raise Hanami::Routing::InvalidRouteException
+    #
+    # @since 0.1.0
+    #
+    # @see http://rdoc.info/gems/hanami-router/Hanami/Router#url-instance_method
+    #
+    # @example Basic example
+    #   require 'hanami'
+    #
+    #   module Bookshelf
+    #     class Application < Hanami::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'
+    #
+    # @example Dynamic finders
+    #   require 'hanami'
+    #
+    #   module Bookshelf
+    #     class Application < Hanami::Application
+    #       configure do
+    #         routes do
+    #           scheme 'https'
+    #           host   'bookshelf.org'
+    #
+    #           get '/login', to: 'sessions#new', as: :login
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   Bookshelf::Routes.login_url
+    #     # => 'https://bookshelf.org/login'
+    #
+    #   Bookshelf::Routes.login_url(return_to: '/dashboard')
+    #     # => 'https://bookshelf.org/login?return_to=%2Fdashboard'
+    def url(name, *args)
+      Utils::Escape::SafeString.new(@routes.url(name, *args))
+    end
+
+    protected
+    # @since 0.3.0
+    # @api private
+    def method_missing(m, *args)
+      named_route, type = m.to_s.split(/\_(path|url)\z/)
+
+      if type
+        public_send(type, named_route.to_sym, *args)
+      else
+        super
+      end
+    end
+  end
+end