appfuel 0.2.3 → 0.2.4

data/lib/appfuel/domain/criteria_settings.rb

@@ -0,0 +1,156 @@
+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.
+    #
+    #   settings:
+    #     page: 1
+    #     per_page: 2
+    #     disable_pagination
+    #     first
+    #     last
+    #     all
+    #     error_on_empty
+    #     parser
+    #     transform
+    #     search_name
+    #
+    class CriteriaSettings
+      DEFAULT_PAGE = 1
+      DEFAULT_PER_PAGE = 20
+
+      attr_reader :parser, :transform
+
+      # @param domain [String] fully qualified domain name
+      # @param opts   [Hash] options for initializing criteria
+      # @return [Criteria]
+      def initialize(settings = {})
+        @parser     = settings[:expr_parser] || ExprParser.new
+        @transform  = settings[:expr_transform] || ExprTransform.new
+
+
+        empty_dataset_is_valid!
+        enable_pagination
+        disable_all
+        disable_first
+        disable_last
+
+        if settings[:error_on_empty] == true
+          error_on_empty_dataset!
+        end
+
+        if settings[:disable_pagination] == true
+          disable_pagination
+        end
+
+        if settings[:first] == true
+          first
+        elsif settings[:last] == true
+          last
+        elsif settings[:all]
+          all
+        end
+
+        page(settings[:page] || DEFAULT_PAGE)
+        per_page(settings[:per_page] || DEFAULT_PER_PAGE)
+      end
+
+      def disable_pagination?
+        @disable_pagination
+      end
+
+      def enable_pagination
+        @disable_pagination = false
+        self
+      end
+
+      def disable_pagination
+        @disable_pagination = true
+        self
+      end
+
+      def page(value = nil)
+        return @page if value.nil?
+        @page = Integer(value)
+        self
+      end
+
+      def per_page(value = nil)
+        return @per_page if value.nil?
+        @per_page = Integer(value)
+        self
+      end
+
+      def all?
+        @all
+      end
+
+      def all
+        @all = true
+        disable_first
+        disable_last
+        self
+      end
+
+      def first?
+        @first
+      end
+
+      def first
+        @first = true
+        disable_last
+        disable_all
+        self
+      end
+
+      def last?
+        @last
+      end
+
+      def last
+        @last = true
+        disable_first
+        disable_all
+        self
+      end
+
+      # Tells the repo to return an error when entity is not found
+      #
+      # @return SearchSettings
+      def error_on_empty_dataset!
+        @error_on_empty = true
+        self
+      end
+
+      # Tells the repo to return and empty collection, or nil if single is
+      # invoked, if the entity is not found
+      #
+      # @return SearchSettings
+      def empty_dataset_is_valid!
+        @error_on_empty = false
+        self
+      end
+
+      def error_on_empty_dataset?
+        @error_on_empty
+      end
+
+      private
+      def disable_all
+        @all = false
+      end
+
+      def disable_first
+        @first = false
+      end
+
+      def disable_last
+        @last = false
+      end
+    end
+  end
+end

data/lib/appfuel/domain/dsl.rb

@@ -27,10 +27,14 @@ module Appfuel
         klass.equalizer = Dry::Equalizer.new(*schema.keys)
         klass.send(:include, klass.equalizer)
 
-        register_container_class(klass)
+        stage_class_for_registration(klass)
         Types.register_domain(klass)
       end
 
+      def container_class_type
+        'domains'
+      end
+
       def default?
         false
       end

data/lib/appfuel/domain/entity.rb

@@ -10,8 +10,7 @@ module Appfuel
   #
   module Domain
     class Entity
-      extend Appfuel::Application::ContainerKey
-      extend Appfuel::Application::ContainerClassRegistration
+      include Appfuel::Application::AppContainer
       extend Dsl
 
       def initialize(inputs = {})

data/lib/appfuel/domain/exists_criteria.rb

@@ -0,0 +1,57 @@
+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.rb

@@ -1,126 +1,95 @@
 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".
+    # conditions. The class represents a basic expression like "id = 6", the
+    # problem with this expression is that "id" is relative to the domain
+    # represented by the criteria. In order to convert that expression to a
+    # storage expression for a db, that expression must be fully qualified in
+    # the form of "features.feature_name.domain.id = 6" so that the mapper can
+    # correctly map to database attributes. This class  provides the necessary
+    # interfaces to allow a criteria to qualify all of its relative expressions.
+    # It also allows fully qualifed expressions to be used.
     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?
+      attr_reader :feature, :domain_basename, :domain_attr, :attr_list, :op, :value
+
+      def initialize(domain_attr, op, value)
+        @attr_list = parse_domain_attr(domain_attr)
+        @op        = op.to_s.strip
+        @value     = value
+
+        fail "op can not be empty" if @op.empty?
+        fail "attr_list can not be empty" if @attr_list.empty?
+      end
+
+      def qualify_feature(feature, domain)
+        fail "this expr is already qualified" if qualified?
+
+        attr_list.unshift(domain)
+        attr_list.unshift(feature)
+        attr_list.unshift('features')
+        self
       end
 
-      def feature?
-        !@feature.nil?
+      def qualify_global(domain)
+        fail "this expr is already qualified" if qualified?
+        attr_list.unshift(domain)
+        attr_list.unshift('global')
+        self
       end
 
       def global?
-        !feature?
+        attr_list[0] == 'global'
       end
 
-      # @return [Bool]
-      def negated?
-        @negated
+      def conjunction?
+        false
       end
 
-      def expr_string
-        data = yield domain_name, domain_attr, OPS[op]
-        lvalue   = data[0]
-        operator = data[1]
-        rvalue   = data[2]
+      def qualified?
+        attr_list[0] == 'global' || attr_list[0] == 'features'
+      end
 
-        operator = "NOT #{operator}" if negated?
-        "#{lvalue} #{operator} #{rvalue}"
+      def feature
+        index = global? ? 0 : 1
+        attr_list[index]
       end
 
-      def to_s
-        "#{domain_name}.#{domain_attr} #{OPS[op]} #{value}"
+      def domain_basename
+        index = global? ? 1 : 2
+        attr_list[index]
       end
 
-      def op
-        negated? ? "not_#{@op}".to_sym : @op
+      def domain_name
+        "#{feature}.#{domain_basename}"
       end
 
-      private
+      def domain_attr
+        start_range = global? ? 2 : 3
+        end_range   = -1
+        attr_list.slice(start_range .. end_range).join('.')
+      end
 
-      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
+      def to_s
+        "#{attr_list.join('.')} #{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
+      def validate_as_fully_qualified
+        unless qualified?
+          fail "expr (#{to_s}) is not fully qualified, mapping will not work"
         end
-        @value = data
+        true
       end
 
-      def supported_op?(op)
-        OPS.keys.include?(op)
+      private
+
+      def parse_domain_attr(list)
+        list = list.split('.') if list.is_a?(String)
+
+        unless list.is_a?(Array)
+          fail "Domain attribute must be a string in the form of " +
+               "(foo.bar.id) or an array ['foo', 'bar', 'id']"
+        end
+        list
       end
     end
   end

data/lib/appfuel/domain/expr_conjunction.rb

@@ -0,0 +1,27 @@
+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/expr_parser.rb

@@ -0,0 +1,199 @@
+require 'parslet'
+require 'parslet/convenience'
+require_relative 'expr_transform'
+
+module Appfuel
+  module Domain
+    # A PEG (Parser Expression Grammer) parser for our domain language. This
+    # gives us the ablity to describe the filtering we would like to do when
+    # searching on a given domain entity. The search string is parsed and
+    # transformed into an interface that repositories can use to determine how
+    # to search a given storage interface. The language always represent the
+    # business domain entities and not a storage system.
+    #
+    class ExprParser < Parslet::Parser
+      rule(:space) { match('\s').repeat(1) }
+      rule(:space?) { space.maybe }
+
+      rule(:comma) { space? >> str(',') >> space? }
+      rule(:digit) { match['0-9'] }
+
+      rule(:lparen) { str('(') >> space? }
+      rule(:rparen) { str(')') >> space? }
+
+      rule(:filter_identifier) { stri('filter') }
+      rule(:order_identifier)  { stri('order') }
+      rule(:limit_identifier)  { stri('limit') }
+
+      rule(:integer) do
+        (str('-').maybe >> digit >> digit.repeat).as(:integer)
+      end
+
+      rule(:float) do
+        (
+          str('-').maybe >> digit.repeat(1) >> str('.') >> digit.repeat(1)
+        ).as(:float)
+      end
+
+      rule(:number) { integer | float }
+
+      rule(:boolean) do
+        (stri("true") | stri('false')).as(:boolean)
+      end
+
+      rule(:string_special) { match['\0\t\n\r"\\\\'] }
+
+      rule(:escaped_special) { str('\\') >> match['0tnr"\\\\'] }
+
+      rule(:string) do
+        str('"') >>
+        ((escaped_special | string_special.absent? >> any).repeat).as(:string) >>
+        str('"')
+      end
+
+      rule(:date) do
+        (
+          digit.repeat(4) >> str('-') >>
+          digit.repeat(2) >> str('-') >>
+          digit.repeat(2)
+        ).as(:date)
+      end
+
+      # 1979-05-27T07:32:00Z
+      rule(:datetime) do
+        (
+          digit.repeat(4) >> str('-') >>
+          digit.repeat(2) >> str('-') >>
+          digit.repeat(2) >> str("T") >>
+          digit.repeat(2) >> str(":") >>
+          digit.repeat(2) >> str(":") >>
+          digit.repeat(2) >> str("Z")
+        ).as(:datetime)
+      end
+
+      rule(:value) do
+        string | number | boolean | datetime | date
+      end
+
+      rule(:attr_label) do
+        match['a-z0-9_'].repeat(1).as(:attr_label)
+      end
+
+      rule(:domain_attr) do
+        (attr_label >> (str('.') >> attr_label).repeat).maybe.as(:domain_attr)
+      end
+
+
+
+      rule(:and_op)     { stri('and')  >> space? }
+      rule(:or_op)      { stri('or')   >> space? }
+      rule(:in_op)      { stri('in')   >> space? }
+      rule(:like_op)    { stri('like') >> space? }
+      rule(:between_op) { stri('between') >> space? }
+
+      rule(:eq_op)      { str('=')    >> space? }
+      rule(:gt_op)      { str('>')    >> space? }
+      rule(:gteq_op)    { str('>=')   >> space? }
+      rule(:lt_op)      { str('<')    >> space? }
+      rule(:lteq_op)    { str('<=')   >> space? }
+
+      rule(:comparison_value) do
+        number | date | datetime
+      end
+
+      rule(:eq_expr) do
+        domain_attr >> space? >> eq_op.as(:op) >> value.as(:value)
+      end
+
+      rule(:gt_expr) do
+        domain_attr >> space? >>
+        gt_op.as(:op) >> space? >>
+        comparison_value.as(:value)
+      end
+
+      rule(:gteq_expr) do
+        domain_attr >> space? >>
+        gteq_op.as(:op) >> space? >>
+        comparison_value.as(:value)
+      end
+
+      rule(:lt_expr) do
+        domain_attr >> space? >>
+        lt_op.as(:op) >> space? >>
+        comparison_value.as(:value)
+      end
+
+      rule(:lteq_expr) do
+        domain_attr >> space?  >>
+        lteq_op.as(:op) >> space? >>
+        comparison_value.as(:value)
+      end
+
+      rule(:relational_expr) do
+        eq_expr | gt_expr | gteq_expr | lt_expr | lteq_expr
+      end
+
+      rule(:in_expr) do
+        domain_attr >> space >>
+        in_op.as(:op) >>
+        str('(') >> space? >>
+        (value >> (comma >> value).repeat).maybe.as(:value) >> space? >>
+        str(')')
+      end
+
+      rule(:like_expr) do
+        domain_attr >> space >>
+        like_op.as(:op) >> space? >>
+        string.as(:value)
+      end
+
+      rule(:between_expr) do
+        domain_attr >> space? >>
+        between_op.as(:op) >> space? >>
+        (
+          comparison_value.as(:lvalue) >> space? >>
+          and_op >> space? >>
+          comparison_value.as(:rvalue)
+        ).as(:value)
+      end
+
+      rule(:domain_expr) do
+        (
+          relational_expr |
+          like_expr |
+          between_expr |
+          in_expr
+        ).as(:domain_expr)
+      end
+
+      rule(:primary) do
+        lparen >> or_operation >> rparen | domain_expr >> space?
+      end
+
+      rule(:and_operation) do
+        (
+          primary.as(:left) >> space? >>
+          and_op >>
+          and_operation.as(:right)
+        ).as(:and) | primary
+      end
+
+      rule(:or_operation) do
+        (
+          and_operation.as(:left) >> space? >>
+          or_op >>
+          or_operation.as(:right)
+        ).as(:or) | and_operation
+      end
+
+      root(:or_operation)
+
+      def stri(str)
+        key_chars = str.split(//)
+        key_chars.collect! {|char|
+          match["#{char.upcase}#{char.downcase}"]
+        }.reduce(:>>)
+      end
+    end
+  end
+end