appfuel 0.2.5 → 0.2.6

data/lib/appfuel/domain/exists_criteria.rb

@@ -1,57 +0,0 @@
-module Appfuel
-  module Domain
-
-    # The Criteria represents the interface between the repositories and actions
-    # or commands. The allow you to find entities in the application storage (
-    # a database) without knowledge of that storage system. The criteria will
-    # always refer to its queries in the domain language for which the repo is
-    # responsible for mapping that query to its persistence layer.
-    #
-    # global.user
-    # memberships.user
-    #
-    # exist: 'foo.bar exists id = 6'
-    #
-    # exits:
-    #   domain: 'foo.bar'
-    #   expr: 'id = 6'
-    #
-    #   settings:
-    #     error_on_empty
-    #     parser
-    #     transform
-    #
-    #
-    class ExistsCriteria < BaseCriteria
-      #
-      # @param domain [String] fully qualified domain name
-      # @param opts   [Hash] options for initializing criteria
-      # @return [Criteria]
-      def initialize(domain_name, data = {})
-        super
-        expr(data[:expr]) if data[:expr]
-      end
-
-      def filter(str)
-        domain_expr = parse_expr(str)
-        if filters?
-          fail "A filter expression has already been assigned"
-        end
-
-        if domain_expr.conjunction?
-          fail "Only simple domain expressions are allowed for exists criteria"
-        end
-
-        if domain_expr.qualified?
-          fail "Only allows relative domain attributes"
-        end
-
-        @filters = qualify_expr(domain_expr)
-        self
-      end
-
-      private
-
-    end
-  end
-end

data/lib/appfuel/domain/expr_conjunction.rb

@@ -1,27 +0,0 @@
-module Appfuel
-  module Domain
-    class ExprConjunction
-      attr_reader :op, :left, :right
-
-      def initialize(type, left, right)
-        @op    = type.to_s.downcase
-        @left  = left
-        @right = right
-      end
-
-      def conjunction?
-        true
-      end
-
-      def qualify_feature(feature, domain)
-        left.qualify_feature(feature, domain)
-        right.qualify_feature(feature, domain)
-      end
-
-      def qualify_global(domain)
-        left.qualify_global(domain)
-        right.qualify_global(domain)
-      end
-    end
-  end
-end

data/lib/appfuel/domain/search_criteria.rb

@@ -1,137 +0,0 @@
-module Appfuel
-  module Domain
-
-    # The Criteria represents the interface between the repositories and actions
-    # or commands. The allow you to find entities in the application storage (
-    # a database) without knowledge of that storage system. The criteria will
-    # always refer to its queries in the domain language for which the repo is
-    # responsible for mapping that query to its persistence layer.
-    #
-    # search: 'foo.bar filter id = 6 and bar = "foo" order id asc limit 6'
-    #
-    #   filters: 'id = 6 or id = 8 and id = 9'
-    #   filters: [
-    #     'id = 6',
-    #     {or: 'id = 8'}
-    #     {and: id = 9'}
-    #   ]
-    #
-    #   order: 'foo.bar.id asc'
-    #   order: 'foo.bar.id'
-    #   order: [
-    #     'foo.bar.id',
-    #     {desc: 'foo.bar.id'},
-    #     {asc: 'foo.bar.id'}
-    #   ]
-    #   limit: 1
-    #
-    #   settings:
-    #     page: 1
-    #     per_page: 2
-    #     disable_pagination
-    #     first
-    #     all
-    #     last
-    #     error_on_empty
-    #     parser
-    #     transform
-    #
-    class SearchCriteria < BaseCriteria
-      attr_reader :order_exprs
-      # Parse out the domain into feature, domain, determine the name of the
-      # repo this criteria is for and initailize basic settings.
-      # global.user
-      #
-      # membership.user
-      # foo.id filter name like "foo" order foo.bar.id asc limit 2
-      # foo.id exists foo.id = 5
-      #
-      # @example
-      #   SpCore::Domain::Criteria('foo', single: true)
-      #   Types.Criteria('foo.bar', single: true)
-      #
-      # === Options
-      #   error_on_empty:   will cause the repo to fail when query returns an
-      #                     an empty dataset. The failure will have the message
-      #                     with key as domain and text is "<domain> not found"
-      #
-      #   single:           will cause the repo to return only one, the first,
-      #                     entity in the dataset
-      #
-      # @param domain [String] fully qualified domain name
-      # @param opts   [Hash] options for initializing criteria
-      # @return [Criteria]
-      #
-      # @param domain [String] fully qualified domain name
-      # @param opts   [Hash] options for initializing criteria
-      # @return [Criteria]
-      def initialize(domain_name, data = {})
-        super
-        @limit = nil
-        @order_exprs = []
-        filter(data[:filter]) if data[:filter]
-      end
-
-      def filter(str, op: 'and')
-        expr = parse_expr(str)
-        return false unless expr
-
-        expr = qualify_expr(expr)
-        if filters?
-          expr = ExprConjunction.new(op, filters, expr)
-        end
-
-        @filters = expr
-        self
-      end
-
-      def limit(nbr = nil)
-        return @limit if nbr.nil?
-
-        @limit = Integer(nbr)
-        fail "limit must be an integer greater than 0" unless nbr > 0
-        self
-      end
-
-      # order first_name asc, last_name
-      #   order: 'foo.bar.id asc'
-      #   order: 'foo.bar.id'
-      #   order: [
-      #     'foo.bar.id',
-      #     {desc: 'foo.bar.id'},
-      #     {asc: 'foo.bar.id'}
-      #   ]
-      #
-      # membership.user.id
-      def order(data)
-        data = [data] if data.is_a?(String)
-        unless data.respond_to?(:each)
-          fail "order must be a string or implement :each"
-        end
-        data.each do |item|
-          item = transform_order_string(item) if item.is_a?(String)
-
-          if !item.is_a?(Hash)
-            fail "order array must be a list of strings or hashes"
-          end
-
-          dir, domain_attr = item.first
-          dir = dir.to_s.downcase
-          unless ['desc', 'asc'].include(dir)
-            fail "order array item must have a hash key of desc or asc"
-          end
-          @order_exprs << {dir => domain_attr}
-        end
-        self
-      end
-
-      private
-
-      def transform_order_string(str)
-        str, dir = item.split(' ')
-        dir = 'asc' if dir.nil?
-        {dir.downcase => str}
-      end
-    end
-  end
-end

data/lib/appfuel/repository/base.rb

@@ -1,86 +0,0 @@
-module Appfuel
-  module Repository
-    class Base
-      include Appfuel::Application::AppContainer
-
-      class << self
-        attr_writer :mapper
-
-        def container_class_type
-          'repositories'
-        end
-
-        def inherited(klass)
-          stage_class_for_registration(klass)
-        end
-
-        def mapper
-          @mapper ||= create_mapper
-        end
-
-        def create_mapper(maps = nil)
-          Mapper.new(container_root_name, maps)
-        end
-      end
-
-      def mapper
-        self.class.mapper
-      end
-
-      def search(criteria)
-        mapper.search(criteria)
-      end
-
-      def exists?(criteria)
-        expr = criteria.fiilters
-        mapper.exists?(expr)
-      end
-
-      def to_storage(entity, exclude = [])
-        mapper.to_storage(entity, exclude)
-      end
-
-      def to_entity(domain_name, storage)
-        key  = qualify_container_key(domain_name, "domains")
-        hash = mapper.to_entity_hash(domain_name, storage)
-        app_container[key].new(hash)
-      end
-
-      def build(type:, name:, storage:, **inputs)
-        builder = find_entity_builder(type: type, domain_name: name)
-        builder.call(storage, inputs)
-      end
-
-      # features.membership.presenters.hash.user
-      # global.presenters.user
-      #
-      # key => db_model
-      # key => db_model
-      def find_entity_builder(domain_name:, type:)
-        key = qualify_container_key(domain_name, "domain_builders.#{type}")
-
-        container = app_container
-        unless container.key?(key)
-          return ->(data, inputs = {}) {
-            build_default_entity(domain_name: domain_name, storage: data)
-          }
-        end
-
-        container[key]
-      end
-
-      def build_default_entity(domain_name:, storage:)
-        storage = [storage] unless storage.is_a?(Array)
-
-        storage_attrs = {}
-        storage.each do |model|
-          storage_attrs.merge!(mapper.model_attributes(model))
-        end
-
-        hash = mapper.to_entity_hash(domain_name, storage_attrs)
-        key  = qualify_container_key(domain_name, "domains")
-        app_container[key].new(hash)
-      end
-    end
-  end
-end

data/lib/appfuel/repository_runner.rb

@@ -1,60 +0,0 @@
-module Appfuel
-  # Used in the validation system by custom predicates to ask the question if
-  # an entity exists in the database
-  class RepositoryRunner
-    attr_reader :repo_namespace, :criteria_class
-
-    # The call relies on the fact that we can build a criteria find the
-    # correct repo and call the exists? interface on that repo. The identity
-    # of any given repo requires its namespace + its class name.
-    #
-    # @param namespace [String] fully qualified namespace string fro repos
-    # @param criteria_class [Class] class used to represent the criteria
-    # @returns [ExistsInDbRunner]
-    def initialize(namespace, criteria_class)
-      @repo_namespace = namespace
-      @criteria_class = criteria_class
-    end
-
-    def create_criteria(entity_key, opts = {})
-      criteria_class.new(entity_key, opts)
-    end
-
-    def query(criteria)
-      load_repo(criteria).query(criteria)
-    end
-
-    # @param entity_key [String] the type identifier for an entity
-    # @param opts [Hash] one attr => value pair is required
-    #                        repo => name is optional
-    #
-    # @return [Bool]
-    def exists?(entity_key, opts = {})
-      fail "opts must be a hash" unless opts.is_a?(Hash)
-
-      criteria_opts = {}
-      if opts.key?(:repo)
-        criteria_opts[:repo] = opts.delete(:repo)
-      end
-      fail "opts hash must have one attr => value pair" if opts.empty?
-
-      property, value = opts.first
-      criteria = create_criteria(entity_key, criteria_opts)
-      criteria.exists(property, value)
-
-      load_repo(criteria).exists?(criteria)
-    end
-
-
-    private
-
-    def load_repo(criteria)
-      klass  = "#{repo_namespace}::#{criteria.repo_name}"
-      unless Kernel.const_defined?(klass)
-        fail "RepositoryRunner: failed - repo #{klass} not defined"
-      end
-
-      Kernel.const_get(klass).new
-    end
-  end
-end