appfuel 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab35093c6d5bbbed105926ad6cad55cde7616d5e
-  data.tar.gz: e9bf722af35d2bad3dea89fba52eea61a02f3a00
+  metadata.gz: 730ab86942bed445ca95032499fb709e294614e5
+  data.tar.gz: 9b6fb2eeb4ad17c1737d9ff66a459edb11e86625
 SHA512:
-  metadata.gz: b1bb7c55c07770ca5b77be1d2e2db73ed5d4542ac0209c0dd069efc9a5646f1d22c813964e07999e7d028c1b02096d53a9638dda6b6381a216618482128b0e95
-  data.tar.gz: ff0140867e8db857de3377e39032f9e534fcdc2a7dc336e507cbe62e41da6f93cdf5c8029bc48ecc147d8b5b40f6f6eb779748b278a656af84f2b6f146a3e2f4
+  metadata.gz: 94cd230b06bd3fafb420f909c329f531b9e227d0ef9213432399fa531d05ac01914bcee6e026030733fb7c6ec5362047cf585b1cf5d139179092c98ad54f3cfe
+  data.tar.gz: 85e629ee6586d4495b700b4713fbc1a7af980af062e4394b67ccbd0b44cba48f4a1c0dd0f6f5da4ebe6c9a8aa810efb1c77c2f6251a3dba3b749001a1d634741

data/CHANGELOG.md

@@ -21,3 +21,11 @@ All notable changes to this project will be documented in this file. (Pending ap
 
 ### Added
 - added exists interface to db mapper, will finalize the repo on next release
+
+## [[0.2.6]](https://github.com/rsb/appfuel/releases/tag/0.2.6) 2017-06-6
+
+### Added
+- dispatcher mixin
+
+### Changed
+- moved domain parsing to repository namespace

data/appfuel.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   # we have to lock dry-types due to failures I am encountering
   # when dynamically creating form validators. Not sure if it is the library
   # or the way I am using it.
-  spec.add_dependency "activerecord",     "~> 5.0.2"
+  spec.add_dependency "activerecord",     "~> 5.1.0"
   spec.add_dependency "dry-types",        "0.9.2"
   spec.add_dependency "dry-container",    "~> 0.6"
   spec.add_dependency "dry-validation",   "~> 0.10.5"

data/lib/appfuel/application/app_container.rb

@@ -120,7 +120,6 @@ module Appfuel
         # @return nil
         def container_class_key(value = nil)
           return @container_class_key if value.nil?
-          p "[container-class-key] #{self} => #{value}"
           @container_class_key = value
         end
 

data/lib/appfuel/application/dispatcher.rb

@@ -0,0 +1,32 @@
+module Appfuel
+  module Application
+    module Dispatcher
+
+      def dispatch(request, container)
+        begin
+          container[:feature_initializer].call(request.feature, container)
+          action = container[:action_loader].call(request.namespace, container)
+          response = action.run(inputs)
+        rescue => e
+          handler_error(e, container)
+        end
+
+        if response.failure?
+          handle_error(contaier,  :failed, error)
+        end
+      end
+
+      private
+      def handle_error(e, container)
+        unless container.key?(:error_handler)
+          return default_error_handling(e, contianer) unless container.key?(:error_handler)
+        end
+
+      end
+
+      def default_error_handling(e, container)
+
+      end
+    end
+  end
+end

data/lib/appfuel/application/root.rb

@@ -1,6 +1,8 @@
 module Appfuel
   module Application
     module Root
+      extend Dispatcher
+
       # 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.
@@ -111,6 +113,7 @@ module Appfuel
         container.register(:root_path, root_path)
         container.register(:auto_register_classes, [])
         container.register(:repository_mappings, {})
+        container.register(:repository_cache, {})
         container.register(:repository_initializer, repo_initializer)
         container.register(:features_path, "#{root_name}/features")
         container.register(:feature_initializer, feature_initializer)
@@ -131,10 +134,7 @@ module Appfuel
       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)
+        dispatch(request, container)
       end
     end
   end

data/lib/appfuel/application.rb

@@ -1,3 +1,4 @@
-require_relative 'application/root'
+require_relative 'application/dispatcher'
 require_relative 'application/app_container'
+require_relative 'application/root'
 require_relative 'application/container_class_registration'

data/lib/appfuel/domain/domain_name_parser.rb

@@ -5,9 +5,11 @@ module Appfuel
 
       # This parse the domain name string or object with domain_name method
       # and returns an array with feature, domain and name.
+      #
       # @example
-      #   parse_domain_name('Foo.Bar.Baz')
-      #   ['Foo', 'Bar', 'Foo.Bar.Baz']
+      #   parse_domain_name('foo.bar')
+      #   ['foo', 'bar', 'foo.bar']
+      #
       # @param name [String, Object] domain name
       # @return [Array] parsed Array from domain name
       def parse_domain_name(name)
@@ -18,7 +20,7 @@ module Appfuel
         name = name.domain_name if name.respond_to?(:domain_name)
         feature, domain = name.split('.')
         if domain.nil?
-          domain, feature  = feature, nil
+          fail "domain names must be in the form of (<feature|global>.domain)"
         end
 
         [feature, domain, name]
@@ -26,9 +28,11 @@ module Appfuel
 
       # This parse the domain attributes string and returns an array with
       # two elements.
+      #
       # @example
-      #   parse_domain_attr('Foo.Bar.Baz')
-      #   ['Foo.Bar', 'Baz']
+      #   parse_domain_attr('foo.bar.baz')
+      #   ['foo.bar', 'baz']
+      #
       # @param name [String] domain name attributes
       # @return [Array] parsed Array from domain attributes
       def parse_domain_attr(name)

data/lib/appfuel/domain.rb

@@ -1,12 +1,5 @@
 require_relative "domain/domain_name_parser"
 require_relative "domain/dsl"
-require_relative "domain/expr"
-require_relative "domain/expr_conjunction"
 require_relative "domain/entity"
 require_relative "domain/value_object"
 require_relative "domain/entity_collection"
-require_relative "domain/criteria_settings"
-require_relative "domain/base_criteria"
-require_relative "domain/search_criteria"
-require_relative "domain/exists_criteria"
-require_relative "domain/expr_parser"

data/lib/appfuel/handler/base.rb

@@ -29,20 +29,14 @@ module Appfuel
         # @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
+          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)
 
           result
         end

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

@@ -2,10 +2,6 @@ module Appfuel
   module Db
     class Mapper < Appfuel::Repository::Mapper
 
-      def search(domain_name, criteria, opts = {})
-
-      end
-
       # Return qualified db column name from entity expression.
       #
       # @param expr [SpCore::Domain::Expr]
@@ -33,7 +29,11 @@ module Appfuel
       # @param entry [Repository::MappingEntry] optional
       # @return [Array] The first index is the expr string using ? for values
       #                 The second index is the actual value(s)
-      def convert_expr(expr, entry = nil)
+      def convert_expr(expr, values = [], entry = nil)
+        if expr_conjunction?(expr)
+          return convert_conjunction(expr, values, entry)
+        end
+
         column = qualified_db_column(expr, entry)
         op     = expr.op
         arg    = case expr.op
@@ -42,7 +42,15 @@ module Appfuel
                  else
                    '?'
                  end
-        ["#{column} #{op} #{arg}", expr.value]
+
+        values << expr.value
+        ["#{column} #{op} #{arg}", values]
+      end
+
+      def convert_conjunction(expr, values = [], entry = nil)
+        left, values  = convert_expr(expr.left, values, entry)
+        right, values = convert_expr(expr.right, values, entry)
+        ["#{left} #{expr.op} #{right}", values]
       end
 
       # Validates if a record exists in the table that matches the array with
@@ -55,10 +63,10 @@ module Appfuel
         domain_attr = domain_expr.domain_attr
 
         entry = find(domain_name, domain_attr)
-        db_expr, values = convert_expr(domain_expr, entry)
+        db_expr, values = convert_expr(domain_expr, [], entry)
         db = storage_class_from_entry(entry, :db)
 
-        db.exists?([db_expr, values])
+        db.exists?([db_expr, *values])
       end
 
       # Build a where expression from the mapped db class using the criteria.Ï
@@ -67,18 +75,8 @@ module Appfuel
       # @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
+        conditions, values = convert_expr(criteria.filters)
+        relation.where(conditions, *values)
       end
 
       # Build an order by expression for the given db relation based on the
@@ -89,12 +87,19 @@ module Appfuel
       # @return [ActiveRecord::Relation]
       def order(criteria, relation)
         return relation unless criteria.order?
-        criteria.order.each do |expr|
+        order_str = convert_order_exprs(criteria.order_by)
+        relation.order(order_str)
+      end
+
+      def convert_order_exprs(list)
+        str = ''
+        list.each do |expr|
           db_column = qualified_db_column(expr)
-          direction = expr.value
-          relation = relation.order("#{db_column} #{direction}")
+          direction = expr.op
+          str << "#{db_column} #{direction}, "
         end
-        relation
+
+        str.strip.chomp(',')
       end
 
       # Eventhough there is no mapping here we add the interface for
@@ -109,17 +114,8 @@ module Appfuel
         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])
+      def storage_hash(db_model)
+        db_model.attributes.select {|_, value| !value.nil?}
       end
     end
   end

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

@@ -24,35 +24,14 @@ module Appfuel
         build(name: entity.domain_name, storage: db_results, type: :db)
       end
 
-      def db_class(key)
-        app_container[key]
-      end
-
-      # Used when the automated query methods don't suite your use case. It
-      # is assumed that the method executed will honor the same interfaces as
-      # query does
-      #
-      # @param criteria [SpCore::Criteria]
-      # @return [Dataset]
-      def execute_criteria(criteria)
-        query_method = "#{criteria.exec}_manual_query"
-        validate_query_method(query_method)
-
-        public_send(query_method, criteria)
-      end
-
-      # Use the criteria entity's basename as a convention to find a method
-      # on the repository that returns the necessary relation (db scope) for
-      # which to add conditions that will be used to complete the query.
+      # when key has no . assume the feature of the repository
       #
       #
-      # @param criteria [SpCore::Criteria]
-      # @return [ActiveRecord::Relation]
-      def query_relation(criteria)
-        query_method = "#{criteria.domain}_query"
-        validate_query_method(query_method)
-
-        public_send(query_method)
+      def db_class(key)
+        unless key.include?('.')
+          key = "features.#{self.class.container_feature_name}.db.#{key}"
+        end
+        app_container[key]
       end
 
       # Handles the treatment of the relation when the recordset is empty
@@ -86,126 +65,79 @@ module Appfuel
       # @param criteria [SpCore::Criteria]
       # @param relation [mixed]
       # @return relation
-      def apply_query_conditions(criteria, relation)
-        relation = where(criteria, relation)
-        relation = order(criteria, relation)
-        relation = limit(criteria, relation)
+      def apply_query_conditions(criteria, relation, _settings)
+        ap 'i am applying some query condititions'
+        relation = mapper.where(criteria, relation)
+        ap relation
+        ap 'some where conditions'
+        relation = mapper.order(criteria, relation)
+        ap 'some order condition'
+        relation = mapper.limit(criteria, relation)
+        ap 'some limit condition'
         relation
       end
 
-      # We have an interface for getting all recordsets separately because
-      # this is usually done with no filters or limits.
-      #
-      # @param criteria [SpCore::Criteria]
-      # @param relation
-      # @return relation
-      def apply_query_all(criteria, relation)
-        unless criteria.all?
-          fail "This interface can only be used when the criteria :all is used"
-        end
-
-        order(criteria, relation.all)
-      end
-
       # Determines which query conditions to apply to the relation
       #
       # @param criteria [SpCore::Criteria]
       # @param relation
       # @return relation
-      def handle_query_conditions(criteria, relation)
-        if criteria.all?
-          return apply_query_all(criteria, relation)
+      def handle_query_conditions(criteria, relation, settings)
+        if settings.all?
+          return order(criteria, relation.all)
         end
 
-        apply_query_conditions(criteria, relation)
+        apply_query_conditions(criteria, relation, settings)
       end
 
-      # Factory method to create a domain entity
-      #
-      # @param domain_name [String]
-      # @return [SpCore::Domain::EntityCollection]
-      def create_entity_collection(domain_name)
-        Appfuel::Domain::EntityCollection.new(domain_name)
-      end
+      def handle_empty_relation(criteria, relation, settings)
+        unless relation.respond_to?(:blank?)
+          fail "The database relation invalid, does not implement :blank?"
+        end
 
-      # Creates a lambda to used with the entity collection
-      #
-      # @param criteria [SpCore::Criteria]
-      # @param relation [Object]
-      # @param builder  [Object]
-      # @return lambda
-      def entity_loader(criteria, relation, builder)
-        -> { load_collection(criteria, relation, builder) }
-      end
+        return nil unless relation.blank?
 
-      # A collection is usually loaded within an entity collection via
-      # a lambda. It setups up pagination results and builds an entity
-      # foreach record in the list
-      #
-      # @param criteria [SpCore::Criteria]
-      # @param relation [Object]
-      # @param builder  [Object]
-      # @return [Hash]
-      def load_collection(criteria, relation, builder)
-        data = { items: [] }
-        unless criteria.disable_pagination?
-          relation = relation.page(criteria.page).per(criteria.per_page)
-          data[:pager] = create_pager_result(
-            total_pages:  relation.total_pages,
-            current_page: relation.current_page,
-            total_count:  relation.total_count,
-            page_limit:   relation.limit_value,
-            page_size:    relation.size
-          )
+        if criteria.error_on_empty_dataset?
+          return domain_not_found_error(criteria)
         end
 
-        relation.each do |db_item|
-          data[:items] << builder.call(db_item)
+        if criteria.single?
+          return domain_not_found(criteria)
         end
-        data
       end
 
-      # Create an entity collection and assign the entity loader with
-      # the entity builder class.
+      # 1) lookup query id in cache
+      #   if found build collection from cached query ids
       #
-      # @param criteria [SpCore::Criteria]
-      # @param relation relation
-      # @return SpCore::Domain::EntityCollection
-      def build_criteria_entities(criteria, relation)
-        builder = create_entity_builder(criteria.domain_name)
-        result  = handle_empty_relation(criteria, relation)
-        # when this has a result it means an empty relation has been
-        # handled and ready for return otherwise it was a no op
+      # 2) query id not found in cache
+      #   a) assign query id from criteria
+      #   b) find the domain builder for that criteria
+      #   c) loop through each item in the database relation
+      #   d) build an domain from each record in the relation
+      #   e) create cache id from the domain
+      #   f) record cache id into a list that represents query
+      #   g) assign domain into the cache with its cache id
+      #       id is in the cache the its updated *represents a miss
+      #   h) assign the query list into the cache with its query id
+      #
+      def build_domains(criteria, relation, settings)
+        result  = handle_empty_relation(criteria, relation, settings)
         return result if result
 
-        if criteria.single?
-          relation_method = criteria.first? ? :first : :last
-          return builder.call(relation.send(relation_method))
+
+        if settings.single?
+          method   = settings.first? ? :first : :last
+          db_model = relation.send(method)
+          builder  = domain_builder(criteria.domain_name)
+          domain   = builder.call(db_model, criteria)
+          ap domain
         end
 
-        collection = create_entity_collection(criteria.domain_name)
-        collection.entity_loader = entity_loader(criteria, relation, builder)
-        collection
       end
 
-      # Query will use the database model to build a query based on the
-      # given criteria. It supports where, order and limit conditions.
-      #
-      # @param criteria [SpCore::Criteria]
-      # @return [SpCore::Domain::Entity, SpCore::Domain::EntityCollection]
-      def search(criteria)
-        return execute_criteria(criteria) if criteria.exec?
-
-        begin
-          relation = query_relation(criteria)
-          relation = handle_query_conditions(criteria, relation)
-          build_criteria_entities(criteria, relation)
-        rescue => e
-          msg = "query failed for #{criteria.domain}: #{e.class} #{e.message}"
-          err = RuntimeError.new(msg)
-          err.set_backtrace(e.backtrace)
-          raise err
-        end
+      def domain_builder(domain_name)
+        key = qualify_container_key(domain_name, 'domain_builders.db')
+        app_container[key]
       end
 
       private