appfuel 0.2.0

data/lib/appfuel/application/container_class_registration.rb

@@ -0,0 +1,22 @@
+module Appfuel
+  module Application
+    module ContainerClassRegistration
+      # All handlers are automatically registered into the application
+      # container which allows them to easily be retrieved for execution.
+      # The ContainerKey mixin handles converting ruby class namespaces to
+      # container key, so we simply need to obtain the qualified namespace
+      # key for this class extending this, that does not belong to appfuel.
+      #
+      # @param klass [Class] the handler class that is inheriting this
+      # @return [Boolean]
+      def register_container_class(klass)
+        root = klass.container_root_name
+        return false if root == 'appfuel'
+
+        container = Appfuel.app_container(root)
+        container.register(klass.container_qualified_key, klass)
+        true
+      end
+    end
+  end
+end

data/lib/appfuel/application/container_key.rb

@@ -0,0 +1,201 @@
+module Appfuel
+  module Application
+    # Mixins to allow you to handle application container keys. The application
+    # container operates based on certain conventions which we take into account
+    # here.
+    module ContainerKey
+      # Parse the namespace assuming it is a ruby namespace and assign
+      # the list to container_path_list
+      #
+      # @param namespace [String]
+      # @return [Array]
+      def load_path_from_ruby_namespace(namespace)
+        self.container_path = parse_list_string(namespace, '::')
+      end
+
+      # Parse the namespace assuming it is a dry container namespace and
+      # assign the list to container_path_list
+      #
+      # @param namespace [String]
+      # @return [Array]
+      def load_path_from_container_namespace(namespace)
+        self.container_path = parse_list_string(namespace, '.')
+      end
+
+      # @param namespace [String] encoded string that represents a path
+      # @param char [String] character used to split the keys into a list
+      # @return [Array] an array of lower case snake cased strings
+      def parse_list_string(namespace, char)
+        fail "split char must be '.' or '::'" unless ['.', '::'].include?(char)
+        namespace.to_s.split(char).map {|i| i.underscore }
+      end
+
+      # return [Boolean]
+      def container_path?
+        !@container_path.nil?
+      end
+
+      # @param list [Array] list of container namespace parts including root
+      # @return [Array]
+      def container_path=(list)
+        fail "container path list must be an array" unless list.is_a?(Array)
+        @container_path = list
+        @container_path.freeze
+      end
+
+      # An array representation of the application container namespace, where
+      # the root is the name of the application and not part of the namespace
+      # and the rest is hierarchical path to features or globals
+      #
+      # @return [Array]
+      def container_path
+        load_path_from_ruby_namespace(self.to_s) unless container_path?
+        @container_path
+      end
+
+      # This is the application name used to identify the application container
+      # that is stored in the framework container
+      #
+      # @return string
+      def container_root_name
+        @container_root_name ||= container_path.first
+      end
+
+      # All root namespace for anything inside features, use this name. It is
+      # important to note that to avoid long namespace in ruby features are the
+      # name of the module directly below the root.
+      #
+      # @return [String]
+      def container_features_root_name
+        @container_features_root_name ||= 'features'
+      end
+
+      # The actual name of the feature
+      #
+      # @return [String]
+      def container_feature_name
+        container_path[1]
+      end
+
+      # The feature name is the second item in the path, that is always prexfix
+      # with "features"
+      #
+      # @return [String]
+      def container_feature_key
+        @container_feature_key ||= (
+          "#{container_features_root_name}.#{container_feature_name}"
+        )
+      end
+
+      # Container key relative from feature or global, depending on which class
+      # this is mixed into
+      #
+      # @return [String]
+      def container_relative_key
+         @container_relative_key ||= container_path[2..-1].join('.')
+      end
+
+      # This refers to either the global path or the path to a particular
+      # feature
+      #
+      # @return [String]
+      def top_container_key
+        container_global_path? ? container_global_name : container_feature_key
+      end
+
+      def container_key_basename
+        @container_path.last
+      end
+
+      # Fully qualified key, meaning you can access the class this was mixed into
+      # if you stored it into the container using this key
+      #
+      # @return [String]
+      def container_qualified_key
+        @container_qualified_key ||= (
+          "#{top_container_key}.#{container_relative_key}"
+        )
+      end
+
+      # Determines if the container path represents a global glass
+      #
+      # @return [Boolean]
+      def container_global_path?
+        container_path[1] == container_global_name
+      end
+
+      # @return [String]
+      def container_global_name
+        @container_global_name ||= 'global'
+      end
+
+      # Convert the injection key to a fully qualified namespaced key that
+      # is used to pull an item out of the app container.
+      #
+      # Rules:
+      #   1) split the injection key by '.'
+      #   2) use the feature_key as the initial namespace
+      #   3) when the first part of the key is "global" use that instead of
+      #      the feature_key
+      #   4) append the type_key to the namespace unless it is "container"
+      #      type_key like "repositories" or "commands" removes the need for
+      #      the user to have to specify it since they already did that when
+      #      they used the type param.
+      #
+      #
+      #   note: feature_key in these examples will be "features.my-feature"
+      #   @example of a feature repository named foo
+      #
+      #       convert_to_qualified_container_key('foo', 'repositories')
+      #
+      #       returns 'features.my-feature.repositories.foo'
+      #
+      #   @example of a global command names bar
+      #
+      #       convert_to_qualified_container_key('global.bar', 'commands')
+      #
+      #       returns 'gloval.commands.bar'
+      #
+      #   @example of a container item baz
+      #     NOTE: feature container items are not in any namespace, they are any item
+      #           that can resolve from the namespace given by "feature_key"
+      #
+      #      convert_to_qualified_container_key('baz', 'container')
+      #
+      #      returns 'features.my-feature.baz'
+      #
+      #   @example of a global container item baz
+      #     NOTE: global container items are not in any namespace, they are any item
+      #           you can resolve from the application container.
+      #
+      #     convert_to_qualified_container_key('global.baz', 'container')
+      #
+      #     returns 'baz'
+      #
+      # @param key [String] partial key to be built into fully qualified key
+      # @param type_ns [String] namespace for key
+      # @return [String] fully qualified namespaced key
+      def qualify_container_key(key, type_ns)
+        parts     = key.to_s.split('.')
+        namespace = "#{container_feature_key}."
+        if parts[0].downcase == 'global'
+          namespace = 'global.'
+          parts.shift
+        elsif parts[0] == container_feature_name
+          parts.shift
+        end
+
+        # when the key is a global container the namespace is only the path
+        if type_ns == "container"
+          namespace = '' if namespace == 'global.'
+          type_ns = ''
+        else
+          type_ns = "#{type_ns}."
+        end
+
+        path = parts.join('.')
+        "#{namespace}#{type_ns}#{path}"
+      end
+    end
+  end
+end

data/lib/appfuel/application/qualify_container_key.rb

@@ -0,0 +1,76 @@
+module Appfuel
+  module Application
+    # Mixins to allow you to handle application container keys. The application
+    # container operates based on certain conventions which we take into account
+    # here.
+    module QualifyContainerKey
+      # Convert the injection key to a fully qualified namespaced key that
+      # is used to pull an item out of the app container.
+      #
+      # Rules:
+      #   1) split the injection key by '.'
+      #   2) use the feature_key as the initial namespace
+      #   3) when the first part of the key is "global" use that instead of
+      #      the feature_key
+      #   4) append the type_key to the namespace unless it is "container"
+      #      type_key like "repositories" or "commands" removes the need for
+      #      the user to have to specify it since they already did that when
+      #      they used the type param.
+      #
+      #
+      #   note: feature_key in these examples will be "features.my-feature"
+      #   @example of a feature repository named foo
+      #
+      #       convert_to_qualified_container_key('foo', 'repositories')
+      #
+      #       returns 'features.my-feature.repositories.foo'
+      #
+      #   @example of a global command names bar
+      #
+      #       convert_to_qualified_container_key('global.bar', 'commands')
+      #
+      #       returns 'gloval.commands.bar'
+      #
+      #   @example of a container item baz
+      #     NOTE: feature container items are not in any namespace, they are any item
+      #           that can resolve from the namespace given by "feature_key"
+      #
+      #      convert_to_qualified_container_key('baz', 'container')
+      #
+      #      returns 'features.my-feature.baz'
+      #
+      #   @example of a global container item baz
+      #     NOTE: global container items are not in any namespace, they are any item
+      #           you can resolve from the application container.
+      #
+      #     convert_to_qualified_container_key('global.baz', 'container')
+      #
+      #     returns 'baz'
+      #
+      # @param key [String] partial key to be built into fully qualified key
+      # @param type_ns [String] namespace for key
+      # @return [String] fully qualified namespaced key
+      def qualify_container_key(key, type_ns)
+        parts     = key.to_s.split('.')
+        namespace = "#{container_feature_key}."
+        if parts[0].downcase == 'global'
+          namespace = 'global.'
+          parts.shift
+        elsif parts[0] == container_feature_name
+          parts.shift
+        end
+
+        # when the key is a global container the namespace is only the path
+        if type_ns == "container"
+          namespace = '' if namespace == 'global.'
+          type_ns = ''
+        else
+          type_ns = "#{type_ns}."
+        end
+
+        path = parts.join('.')
+        "#{namespace}#{type_ns}#{path}"
+      end
+    end
+  end
+end

data/lib/appfuel/application/root.rb

@@ -0,0 +1,140 @@
+module Appfuel
+  module Application
+    module Root
+      # Initialize Appfuel by creating an application container for the
+      # app represented by the root module passed in. The app container is
+      # a dependency injection container that is used thought the app.
+      #
+      # @raises ArgumentError when root module does not exist
+      #
+      # @param params [Hash]
+      # @option root [Module] root module of the application
+      # @option app_name [String, Symbol] key to store container in appfuel
+      #
+      # @return [Dry::Container]
+      def setup_appfuel(params = {})
+        app_container       = params[:app_container] || Dry::Container.new
+        framework_container = Appfuel.framework_container
+
+        app_container = build_app_container(params, app_container)
+        app_name = handle_app_name(params, app_container, framework_container)
+
+        app_container.register(:app_name, app_name)
+        framework_container.register(app_name, app_container)
+
+        if params.key?(:on_after_setup)
+          handle_after_setup(params[:on_after_setup], app_container)
+        end
+
+        app_container
+      end
+
+      def handle_after_setup(hook, container)
+        unless hook.respond_to?(:call)
+          fail ArgumentError, "After setup hook (:after_setup) must " +
+            "implement :call, which takes the di container as its only arg"
+        end
+        hook.call(container)
+      end
+
+      # The application name is determined by the root module. We use the
+      # lower case underscored version of the root module name
+      #
+      # @param root [Module] The root module of the application
+      # @param params [Hash] input params from setup
+      # @option app_name [String] optional
+      # @option default_app [Bool] force the assignment of default name
+      #
+      # @return [String]
+      def handle_app_name(params, app_container, framework_container)
+        app_name = app_container[:root].to_s.underscore
+
+        if params[:default_app] == true || !Appfuel.default_app?
+          framework_container.register(:default_app_name, app_name)
+        end
+
+        app_name
+      end
+
+      # Initializes the application container with:
+      #
+      # Application Container
+      #   root: This is the root module that holds the namespaces for all
+      #         features, actions, commands etc. This is required.
+      #
+      #   root_path: This is the root path of app where the source code
+      #              lives. We use this to autoload this features. This
+      #              is still under design so it might not stay.
+      #
+      #   config_definition: This is the definition object that we use to
+      #                      build out the configuration hash. This is optional
+      #
+      #   initializers: This is an array that hold all the initializers to be
+      #                 run. This builder will handle creating the array. It is
+      #                 populated via appfuel dsl Appfuel::Initialize#define
+      #
+      #   global.validators: This is a hash that holds all global validators.
+      #                      this builder will handle creating the hash. It is
+      #                      populated via appfuel dsl
+      #                      Appfuel::Validator#global_validator
+      #
+      #   global.domain_builders:
+      #   global.presenters
+      #
+      # @param root [Module] the root module of the application
+      # @param container [Dry::Container] dependency injection container
+      # @return [Dry::Container]
+      def build_app_container(params, container = Dry::Container.new)
+        root = params.fetch(:root) {
+          fail ArgumentError, "Root module (:root) is required"
+        }
+
+        root_path = params.fetch(:root_path) {
+          fail ArgumentError, "Root path (:root_path) is required"
+        }
+
+        feature_initializer = params.fetch(:feature_initializer) {
+          Feature::Initializer.new
+        }
+
+        action_loader = params.fetch(:action_loader) {
+          Feature::ActionLoader.new
+        }
+
+        repo_initializer = params.fetch(:repository_initializer) {
+          Repository::Initializer.new
+        }
+
+        root_name = root.to_s.underscore
+        container.register(:root, root)
+        container.register(:root_name, root_name)
+        container.register(:root_path, root_path)
+        container.register(:repository_mappings, {})
+        container.register(:repository_initializer, repo_initializer)
+        container.register(:features_path, "#{root_name}/features")
+        container.register(:feature_initializer, feature_initializer)
+        container.register(:action_loader, action_loader)
+        if params.key?(:config_definition)
+          container.register(:config_definition, params[:config_definition])
+        end
+
+        Appfuel.setup_container_dependencies('global', container)
+
+        container
+      end
+
+      def bootstrap(overrides: {}, env: ENV)
+        Initialize.run(overrides: overrides, env: env)
+      end
+
+      def call(route, inputs = {})
+        container = Appfuel.app_container
+        request   = Request.new(route, inputs)
+
+        container[:feature_initializer].call(request.feature, container)
+        action = container[:action_loader].call(request.namespace, container)
+        action.run(inputs)
+      end
+    end
+  end
+end

data/lib/appfuel/cli_msg_request.rb

@@ -0,0 +1,19 @@
+module Appfuel
+  # This represents the message delivered by RabbitMQ. We encapsulate it
+  # so that if you want to fire an action from the command line you can
+  # use a CliRequest and not worry about rabbit details
+  #
+  class CliMsgRequest < MsgRequest
+
+    def initialize (route, input)
+      self.inputs       = input
+      self.service_route = route
+    end
+
+    private
+    def inputs=(data)
+      fail "input must be a hash" unless data.is_a?(Hash)
+      @inputs = data
+    end
+  end
+end