appfuel 0.2.0

data/lib/appfuel/request.rb

@@ -0,0 +1,53 @@
+module Appfuel
+  class Request
+    attr_reader :action_route, :feature, :action, :inputs, :namespace
+
+    def initialize(action_route, inputs = {})
+      unless inputs.respond_to?(:to_h)
+        fail "inputs must respond to :to_h"
+      end
+      @inputs = inputs.to_h
+      @action_route, @feature, @action = parse_route(action_route)
+      @namespace = "features.#{feature}.actions.#{action}"
+    end
+
+    private
+
+    # The service route is a forward slash separated string consisting of two
+    # parts. The first part is the feature that holds the action and the
+    # second is the action itself.
+    #
+    # @example 'offers/create'
+    #   feature is Offers
+    #   action is Create
+    #
+    # @param route [String]
+    # @return [Array]
+    def parse_route(route)
+      feature_name, action_name = route.to_s.split('/')
+
+      feature_name = handle_parsed_string(feature_name)
+      action_name  = handle_parsed_string(action_name)
+
+      handle_empty_feature(feature_name)
+      handle_empty_action(action_name)
+
+
+      [route, feature_name, action_name]
+    end
+
+    def handle_parsed_string(value)
+      value.to_s.strip
+    end
+
+    def handle_empty_feature(feature_name)
+      return unless feature_name.empty?
+      fail "feature is missing, action route must be like <feature/action>"
+    end
+
+    def handle_empty_action(action_name)
+      return unless action_name.empty?
+      fail "action is missing, action route must be like <feature/action>"
+    end
+  end
+end

data/lib/appfuel/response.rb

@@ -0,0 +1,96 @@
+module Appfuel
+  # Every action or command must return a response. A response is either
+  # ok or it has errors. You can retrieve the results with the "ok" method
+  # or the errors with the "error" method
+  class Response
+
+    class << self
+      # Convience method for creating a successfull response
+      #
+      # @param  result Hash the successfull resultset
+      # @reuturn Response
+      def ok(result = nil)
+        self.new(ok: result)
+      end
+
+      # Convience method for creating an error response. It understands
+      # how to handle a SpCore::Error object. Any thing that
+      # is not a hash or can't be converted to a hash is assumed to be
+      # a string and converted into a general_error
+      #
+      # @param data Hash the errors hash
+      # @reuturn Response
+      def error(data)
+        result = format_result_hash(data, default_key: :general_error)
+        result = result[:errors] if result.key?(:errors)
+        self.new(errors: result)
+      end
+
+      def format_result_hash(data, default_key:)
+        if data.is_a?(Hash)
+          result = data
+        elsif data.respond_to?(:to_h)
+          result = data.to_h
+        else
+          result = {default_key => data.to_s}
+        end
+
+        result.symbolize_keys
+      end
+    end
+
+    attr_reader :ok, :errors
+
+    # @param data [Hash]
+    # @return [Response]
+    def initialize(data = {})
+      result = format_result_hash(data)
+
+      # when no ok key and no errors key the assume
+      # it is a successfull response
+      if !result.key?(:ok) && !result.key?(:errors)
+        result = {ok: result}
+      end
+
+      @ok = result[:ok]
+      @errors = nil
+      if result.key?(:errors)
+        @ok = nil
+        @errors = Errors.new(result[:errors])
+      end
+    end
+
+    def errors?
+      !ok?
+    end
+    alias_method :failure?, :errors?
+
+    def error_messages
+      return {} if ok?
+
+      errors.messages
+    end
+
+    def ok?
+      errors.nil?
+    end
+    alias_method :success?, :ok?
+
+    def to_h
+      if ok?
+        {ok: ok}
+      else
+        errors.to_h
+      end
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
+    private
+    def format_result_hash(data)
+      self.class.format_result_hash(data, default_key: :ok)
+    end
+  end
+end

data/lib/appfuel/response_handler.rb

@@ -0,0 +1,79 @@
+module Appfuel
+  class ResponseHandler
+    attr_reader :response_class
+
+    def initialize(response_class = Response)
+      @response_class = response_class
+    end
+
+    def create_response(data)
+      return data        if response?(data)
+      return error(data) if error_data?(data)
+      ok(data)
+    end
+
+    def response?(data)
+      data.is_a?(response_class)
+    end
+
+    # Determine if the data given is an error by looking at its class or
+    # checking if it is a hash with the key :errors
+    #
+    # @param data
+    # @return Bool
+    def error_data?(data)
+      case
+      when data.kind_of?(::StandardError) || data.is_a?(Errors)
+        true
+      when data.is_a?(Hash)
+        data.key?(:errors)
+      else
+        false
+      end
+    end
+
+    # This is used when returning results back to the action handler. We
+    # use this to indicate it was a successful response
+    #
+    # @param ok Hash
+    # @return Response
+    def ok(value = nil)
+      response_class.ok(value)
+    end
+
+    # Convert a number of different error formats into hash and use that to
+    # build the response
+    #
+    # @param args StandardError|ActiveModel::Errors|Hash|Errors|Symbol|Response
+    # @return Response
+    def error(*args)
+      error = args.shift
+      case
+      when error.kind_of?(ActiveModel::Errors)
+        messages = error.messages
+      when error.kind_of?(StandardError)
+        key = error.class.to_s.underscore.to_sym
+        backtrace_key = "#{key}_backtrace".to_sym
+        messages = {
+          errors: {
+            key => [error.message],
+            backtrace_key => error.backtrace || []
+          }
+        }
+      when error.is_a?(Hash)
+        messages = error.key?(:errors) ? error : {errors: error}
+      when error.is_a?(Errors)
+        messages = error.to_h
+
+      when args.length >= 1
+        messages = {errors: {error => args}}
+      when error.is_a?(response_class)
+        return error
+      else
+        messages = {errors: {general_error: [error.to_s]}}
+      end
+
+      response_class.error(messages)
+    end
+  end
+end

data/lib/appfuel/root_module.rb

@@ -0,0 +1,31 @@
+module Appfuel
+  # The root module is an import concept. It represents the services top most
+  # namespace. It is assumed that the root module will have a feature module,
+  # its child, and that feature module will have many action classes inside it.
+  module RootModule
+
+    def root_module=(value)
+      fail "Root module must be a module" unless value.is_a?(Module)
+      @root_module = value
+    end
+
+    def root_module
+      @root_module ||= root_module_const
+    end
+
+    protected
+
+    def root_module_const
+      name = root_module_name
+      unless Kernel.const_defined?(name)
+        fail "Root module is not defined (#{name})"
+      end
+
+      Kernel.const_get(name)
+    end
+
+    def root_module_name
+      self.to_s.split("::").first
+    end
+  end
+end

data/lib/appfuel/run_error.rb

@@ -0,0 +1,9 @@
+module Appfuel
+  class RunError < StandardError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+  end
+end

data/lib/appfuel/storage.rb

@@ -0,0 +1,3 @@
+require_relative 'storage/file'
+require_relative 'storage/memory'
+require_relative 'storage/db'

data/lib/appfuel/storage/db.rb

@@ -0,0 +1,4 @@
+require_relative 'db/mapper'
+require_relative 'db/repository_query'
+require_relative 'db/repository'
+require_relative 'db/active_record_model'

data/lib/appfuel/storage/db/active_record_model.rb

@@ -0,0 +1,42 @@
+module Appfuel
+  module Db
+    class ActiveRecordModel < ActiveRecord::Base
+      # ChangeOrder::Global::Db::FooBar
+      #
+      # ChangeOrder::Membership::Peristence::Db::Account
+      # ChangeOrder::Membership::Persistence::Yaml::Account
+      #
+      # ChangeOrder::Membership::Domains::Account
+      #
+      # Appfuel.mapping membership.account,
+      #                 db: account, yaml: account do
+      #   map id, account.id
+      # end
+      #
+      # module Membership
+      #   module Db
+      #
+      #   end
+      # end
+      #
+      #
+      # global.db.foobar
+      #
+      # features.membership.db.account
+      # features.membership.yaml.account
+      #
+      #
+      self.abstract_class = true
+      include Appfuel::Application::AppContainer
+      def self.inherited(klass)
+        super
+        register_container_class(klass)
+      end
+
+
+      def entity_attributes
+        attributes.symbolize_keys.select {|_,value| !value.nil?}
+      end
+    end
+  end
+end

data/lib/appfuel/storage/db/mapper.rb

@@ -0,0 +1,213 @@
+module Appfuel
+  module Db
+    class Mapper < Appfuel::Repository::Mapper
+
+      # Determines if an domain entity exists for this key
+      #
+      # @param key [String, Symbol]
+      # @return [Boolean]
+      def entity_mapped?(name)
+        registry.entity?(name)
+      end
+
+      # Returns the active record model from a map for a given entity
+      #
+      # @raise [RuntimeError] if entity key does not exist
+      # @raise [RuntimeError] if map key does not exist
+      #
+      # @param entity [String] encoded "feature.entity"
+      # @param domain_attr [String] attribute of entity
+      # @return [DbModel]
+      def db_class_key(entity_name, entity_attr)
+        entry = find(entity_name, entity_attr)
+        db_class_key = entry.storage(:db)
+
+        mapp.storage(entity, domain_attr)
+      end
+
+      # Converts an entity expression into a valid active record expresion with
+      # string expresion (array canditions) and value(s)
+      #
+      # @param expr [Domain::Expr]
+      # @param results [Hash]
+      # @return [DbExpr] Returns a valid active record expresion
+      def create_db_expr(expr)
+        DbExpr.new(qualified_db_column(expr), expr.op, expr.value)
+      end
+
+      # Validates if a record exists in the table that matches the array with
+      # the conditions given.
+      #
+      # @param criteria [Criteria]
+      # @return [Boolean]
+      def exists?(criteria)
+        domain_expr = criteria.exists_expr
+        domain_name = domain_expr.domain_name
+        domain_attr = domain_expr.domain_attr
+
+        db_expr     = create_db_expr(domain_expr)
+        db_model    = registry.db_class(domain_name, domain_attr)
+        db_model.exists?([db_expr.string, db_expr.values])
+      end
+
+      # Build a where expression from the mapped db class using the criteria.Ï
+      #
+      # @param criteria [Criteria]
+      # @param relation [DbModel, ActiveRecord::Relation]
+      # @return [DbModel, ActiveRecord::Relation]
+      def where(criteria, relation)
+        unless criteria.where?
+          fail "you must explicitly call :all when criteria has no exprs."
+        end
+
+        criteria.each do |domain_expr, op|
+          relation = if op == :or
+                        relation.or(db_where(domain_expr, relation))
+                      else
+                        db_where(domain_expr, relation)
+                      end
+        end
+        relation
+      end
+
+      # Return qualified db column name from entity expression.
+      #
+      # @param expr [SpCore::Domain::Expr]
+      # @return db column name [String]
+      def qualified_db_column(expr)
+        table_name, column = db_table_column(expr)
+        "#{table_name}.#{column}"
+      end
+
+      # Determine Domain Mapentry and DbModel from entity expression.
+      #
+      # @param expr [SpCore::Domain::Expr]
+      # @return [table_name, column] [Array]
+      def db_table_column(expr)
+        entry = registry.find(expr.domain_name, expr.domain_attr)
+        db    = registry.db_class_constant(entry.db_class)
+        [db.table_name, entry.db_column]
+      end
+
+      # Build an order by expression for the given db relation based on the
+      # criteria
+      #
+      # @param criteria [Criteria]
+      # @param relation [DbModel, ActiveRecord::Relation]
+      # @return [ActiveRecord::Relation]
+      def order(criteria, relation)
+        return relation unless criteria.order?
+        criteria.order.each do |expr|
+          db_column = qualified_db_column(expr)
+          direction = expr.value
+          relation = relation.order("#{db_column} #{direction}")
+        end
+        relation
+      end
+
+      # Eventhough there is no mapping here we add the interface for
+      # consistency.
+      #
+      # @param criteria [Criteria]
+      # @param relation [DbModel, ActiveRecord::Relation]
+      # @return [ActiveRecord::Relation]
+      def limit(criteria, relation)
+        return relation unless criteria.limit?
+
+        relation.limit(criteria.limit)
+      end
+
+      # Map the entity expr to a hash of db_column => value and call
+      # on the relation using that.
+      #
+      # @note this is db library specific and needs to be moved to an adapter
+      #
+      # @param expr [Appfuel::Domain::Expr]
+      # @param relation [ActiveRecord::Relation]
+      # @return [ActiveRecord::Relation]
+      def db_where(domain_expr, relation)
+        db_expr = create_db_expr(domain_expr)
+        relation.where([db_expr.string, db_expr.values])
+      end
+
+      # Convert the entity into a hash of db tables that represent
+      # that entity. Each table has its own hash of mapped columns.
+      #
+      # @param domain [Appfuel::Domain::Entity]
+      # @param opts [Hash]
+      # @option exclued [Array] list of columns to exclude from mapping
+      #
+      # @return [Hash] each key is a table with a hash of column name/value
+      def to_storage(domain, opts = {})
+        excluded = opts[:exclude] || []
+        data = {}
+        each_entity_attr(domain.domain_name) do |entry|
+          column   = entry.storage_attr
+          db_class = entry.storage(:db)
+          next if excluded.include?(column) || entry.skip?
+
+          data[db_class] = {} unless data.key?(db_class)
+          data[db_class][column] = entity_value(domain, entry)
+        end
+        data
+      end
+
+      # Handles entity value by checking if its a computed property,
+      # fetching the value and converting undefined values to nil.
+      #
+      # @param domain [Appfuel::Domain::Entity]
+      # @param map_entry [MappingEntity]
+      # @return the value
+      def entity_value(domain, entry)
+        value = retrieve_entity_value(domain, entry.domain_attr)
+        if entry.computed_attr?
+          value = entry.compute_attr(value)
+        end
+
+        value = nil if undefined?(value)
+
+        value
+      end
+
+      # @params value [mixed]
+      # @return [Boolean]
+      def undefined?(value)
+        value == Types::Undefined
+      end
+
+      # Fetch the value for the entity attribute. When the attribute name
+      # contains a '.' then traverse the dots and call the last attribute
+      # for the value
+      #
+      # @param domain [Appfuel::Domain::Entity]
+      # @param entity_attribute [String]
+      # @return the value
+      def retrieve_entity_value(domain, entity_attr)
+        chain  = entity_attr.split('.')
+        target = domain
+        chain.each do |attr_method|
+          unless target.respond_to?(attr_method)
+            return nil
+          end
+
+          target = target.public_send(attr_method)
+        end
+        target
+      end
+
+      # Create nested hashes from string
+      #
+      # @param domain_attr [String]
+      # @param entity_value [String]
+      # @return [nested hash]
+      def create_entity_hash(domain_attr, entity_value)
+        domain_attr.split('.').reverse.inject(entity_value) { |a,n| {n => a}}
+      end
+
+      def model_attributes(relation)
+        ap relation
+        relation.attributes.select {|_, value| !value.nil?}
+      end
+    end
+  end
+end