hanami 0.0.0 → 0.7.0

data/lib/hanami/generators/database_config.rb

@@ -0,0 +1,99 @@
+require 'shellwords'
+
+module Hanami
+  module Generators
+    class DatabaseConfig
+
+      SUPPORTED_ENGINES = {
+        'mysql'      => { type: :sql,         mri: 'mysql2',  jruby: 'jdbc-mysql'    },
+        'mysql2'     => { type: :sql,         mri: 'mysql2',  jruby: 'jdbc-mysql'    },
+        'postgresql' => { type: :sql,         mri: 'pg',      jruby: 'jdbc-postgres' },
+        'postgres'   => { type: :sql,         mri: 'pg',      jruby: 'jdbc-postgres' },
+        'sqlite'     => { type: :sql,         mri: 'sqlite3', jruby: 'jdbc-sqlite3'  },
+        'sqlite3'    => { type: :sql,         mri: 'sqlite3', jruby: 'jdbc-sqlite3'  },
+        'filesystem' => { type: :file_system, mri: nil,       jruby: nil             },
+        'memory'     => { type: :memory,      mri: nil,       jruby: nil             }
+      }.freeze
+
+      DEFAULT_ENGINE = 'filesystem'.freeze
+
+      attr_reader :engine, :name
+
+      def initialize(engine, name)
+        @engine = engine
+        @name = name
+
+        SUPPORTED_ENGINES.key?(engine.to_s) or fail "\"#{ engine }\" is not a valid database type"
+      end
+
+      def to_hash
+        {
+          gem: gem,
+          uri: uri,
+          type: type
+        }
+      end
+
+      def type
+        SUPPORTED_ENGINES[engine][:type]
+      end
+
+      def sql?
+        type == :sql
+      end
+
+      def filesystem?
+        type == :file_system
+      end
+
+      private
+
+      def platform
+        Hanami::Utils.jruby? ? :jruby : :mri
+      end
+
+      def platform_prefix
+        'jdbc:'.freeze if Hanami::Utils.jruby?
+      end
+
+      def uri
+        {
+          development: environment_uri(:development),
+          test: environment_uri(:test)
+        }
+      end
+
+      def gem
+        SUPPORTED_ENGINES[engine][platform]
+      end
+
+      def base_uri
+        case engine
+        when 'mysql', 'mysql2'
+          if Hanami::Utils.jruby?
+            "mysql://localhost/#{ name }"
+          else
+            "mysql2://localhost/#{ name }"
+          end
+        when 'postgresql', 'postgres'
+          "postgres://localhost/#{ name }"
+        when 'sqlite', 'sqlite3'
+          "sqlite://db/#{ Shellwords.escape(name) }"
+        when 'memory'
+          "memory://localhost/#{ name }"
+        when 'filesystem'
+          "file:///db/#{ Shellwords.escape(name) }"
+        end
+      end
+
+      def environment_uri(environment)
+        case engine
+        when 'sqlite', 'sqlite3'
+          "#{ platform_prefix }#{ base_uri }_#{ environment }.sqlite"
+        else
+          "#{ platform_prefix if sql? }#{ base_uri }_#{ environment }"
+        end
+      end
+    end
+  end
+end

data/lib/hanami/generators/generatable.rb

@@ -0,0 +1,51 @@
+require 'hanami/generators/generator'
+
+module Hanami
+  module Generators
+    module Generatable
+
+      def start
+        map_templates
+        process_templates
+      end
+
+      def destroy
+        generator.behavior = :revoke
+        self
+      end
+
+      def generator
+        @generator ||= Hanami::Generators::Generator.new(template_source_path, target_path)
+      end
+
+      def map_templates
+        raise NotImplementedError, "must implement the map_templates method"
+      end
+
+      def add_mapping(source, target)
+        generator.add_mapping(source, target)
+      end
+
+      def process_templates
+        generator.process_templates(template_options)
+        post_process_templates
+      end
+
+      def post_process_templates
+        nil
+      end
+
+      def template_options
+        {}
+      end
+
+      def template_source_path
+        raise NotImplementedError, "must implement the template_source_path method"
+      end
+
+      def target_path
+        raise NotImplementedError, "must implement the target_path method"
+      end
+    end
+  end
+end

data/lib/hanami/generators/generator.rb

@@ -0,0 +1,35 @@
+require 'thor'
+require 'forwardable'
+
+module Hanami
+  module Generators
+    class Generator
+
+      extend Forwardable
+
+      def_delegators :@processor, :run, :behavior=, :inject_into_file, :append_to_file, :prepend_to_file
+
+      class Processor < Thor
+        include Thor::Actions
+      end
+
+      def initialize(template_source_path, target_path)
+        @template_source_path = template_source_path
+        @target_path = target_path
+        @template_mappings = []
+        @processor = Processor.new
+        @processor.class.source_root(@template_source_path)
+      end
+
+      def add_mapping(source, target)
+        @template_mappings << [source, target]
+      end
+
+      def process_templates(options = {})
+        @template_mappings.each do |src, dst|
+          @processor.template(@template_source_path.join(src), @target_path.join(dst), options)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/generators/mailer/mailer.rb.tt

@@ -0,0 +1,7 @@
+class Mailers::<%= config[:mailer] %>
+  include Hanami::Mailer
+
+  from    <%= config[:from] %>
+  to      <%= config[:to] %>
+  subject <%= config[:subject] %>
+end

data/lib/hanami/generators/mailer/mailer_spec.rb.tt

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Mailers::<%= config[:mailer] %> do
+  it 'delivers email' do
+    mail = Mailers::<%= config[:mailer] %>.deliver
+  end
+end

data/lib/hanami/generators/migration/migration.rb.tt

@@ -0,0 +1,4 @@
+Hanami::Model.migration do
+  change do
+  end
+end

data/lib/hanami/generators/model/entity.rb.tt

@@ -0,0 +1,3 @@
+class <%= config[:model_name] %>
+  include Hanami::Entity
+end

data/lib/hanami/generators/model/entity_spec.minitest.tt

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe <%= config[:model_name] %> do
+  # place your tests here
+end

data/lib/hanami/generators/model/entity_spec.rspec.tt

@@ -0,0 +1,3 @@
+RSpec.describe <%= config[:model_name] %> do
+  # place your tests here
+end

data/lib/hanami/generators/model/repository.rb.tt

@@ -0,0 +1,3 @@
+class <%= config[:model_name] %>Repository
+  include Hanami::Repository
+end

data/lib/hanami/generators/model/repository_spec.minitest.tt

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe <%= config[:model_name] %>Repository do
+  # place your tests here
+end

data/lib/hanami/generators/model/repository_spec.rspec.tt

@@ -0,0 +1,3 @@
+RSpec.describe <%= config[:model_name] %>Repository do
+  # place your tests here
+end

data/lib/hanami/generators/test_framework.rb

@@ -0,0 +1,42 @@
+require 'hanami/hanamirc'
+module Hanami
+  module Generators
+    class TestFramework
+      RSPEC = 'rspec'.freeze
+      MINITEST = 'minitest'.freeze
+      VALID_FRAMEWORKS = [RSPEC, MINITEST].freeze
+
+      attr_reader :framework
+
+      def initialize(hanamirc, framework)
+        @framework = (framework || hanamirc.options.fetch(:test))
+        assert_framework!
+      end
+
+      def rspec?
+        framework == RSPEC
+      end
+
+      def minitest?
+        framework == MINITEST
+      end
+
+      private
+
+      def assert_framework!
+        if !supported_framework?
+          raise ArgumentError.new("Unknown test framework '#{ framework}'. Please use one of #{ valid_test_frameworks.join(', ')}")
+        end
+      end
+
+      def valid_test_frameworks
+        VALID_FRAMEWORKS.map { |name| "'#{ name }'"}
+      end
+
+      def supported_framework?
+        VALID_FRAMEWORKS.include?(framework)
+      end
+
+    end
+  end
+end

data/lib/hanami/hanamirc.rb

@@ -0,0 +1,152 @@
+require 'pathname'
+require 'dotenv/parser'
+require 'hanami/utils/hash'
+
+module Hanami
+  # Read the .hanamirc file in the root of the application
+  #
+  # @since 0.3.0
+  # @api private
+  class Hanamirc
+    # Hanamirc name file
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @see Hanami::Hanamirc#path_file
+    FILE_NAME = '.hanamirc'.freeze
+
+    # Architecture default value
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @see Hanami::Hanamirc#options
+    DEFAULT_ARCHITECTURE = 'container'.freeze
+
+    # Application architecture value
+    #
+    # @since 0.6.0
+    # @api private
+    APP_ARCHITECTURE = 'app'.freeze
+
+    # Architecture key for writing the hanamirc file
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @see Hanami::Hanamirc::DEFAULT_OPTIONS
+    ARCHITECTURE_KEY = 'architecture'.freeze
+
+    # Test suite default value
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @see Hanami::Hanamirc::DEFAULT_OPTIONS
+    DEFAULT_TEST_SUITE = 'minitest'.freeze
+
+    # Test suite key for writing the hanamirc file
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @see Hanami::Hanamirc::DEFAULT_OPTIONS
+    TEST_KEY = 'test'.freeze
+
+    # Template default value
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @see Hanami::Hanamirc::DEFAULT_OPTIONS
+    DEFAULT_TEMPLATE = 'erb'.freeze
+
+    # Template key for writing the hanamirc file
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @see Hanami::Hanamirc::DEFAULT_OPTIONS
+    TEMPLATE_KEY = 'template'.freeze
+
+    # Default values for writing the hanamirc file
+    #
+    # @since 0.5.1
+    # @api private
+    #
+    # @see Hanami::Hanamirc#options
+    DEFAULT_OPTIONS = Utils::Hash.new({
+      ARCHITECTURE_KEY => DEFAULT_ARCHITECTURE,
+      TEST_KEY         => DEFAULT_TEST_SUITE,
+      TEMPLATE_KEY     => DEFAULT_TEMPLATE
+    }).symbolize!.freeze
+
+    # Initialize Hanamirc class with application's root and environment options.
+    #
+    # @param root [Pathname] Application's root
+    #
+    # @see Hanami::Environment#initialize
+    def initialize(root)
+      @root = root
+    end
+
+    # Read hanamirc file (if exists) and parse it's values or return default.
+    #
+    # @return [Hanami::Utils::Hash] parsed values
+    #
+    # @example Default values if file doesn't exist
+    #   Hanami::Hanamirc.new(Pathname.new(Dir.pwd)).options
+    #    # => { architecture: 'container', test: 'minitest', template: 'erb' }
+    #
+    # @example Custom values if file doesn't exist
+    #   options = { architect: 'application', test: 'rspec', template: 'slim' }
+    #   Hanami::Hanamirc.new(Pathname.new(Dir.pwd), options).options
+    #    # => { architecture: 'application', test: 'rspec', template: 'slim' }
+    def options
+      @options ||= symbolize(DEFAULT_OPTIONS.merge(file_options))
+    end
+
+    # Check if hanamirc file exists
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @return [Boolean] hanamirc file's path existing
+    def exists?
+      path_file.exist?
+    end
+
+    private
+
+    def symbolize(hash)
+      Utils::Hash.new(hash).symbolize!
+    end
+
+    def file_options
+      symbolize(exists? ? Dotenv::Parser.call(content) : {})
+    end
+
+    # Return the hanamirc file's path
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @return [Pathname] hanamirc file's path
+    #
+    # @see Hanami::Hanamirc::FILE_NAME
+    def path_file
+      @root.join FILE_NAME
+    end
+
+    # Return the content of hanamirc file
+    #
+    # @since 0.3.0
+    # @api private
+    #
+    # @return [String] content of hanamirc file
+    def content
+      path_file.read
+    end
+  end
+end

data/lib/hanami/loader.rb

@@ -0,0 +1,258 @@
+require 'hanami/utils/class'
+require 'hanami/utils/kernel'
+require 'hanami/utils/string'
+require 'hanami/routes'
+require 'hanami/routing/default'
+require 'hanami/action/session'
+require 'hanami/config/security'
+require 'hanami/action/routing_helpers'
+
+module Hanami
+  # Load an application
+  #
+  # @since 0.1.0
+  # @api private
+  class Loader
+
+    STRICT_TRANSPORT_SECURITY_HEADER = 'Strict-Transport-Security'.freeze
+    STRICT_TRANSPORT_SECURITY_DEFAULT_VALUE = 'max-age=31536000'.freeze
+
+    def initialize(application)
+      @application   = application
+      @configuration = @application.configuration
+
+      @mutex = Mutex.new
+    end
+
+    def load!
+      @mutex.synchronize do
+        load_configuration!
+        configure_frameworks!
+        load_configuration_load_paths!
+        load_rack!
+        load_frameworks!
+        load_initializers!
+      end
+    end
+
+    private
+    attr_reader :application, :configuration
+
+    def load_configuration!
+      configuration.load!(application_module)
+    end
+
+    def configure_frameworks!
+      _configure_model_framework! if defined?(Hanami::Model)
+      _configure_controller_framework!
+      _configure_view_framework!
+      _configure_assets_framework!
+      _configure_logger!
+    end
+
+    def _configure_controller_framework!
+      config = configuration
+      unless namespace.const_defined?('Controller')
+        controller = Hanami::Controller.duplicate(namespace) do
+          handle_exceptions config.handle_exceptions
+          default_request_format config.default_request_format
+          default_response_format config.default_response_format
+          default_headers({
+            Hanami::Config::Security::X_FRAME_OPTIONS_HEADER         => config.security.x_frame_options,
+            Hanami::Config::Security::CONTENT_SECURITY_POLICY_HEADER => config.security.content_security_policy
+          })
+          default_headers.merge!(STRICT_TRANSPORT_SECURITY_HEADER => STRICT_TRANSPORT_SECURITY_DEFAULT_VALUE) if config.force_ssl
+
+          if config.cookies.enabled?
+            require 'hanami/action/cookies'
+            prepare { include Hanami::Action::Cookies }
+            cookies config.cookies.default_options
+          end
+
+          if config.sessions.enabled?
+            prepare do
+              include Hanami::Action::Session
+              include Hanami::Action::CSRFProtection
+            end
+          end
+
+          prepare { include Hanami::Action::RoutingHelpers }
+
+          config.controller.__apply(self)
+        end
+
+        namespace.const_set('Controller', controller)
+      end
+    end
+
+    def _configure_view_framework!
+      config = configuration
+      unless namespace.const_defined?('View')
+        view = Hanami::View.duplicate(namespace) do
+          root   config.templates
+          layout config.layout
+
+          config.view.__apply(self)
+        end
+
+        namespace.const_set('View', view)
+      end
+    end
+
+    def _configure_assets_framework!
+      config = configuration
+
+      unless application_module.const_defined?('Assets')
+        assets = Hanami::Assets.duplicate(namespace) do
+          root             config.root
+
+          scheme           config.scheme
+          host             config.host
+          port             config.port
+
+          public_directory Hanami.public_directory
+          prefix           Utils::PathPrefix.new('/assets').join(config.path_prefix)
+
+          manifest         Hanami.public_directory.join('assets.json')
+          compile          true
+
+          config.assets.__apply(self)
+        end
+
+        assets.configure do
+          cdn host != config.host
+        end
+
+        application_module.const_set('Assets', assets)
+      end
+    end
+
+    def _configure_model_framework!
+      config = configuration
+      if _hanami_model_loaded? && !application_module.const_defined?('Model')
+        model = Hanami::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 _configure_logger!
+      unless application_module.const_defined?('Logger', false)
+        if configuration.logger.nil?
+          configuration.logger Hanami::Logger.new(application_module.to_s)
+        end
+        application_module.const_set('Logger', configuration.logger)
+      end
+    end
+
+    def load_frameworks!
+      _load_view_framework!
+      _load_assets_framework!
+      _load_model_framework!
+    end
+
+    def _load_view_framework!
+      namespace.module_eval %{
+        #{ namespace }::View.load!
+      }
+    end
+
+    def _load_assets_framework!
+      application_module.module_eval %{
+        #{ application_module }::Assets.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 _hanami_model_loaded? && application_module.const_defined?('Model')
+        model = application_module.const_get('Model')
+        model.configuration.adapter
+      end
+    end
+
+    def _hanami_model_loaded?
+      defined?(Hanami::Model)
+    end
+
+    def _hanami_mailer_loaded?
+      defined?(Hanami::Mailer)
+    end
+
+    def load_configuration_load_paths!
+      configuration.load_paths.load!(configuration.root)
+    end
+
+    def load_rack!
+      _assign_routes_to_application_module!
+
+      return if application.is_a?(Class)
+      _assign_rendering_policy!
+      _assign_rack_routes!
+      _load_rack_middleware!
+    end
+
+    def _assign_rendering_policy!
+      application.renderer = RenderingPolicy.new(configuration)
+    end
+
+    def _assign_rack_routes!
+      application.routes = application_routes
+    end
+
+    def _load_rack_middleware!
+      configuration.middleware.load!(application, namespace)
+    end
+
+    def _assign_routes_to_application_module!
+      unless application_module.const_defined?('Routes')
+        routes = Hanami::Routes.new(application_routes)
+        application_module.const_set('Routes', routes)
+      end
+    end
+
+    def application_module
+      @application_module ||= Utils::Class.load!(
+        Utils::String.new(application.name).namespace
+      )
+    end
+
+    def application_routes
+      resolver    = Hanami::Routing::EndpointResolver.new(pattern: configuration.controller_pattern, namespace: namespace)
+      default_app = Hanami::Routing::Default.new
+      Hanami::Router.new(
+        parsers:     configuration.body_parsers,
+        resolver:    resolver,
+        default_app: default_app,
+        scheme:      configuration.scheme,
+        host:        configuration.host,
+        port:        configuration.port,
+        prefix:      configuration.path_prefix,
+        force_ssl:   configuration.force_ssl,
+        &configuration.routes
+      )
+    end
+
+    def namespace
+      configuration.namespace || application_module
+    end
+
+    def load_initializers!
+      Dir["#{configuration.root}/config/initializers/**/*.rb"].each do |file|
+        require file
+      end
+    end
+  end
+end