appfuel 0.2.5 → 0.2.6

data/lib/appfuel/{domain → storage/repository}/expr_transform.rb

@@ -1,7 +1,5 @@
-require 'parslet'
-
 module Appfuel
-  module Domain
+  module Repository
     # A PEG (Parser Expression Grammer) transformer for our domain language.
     #
     class ExprTransform < Parslet::Transform
@@ -41,13 +39,15 @@ module Appfuel
       end
 
       def self.build_conjunction_node(data)
-        if data.key?(:root)
+        if data.is_a?(Expr) || data.is_a?(ExprConjunction)
+          node = data
+        elsif data.key?(:root)
           node = data[:root]
         elsif data.key?(:domain_expr)
-          node = data[:domain_expr]
+          node  = data[:domain_expr]
         elsif data.key?(:and) || data.key?(:or)
-          op = right.key?(:and) ? 'and' : 'or'
-          node = build_conjunction(op, data)
+          op = data.key?(:and) ? :and : :or
+          node = build_conjunction(op, data[op])
         end
         node
       end

data/lib/appfuel/{repository → storage/repository}/mapper.rb

@@ -138,13 +138,14 @@ module Appfuel
         app_container[key]
       end
 
-      def to_entity_hash(domain_name,  data)
+      def to_entity_hash(domain_name,  storage)
         entity_attrs = {}
+        storage_data = storage_hash(storage)
         each_entity_attr(domain_name) do |entry|
           attr_name   = entry.storage_attr
           domain_attr = entry.domain_attr
-          next unless data.key?(attr_name)
-          update_entity_hash(domain_attr, data[attr_name], entity_attrs)
+          next unless storage_data.key?(attr_name)
+          update_entity_hash(domain_attr, storage_data[attr_name], entity_attrs)
         end
 
         entity_attrs
@@ -221,6 +222,10 @@ module Appfuel
         target
       end
 
+      def expr_conjunction?(value)
+        value.instance_of?(ExprConjunction)
+      end
+
       private
       def validate_domain(entity_name)
         unless entity?(entity_name)

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

@@ -0,0 +1,51 @@
+module Appfuel
+  module Repository
+    class OrderExpr < Expr
+
+      def self.build(data)
+        return [data] if data.instance_of?(self)
+        data = [data] if data.is_a?(String)
+        unless data.respond_to?(:each)
+          fail "order must be a string or implement :each"
+        end
+
+        results = []
+        data.each do |item|
+          item = parse_order_string(item) if item.is_a?(String)
+          if item.instance_of?(self)
+            results << item
+            next
+          end
+
+          if !item.is_a?(Hash)
+            fail "order array must be a list of strings or hashes"
+          end
+          domain_attr, dir = item.first
+          results << self.new(domain_attr, dir)
+        end
+        results
+      end
+
+      def initialize(domain_attr, op = nil)
+        op ||= 'asc'
+
+        super(domain_attr, op, nil)
+        @op = @op.downcase
+        unless ['asc', 'desc'].include?(@op)
+          fail "order direction must be either asc or desc"
+        end
+      end
+
+      def to_s
+        "#{attr_list.join('.')} #{op}"
+      end
+
+      private
+      def self.parse_order_string(str)
+        str, dir = str.split(' ')
+         dir = 'asc' if dir.nil?
+         {str => dir.downcase}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Appfuel
+  # Used in the validation system by custom predicates to ask the question if
+  # an entity exists in the database
+  module Repository
+    class Runner
+      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
+end

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

@@ -0,0 +1,50 @@
+module Appfuel
+  module Repository
+    class SearchParser < ExprParser
+      rule(:filter_identifier) { stri('filter') }
+      rule(:order_identifier)  { stri('order') }
+      rule(:limit_identifier)  { stri('limit') }
+
+      rule(:order_dir) do
+        (stri('asc') | stri('desc')).as(:order_dir)
+      end
+
+      rule(:domain_name) do
+        attr_label.as(:feature) >> str('.') >> attr_label.as(:basename)
+      end
+
+      rule(:limit_expr) do
+        (
+          limit_identifier >> space >> space? >> integer.as(:value)
+        ).as(:limit)
+      end
+
+      rule(:order_expr) do
+        (
+          (domain_attr >> space >> order_dir) | domain_attr
+        ).as(:order_expr)
+      end
+
+      # order id
+      # order id asc
+      # order foo.id asc
+      # order foo.id, code desc, foo.bar.id asc
+      rule(:order_by) do
+        (
+          order_identifier >> space >> space? >>
+          (order_expr >> (comma >> order_expr).repeat).maybe
+        ).as(:order)
+      end
+
+      rule(:search) do
+        (
+          domain_name.as(:domain) >> space >> space? >>
+          filter_identifier >> space >> space? >>
+          or_operation.as(:filters) >> order_by.maybe >> space? >> limit_expr.maybe
+        ).as(:search)
+      end
+
+      root(:search)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Appfuel
+  module Repository
+    class SearchTransform <  ExprTransform
+
+
+      rule(order_dir: simple(:n)) {
+        value = n.to_s.downcase
+        value == 'desc' ? 'desc' : 'asc'
+      }
+
+      rule(order_expr: subtree(:expr)) do |dict|
+        expr = dict[:expr]
+        domain_attr = expr[:domain_attr]
+        order_dir = expr[:order_dir] || 'asc'
+        OrderExpr.new(domain_attr, order_dir)
+      end
+
+      rule(attr_label: simple(:n)) { n.to_s }
+
+      rule(domain_attr: simple(:n)) {
+        list = n.is_a?(Array) ? n : [n]
+        {domain_attr: list}
+      }
+
+      rule(domain_expr: subtree(:domain_expr)) do |dict|
+        data = dict[:domain_expr]
+        domain_attr = data[:domain_attr]
+        op          = data[:op]
+        value       = data[:value]
+        Expr.new(domain_attr, op, value)
+      end
+
+      rule(search: subtree(:search)) do |dict|
+        search  = dict[:search]
+        domain  = search[:domain]
+        filters = search[:filters]
+        orders  = search[:order]
+        limit   = search[:limit]
+
+        if filters.is_a?(Hash) && filters.key?(:root)
+          filters = filters[:root]
+        end
+        result  = {}
+        result[:domain]  = "#{domain[:feature]}.#{domain[:basename]}"
+        result[:filters] = filters
+        unless limit.nil?
+          result[:limit] = limit[:value]
+        end
+
+        unless orders.nil?
+          orders = orders.is_a?(Array) ? orders : [orders]
+          result[:order] = orders
+        end
+        {search: Criteria.build(result)}
+      end
+    end
+  end
+end

data/lib/appfuel/{domain/criteria_settings.rb → storage/repository/settings.rb}

@@ -1,6 +1,5 @@
 module Appfuel
-  module Domain
-
+  module Repository
     # 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
@@ -19,7 +18,7 @@ module Appfuel
     #     transform
     #     search_name
     #
-    class CriteriaSettings
+    class Settings
       DEFAULT_PAGE = 1
       DEFAULT_PER_PAGE = 20
 
@@ -29,8 +28,8 @@ module Appfuel
       # @param opts   [Hash] options for initializing criteria
       # @return [Criteria]
       def initialize(settings = {})
-        @parser     = settings[:expr_parser] || ExprParser.new
-        @transform  = settings[:expr_transform] || ExprTransform.new
+        @parser     = settings[:parser]    || SearchParser.new
+        @transform  = settings[:transform] || SearchTransform.new
 
 
         empty_dataset_is_valid!
@@ -55,10 +54,22 @@ module Appfuel
           all
         end
 
+        manual_query(settings[:manual_query]) if settings.key?(:manual_query)
+
         page(settings[:page] || DEFAULT_PAGE)
         per_page(settings[:per_page] || DEFAULT_PER_PAGE)
       end
 
+      def manual_query?
+        !manual_query.nil?
+      end
+
+      def manual_query(value = nil)
+        return @manual_query if value.nil?
+        @manual_query = value
+        self
+      end
+
       def disable_pagination?
         @disable_pagination
       end
@@ -85,6 +96,10 @@ module Appfuel
         self
       end
 
+      def single?
+        first? || last?
+      end
+
       def all?
         @all
       end

data/lib/appfuel/{repository.rb → storage/repository.rb}

@@ -1,8 +1,21 @@
+require 'parslet'
+require 'parslet/convenience'
+
 require_relative 'repository/base'
 require_relative 'repository/mapping_entry'
 require_relative 'repository/mapping_dsl'
 require_relative 'repository/mapper'
 require_relative 'repository/initializer'
+require_relative 'repository/runner'
+require_relative 'repository/expr'
+require_relative 'repository/expr_conjunction'
+require_relative 'repository/order_expr'
+require_relative 'repository/criteria'
+require_relative 'repository/expr_parser'
+require_relative 'repository/search_parser'
+require_relative 'repository/expr_transform'
+require_relative 'repository/search_transform'
+require_relative 'repository/settings'
 
 module Appfuel
   module Repository

data/lib/appfuel/storage.rb

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

data/lib/appfuel/version.rb

@@ -1,3 +1,3 @@
 module Appfuel
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/lib/appfuel.rb

@@ -197,8 +197,6 @@ end
 # Domain Entities
 require "appfuel/domain"
 require "appfuel/presenter"
-require "appfuel/repository"
-require "appfuel/repository_runner"
 require "appfuel/storage"
 require "appfuel/handler"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appfuel
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Robert Scott-Buccleuch
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-25 00:00:00.000000000 Z
+date: 2017-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: 5.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: 5.1.0
 - !ruby/object:Gem::Dependency
   name: dry-types
   requirement: !ruby/object:Gem::Requirement
@@ -259,6 +259,7 @@ files:
 - lib/appfuel/application.rb
 - lib/appfuel/application/app_container.rb
 - lib/appfuel/application/container_class_registration.rb
+- lib/appfuel/application/dispatcher.rb
 - lib/appfuel/application/root.rb
 - lib/appfuel/cli_msg_request.rb
 - lib/appfuel/configuration.rb
@@ -267,19 +268,11 @@ files:
 - lib/appfuel/configuration/populate.rb
 - lib/appfuel/configuration/search.rb
 - lib/appfuel/domain.rb
-- lib/appfuel/domain/base_criteria.rb
 - lib/appfuel/domain/criteria_builder.rb
-- lib/appfuel/domain/criteria_settings.rb
 - lib/appfuel/domain/domain_name_parser.rb
 - lib/appfuel/domain/dsl.rb
 - lib/appfuel/domain/entity.rb
 - lib/appfuel/domain/entity_collection.rb
-- lib/appfuel/domain/exists_criteria.rb
-- lib/appfuel/domain/expr.rb
-- lib/appfuel/domain/expr_conjunction.rb
-- lib/appfuel/domain/expr_parser.rb
-- lib/appfuel/domain/expr_transform.rb
-- lib/appfuel/domain/search_criteria.rb
 - lib/appfuel/domain/value_object.rb
 - lib/appfuel/errors.rb
 - lib/appfuel/feature.rb
@@ -297,13 +290,6 @@ files:
 - lib/appfuel/predicates.rb
 - lib/appfuel/presenter.rb
 - lib/appfuel/presenter/base.rb
-- lib/appfuel/repository.rb
-- lib/appfuel/repository/base.rb
-- lib/appfuel/repository/initializer.rb
-- lib/appfuel/repository/mapper.rb
-- lib/appfuel/repository/mapping_dsl.rb
-- lib/appfuel/repository/mapping_entry.rb
-- lib/appfuel/repository_runner.rb
 - lib/appfuel/request.rb
 - lib/appfuel/response.rb
 - lib/appfuel/response_handler.rb
@@ -323,6 +309,22 @@ files:
 - lib/appfuel/storage/memory.rb
 - lib/appfuel/storage/memory/mapper.rb
 - lib/appfuel/storage/memory/repository.rb
+- lib/appfuel/storage/repository.rb
+- lib/appfuel/storage/repository/base.rb
+- lib/appfuel/storage/repository/criteria.rb
+- lib/appfuel/storage/repository/expr.rb
+- lib/appfuel/storage/repository/expr_conjunction.rb
+- lib/appfuel/storage/repository/expr_parser.rb
+- lib/appfuel/storage/repository/expr_transform.rb
+- lib/appfuel/storage/repository/initializer.rb
+- lib/appfuel/storage/repository/mapper.rb
+- lib/appfuel/storage/repository/mapping_dsl.rb
+- lib/appfuel/storage/repository/mapping_entry.rb
+- lib/appfuel/storage/repository/order_expr.rb
+- lib/appfuel/storage/repository/runner.rb
+- lib/appfuel/storage/repository/search_parser.rb
+- lib/appfuel/storage/repository/search_transform.rb
+- lib/appfuel/storage/repository/settings.rb
 - lib/appfuel/types.rb
 - lib/appfuel/validation.rb
 - lib/appfuel/validation/validator.rb

data/lib/appfuel/domain/base_criteria.rb

@@ -1,171 +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'
-    # search: 'foo.bar filter id = 6 and bar = "foo" order id asc limit 6'
-    #
-    # search:
-    #   domain: 'foo.bar',
-    #
-    #   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
-    #
-    # exists:
-    #   domain:
-    #   expr:
-    #
-    #
-    class BaseCriteria
-      include DomainNameParser
-
-
-      attr_reader :domain_basename, :domain_name, :feature, :settings, :filters
-
-      # 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]
-      def initialize(domain_name, data = {})
-        @feature, @domain_basename, @domain_name = parse_domain_name(domain_name)
-        @settings = data[:settings] || CriteriaSettings.new(data)
-        @filters  = nil
-        @params   = {}
-      end
-
-      def clear_filters
-        @filters = nil
-      end
-
-      def filters?
-        !filters.nil?
-      end
-
-      def global?
-        !feature?
-      end
-
-      def feature?
-        @feature != 'global'
-      end
-
-      # @example
-      #   criteria.add_param('foo', 100)
-      #
-      # @param key [Symbol, String] The key name where we want to keep the value
-      # @param value [String, Integer] The value that belongs to the key param
-      # @return [String, Integer] The saved value
-      def add_param(key, value)
-        fail 'key should not be nil' if key.nil?
-
-        @params[key.to_sym] = value
-      end
-
-      # @param key [String, Symbol]
-      # @return [String, Integer, Boolean] the found value
-      def param(key)
-        @params[key.to_sym]
-      end
-
-      # @param key [String, Symbol]
-      # @return [Boolean]
-      def param?(key)
-        @params.key?(key.to_sym)
-      end
-
-      # @return [Boolean] if the @params variable has values
-      def params?
-        !@params.empty?
-      end
-
-      private
-      def parse_expr(str)
-        if !(settings.parser && settings.parser.respond_to?(:parse))
-          fail "expression parser must implement to :parse"
-        end
-
-        if !(settings.transform && settings.transform.respond_to?(:apply))
-          fail "expression transform must implement :apply"
-        end
-
-        begin
-          tree = settings.parser.parse(str)
-        rescue Parslet::ParseFailed => e
-          msg = "The expression (#{str}) failed to parse"
-          err = RuntimeError.new(msg)
-          err.set_backtrace(e.backtrace)
-          raise err
-        end
-
-        result = settings.transform.apply(tree)
-        result = result[:domain_expr] || result[:root]
-        unless result
-          fail "unable to parse (#{str}) correctly"
-        end
-        result
-      end
-
-      def qualify_expr(domain_expr)
-        return domain_expr if domain_expr.qualified?
-        if global?
-          domain_expr.qualify_global(domain_basename)
-          return domain_expr
-        end
-
-        domain_expr.qualify_feature(feature, domain_basename)
-        domain_expr
-      end
-    end
-  end
-end