appfuel 0.2.0

data/lib/appfuel/domain/entity_collection.rb

@@ -0,0 +1,87 @@
+module Appfuel
+  module Domain
+    # Currently this only answers the use case where a collection of active
+    # record models are converted into a collection of domain entities via
+    # a entity loader.
+    #
+    # NOTE: There is no ability yet to add or track the entity state
+    #
+    class EntityCollection
+      include Enumerable
+      attr_reader :domain_name, :domain_basename, :entity_loader
+
+      def initialize(domain_name, entity_loader = nil)
+        unless Types.key?(domain_name)
+          fail "#{domain_name} is not a registered type"
+        end
+
+        @pager  = nil
+        @list   = []
+        @loaded = false
+
+        parts = domain_name.split('.')
+        @domain_name     = domain_name
+        @domain_basename = parts.last
+        @is_global       = parts.size == 1
+
+        self.entity_loader =  entity_loader if entity_loader
+      end
+
+      def collection?
+        true
+      end
+
+      def global?
+        @is_global
+      end
+
+      def all
+        load_entities
+        @list
+      end
+
+      def first
+        load_entities
+        @list.first
+      end
+
+      def each
+        load_entities
+        return @list.each unless block_given?
+
+        @list.each {|entity| yield entity}
+      end
+
+      def pager
+        load_entities
+        @pager
+      end
+
+      def to_a
+        list = []
+        each do |entity|
+          list << entity.to_h
+        end
+        list
+      end
+
+      def entity_loader?
+        !@entity_loader.nil?
+      end
+
+      def entity_loader=(loader)
+        fail "Entity loader must implement call" unless loader.respond_to?(:call)
+        @entity_loader = loader
+      end
+
+      protected
+
+      def load_entities
+        return false if @loaded || !entity_loader?
+        data = entity_loader.call
+        @list = data[:list]
+        @pager  = data[:pager]
+      end
+    end
+  end
+end

data/lib/appfuel/domain/expr.rb

@@ -0,0 +1,127 @@
+module Appfuel
+  module Domain
+    # Domain expressions are used mostly by the criteria to describe filter
+    # conditions. The class represents a basic expression like "id eq 6", the
+    # problem with this expression is that we need additional information in
+    # order to properly map it to something like a db expression. This call
+    # ensures that additional information exists. Most importantly we need
+    # a fully qualified domain name in the form of "feature.domain".
+    class Expr
+      include DomainNameParser
+      OPS = {
+        eq:       '=',
+        gt:       '>',
+        gteq:     '>=',
+        lt:       '<',
+        lteq:     '<=',
+        in:       'IN',
+        like:     'LIKE',
+        ilike:    'ILIKE',
+        between:  'BETWEEN'
+      }
+      attr_reader :feature, :domain_basename, :domain_name, :domain_attr, :value
+
+      # Assign the fully qualified domain name, its basename and its attribute
+      # along with the operator and value. Operator and value are assumed to
+      # be the first key => value pair of the hash.
+      #
+      # @example
+      #   feature domain
+      #   Expr.new('foo.bar', 'id', eq: 6)
+      #
+      #   or
+      #   global domain
+      #   Expr.new('bar', 'name', like: '%Bob%')
+      #
+      #
+      # @param domain [String] fully qualified domain name
+      # @param domain_attr [String, Symbol] attribute name
+      # @param data [Hash] holds operator and value
+      # @option data [Symbol] the key is the operator and value is the value
+      #
+      # @return [Expr]
+      def initialize(domain, domain_attr, data)
+        fail "operator value pair must exist in a hash" unless data.is_a?(Hash)
+        @feature, @domain_basename, @domain_name = parse_domain_name(domain)
+
+        operator, value = data.first
+        @domain_attr    = domain_attr.to_s
+        self.op         = operator
+        self.value      = value
+
+        fail "domain name can not be empty" if @domain_name.empty?
+        fail "domain attribute can not be empty" if @domain_attr.empty?
+      end
+
+      def feature?
+        !@feature.nil?
+      end
+
+      def global?
+        !feature?
+      end
+
+      # @return [Bool]
+      def negated?
+        @negated
+      end
+
+      def expr_string
+        data = yield domain_name, domain_attr, OPS[op]
+        lvalue   = data[0]
+        operator = data[1]
+        rvalue   = data[2]
+
+        operator = "NOT #{operator}" if negated?
+        "#{lvalue} #{operator} #{rvalue}"
+      end
+
+      def to_s
+        "#{domain_name}.#{domain_attr} #{OPS[op]} #{value}"
+      end
+
+      def op
+        negated? ? "not_#{@op}".to_sym : @op
+      end
+
+      private
+
+      def op=(value)
+        negated, value = value.to_s.split('_')
+        @negated = false
+        if negated == 'not'
+          @negated = true
+        else
+          value = negated
+        end
+        value = value.to_sym
+        unless supported_op?(value)
+          fail "op has to be one of [#{OPS.keys.join(',')}]"
+        end
+        @op = value
+      end
+
+      def value=(data)
+        case op
+        when :in
+          unless data.is_a?(Array)
+            fail ":in operator must have an array as a value"
+          end
+        when :range
+          unless data.is_a?(Range)
+            fail ":range operator must have a range as a value"
+          end
+        when :gt, :gteq, :lt, :lteq
+          unless data.is_a?(Numeric)
+            fail ":gt, :gteq, :lt, :lteq operators expect a numeric value"
+          end
+        end
+        @value = data
+      end
+
+      def supported_op?(op)
+        OPS.keys.include?(op)
+      end
+    end
+  end
+end

data/lib/appfuel/domain/value_object.rb

@@ -0,0 +1,7 @@
+module Appfuel
+  module Domain
+    class ValueObject < Entity
+      enable_value_object
+    end
+  end
+end

data/lib/appfuel/errors.rb

@@ -0,0 +1,104 @@
+module Appfuel
+  # Feature handler, action handler, command handler all use this class.
+  # Presenters and validators will have there errors tranformed into this.
+  # Errors are a basic hash structure where each key has an array of strings
+  # that represent error messages.
+  #
+  # Example
+  #   messages: {
+  #     name: [
+  #       'must be present',
+  #       'can not be blank',
+  #       'can not be Bob'
+  #     ]
+  #   }
+  class Errors
+    include Enumerable
+    attr_reader :messages
+
+    def initialize(messages = {})
+      @messages = messages || {}
+      @messages.stringify_keys! unless @messages.empty?
+    end
+
+    # Defined to use Enumerable so that we can treat errors
+    # as an iterator
+    def each
+      messages.each do|key, msgs|
+        yield key, msgs
+      end
+    end
+
+    # Add an error message to a given key
+    #
+    # @param key Symbol   key for this message
+    # @param msg String   the message to be stored
+    def add(key, msg)
+      key = key.to_s
+      msg = msg.to_s
+      messages[key] = [] unless messages.key?(key)
+      messages[key] << msg unless messages[key].include?(msg)
+    end
+
+    # Formats the list of messages for each key
+    #
+    # Example
+    #   messages: {
+    #     name: [
+    #       ' must be present ',
+    #       ' can not be blank ',
+    #       ' can not be Bob '
+    #     ]
+    #   }
+    #
+    # note: spaces are used only for readability
+    # name: must be present \n can not be blank \n can not be Bob \n \n
+    #
+    # @param msg_separator String separates each message default \n
+    # @param list_separator String separates each list of messages
+    # @return String
+    def format(msg_separator = "\n", list_separator = "\n")
+      msg = ''
+      each do |key, list|
+        msg << "#{key}: #{list.join(msg_separator)}#{list_separator}"
+      end
+      msg
+    end
+
+    def delete(key)
+      messages.delete(key.to_s)
+    end
+
+    def [](key)
+      messages[key.to_s]
+    end
+
+    def size
+      messages.length
+    end
+
+    def values
+      messages.values
+    end
+
+    def keys
+      messages.keys
+    end
+
+    def clear
+      messages.clear
+    end
+
+    def empty?
+      messages.empty?
+    end
+
+    def to_h
+      {errors: messages}
+    end
+
+    def to_s
+      format
+    end
+  end
+end

data/lib/appfuel/feature.rb

@@ -0,0 +1,2 @@
+require_relative 'feature/action_loader'
+require_relative 'feature/initializer'

data/lib/appfuel/feature/action_loader.rb

@@ -0,0 +1,25 @@
+module Appfuel
+  module Feature
+    # Loads an action from the container using its fully qualified namespace.
+    # This class has been abstracted out because its Appfuel's implementation
+    # of loading an action. This action loader is injected into the container
+    # during setup which allows the client to use their own if this basic
+    # lookup mehtod does not work for them.
+    #
+    # The idea is that all actions, commands and repositories auto register
+    # themselves into the container based on a namespace derived inpart by
+    # their own ruby namespace.
+    class ActionLoader
+      # @raises RuntimeError when key is not found
+      # @param namespace [String] fully qualifed container namespace
+      # @param container [Dry::Container] application container
+      # @return [Appfuel::Handler::Action]
+      def call(namespace, container)
+        unless container.key?(namespace)
+          fail "[ActionLoader] Could not load action at #{namespace}"
+        end
+        container[namespace]
+      end
+    end
+  end
+end

data/lib/appfuel/feature/initializer.rb

@@ -0,0 +1,43 @@
+module Appfuel
+  module Feature
+    # Run a given feature's initializers. Each feature can declare any number
+    # of initializers just as the application does. This allow dependencies
+    # and vendor code to be initialized only when the feature is used.
+    class Initializer
+      # Ensure the correct namespaces are registered so that the initializer
+      # dsl will work and then require the feature and run its intializers
+      # unless instructed not too. Initializers are only run once.
+      #
+      # @param name [String] name of the feature as found in the container
+      # @param container [Dry::Container] application container
+      # @return [Boolean]
+      def call(name, container)
+        name = name.to_s.underscore
+        feature_key = "features.#{name}"
+        unless container.key?(feature_key)
+          Appfuel.setup_container_dependencies(feature_key, container)
+        end
+
+        unless require_feature_disabled?(container, feature_key)
+          require "#{container[:features_path]}/#{name}"
+        end
+
+        return false if initialized?(container, feature_key)
+
+        Appfuel.run_initializers(feature_key, container)
+        true
+      end
+
+      private
+      def require_feature_disabled?(container, feature_key)
+        disable_key = "#{feature_key}.disable_require"
+        container.key?(disable_key) && container[disable_key] == true
+      end
+
+      def initialized?(container, feature_key)
+        init_key = "#{feature_key}.initialized"
+        container.key?(init_key) && container[init_key] == true
+      end
+    end
+  end
+end

data/lib/appfuel/handler.rb

@@ -0,0 +1,6 @@
+require_relative 'handler/validator_dsl'
+require_relative 'handler/inject_dsl'
+
+require_relative 'handler/base'
+require_relative 'handler/action'
+require_relative 'handler/command'

data/lib/appfuel/handler/action.rb

@@ -0,0 +1,17 @@
+module Appfuel
+  module Handler
+    class Action < Base
+      class << self
+
+        # In order to reduce the length of namespaces actions are not required
+        # to be inside an Actions namespace, but, it is namespaced with in the
+        # application container, so we adjust for that here.
+        #
+        # @return [String]
+        def container_relative_key
+          "actions.#{super}"
+        end
+      end
+    end
+  end
+end

data/lib/appfuel/handler/base.rb

@@ -0,0 +1,103 @@
+module Appfuel
+  module Handler
+    class Base
+      extend ValidatorDsl
+      extend InjectDsl
+      include Appfuel::Application::AppContainer
+
+      # Class level interfaces used by the framwork to register and run
+      # handlers
+      class << self
+
+        # Register the extending class with the application container
+        #
+        # @param klass [Class] the handler class that is inheriting this
+        # @return nil
+        def inherited(klass)
+          register_container_class(klass)
+        end
+
+        def response_handler
+          @response_handler ||= ResponseHandler.new
+        end
+
+        # Run will validate all inputs; returning on input failures, resolving
+        # declared dependencies, then delegate to the handlers call method with
+        # its valid inputs and resolved dependencies. Finally it ensure every
+        # response is a Response object.
+        #
+        # @param inputs [Hash] inputs to be validated
+        # @return [Response]
+        def run(inputs = {}, container = Dry::Container.new)
+          begin
+            response = resolve_inputs(inputs)
+            return response if response.failure?
+            valid_inputs = response.ok
+
+            resolve_dependencies(container)
+            handler = self.new(container)
+            result = handler.call(valid_inputs)
+            result = create_response(result) unless response?(result)
+          rescue RunError => e
+            result = e.response
+          rescue StandardError => e
+            result = error(e)
+          end
+
+          result
+        end
+
+        def error(*args)
+          response_handler.error(*args)
+        end
+
+        def ok(value = nil)
+          response_handler.ok(value)
+        end
+
+        def response?(value)
+          response_handler.response?(value)
+        end
+
+        def create_response(data)
+          response_handler.create_response(data)
+        end
+
+      end
+
+      attr_reader :data
+
+      def initialize(container = Dry::Container.new)
+        @data = container
+      end
+
+      def call(inputs, data = {})
+        fail "Concrete handlers must implement their own call"
+      end
+
+      def ok(value = nil)
+        self.class.ok(value)
+      end
+
+      def error(*args)
+        self.class.error(*args)
+      end
+
+      def present(name, data, inputs = {})
+        return data if inputs[:raw] == true
+
+        key = qualify_container_key(name, 'presenters')
+        container = self.class.app_container
+        unless container.key?(key)
+          unless data.respond_to?(:to_h)
+            fail "data must implement :to_h for generic presentation"
+          end
+
+          return data.to_h
+        end
+
+        container[key].call(data, inputs)
+      end
+    end
+  end
+end