appfuel 0.2.3 → 0.2.4

data/lib/appfuel/domain/expr_transform.rb

@@ -0,0 +1,68 @@
+require 'parslet'
+
+module Appfuel
+  module Domain
+    # A PEG (Parser Expression Grammer) transformer for our domain language.
+    #
+    class ExprTransform < Parslet::Transform
+      rule(integer:  simple(:n))  { Integer(n) }
+      rule(float:    simple(:n))  { Float(n) }
+      rule(boolean:  simple(:b))  { b.downcase == 'true' }
+      rule(datetime: simple(:dt)) { Time.parse(dt) }
+      rule(date:     simple(:d))  { Date.parse(d) }
+      rule(string:   simple(:s)) do
+        s.to_s.gsub(/\\[0tnr]/, "\\0" => "\0",
+                                "\\t" => "\t",
+                                "\\n" => "\n",
+                                "\\r" => "\r")
+      end
+
+      rule(domain_expr: subtree(:expr)) do |dict|
+        expr  = dict[:expr]
+        attrs = build_domain_attrs(expr[:domain_attr])
+        op    = expr[:op].to_s.strip.downcase
+        value = expr[:value]
+        {domain_expr: Expr.new(attrs, op, value)}
+      end
+
+      rule(and: subtree(:data)) do |dict|
+        {root: build_conjunction('and', dict[:data])}
+      end
+
+      rule(or: subtree(:data)) do |dict|
+        {root: build_conjunction('or', dict[:data])}
+      end
+
+      def self.build_conjunction(op, data)
+        left  = build_conjunction_node(data[:left])
+        right = build_conjunction_node(data[:right])
+
+        ExprConjunction.new(op, left, right)
+      end
+
+      def self.build_conjunction_node(data)
+        if data.key?(:root)
+          node = data[:root]
+        elsif data.key?(:domain_expr)
+          node = data[:domain_expr]
+        elsif data.key?(:and) || data.key?(:or)
+          op = right.key?(:and) ? 'and' : 'or'
+          node = build_conjunction(op, data)
+        end
+        node
+      end
+
+      def self.build_domain_attrs(domain_attr)
+        attr_list = []
+        if domain_attr.is_a?(Hash)
+          attr_list << domain_attr[:attr_label].to_s
+        else
+          domain_attr.each do |label|
+            attr_list << label[:attr_label].to_s
+          end
+        end
+        attr_list
+      end
+    end
+  end
+end

data/lib/appfuel/domain/search_criteria.rb

@@ -0,0 +1,137 @@
+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
+
+      # 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 = []
+        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 = filter
+        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 << {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/domain.rb

@@ -1,7 +1,12 @@
 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"
+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/feature/initializer.rb

@@ -22,6 +22,11 @@ module Appfuel
           require "#{container[:features_path]}/#{name}"
         end
 
+        container[:auto_register_classes].each do |klass|
+          next unless klass.register?
+          container.register(klass.container_class_path, klass)
+        end
+
         return false if initialized?(container, feature_key)
 
         Appfuel.run_initializers(feature_key, container)

data/lib/appfuel/handler/action.rb

@@ -2,6 +2,9 @@ module Appfuel
   module Handler
     class Action < Base
       class << self
+        def container_class_type
+          'actions'
+        end
 
         # In order to reduce the length of namespaces actions are not required
         # to be inside an Actions namespace, but, it is namespaced with in the

data/lib/appfuel/handler/base.rb

@@ -14,7 +14,7 @@ module Appfuel
         # @param klass [Class] the handler class that is inheriting this
         # @return nil
         def inherited(klass)
-          register_container_class(klass)
+          stage_class_for_registration(klass)
         end
 
         def response_handler
@@ -83,6 +83,16 @@ module Appfuel
         self.class.error(*args)
       end
 
+      def search(repo, domain, options = {})
+        criteria = build_criteria(domain, options)
+        repo = data[repo]
+        repo.search(criteria)
+      end
+
+      def build_criteria(domain, options)
+
+      end
+
       def present(name, data, inputs = {})
         return data if inputs[:raw] == true
 

data/lib/appfuel/handler/command.rb

@@ -2,6 +2,10 @@ module Appfuel
   module Handler
     class Command < Base
       class << self
+        def container_class_type
+          'commands'
+        end
+
         def resolve_dependencies(results = Dry::Container.new)
 =begin
           super

data/lib/appfuel/repository/base.rb

@@ -5,8 +5,13 @@ module Appfuel
 
       class << self
         attr_writer :mapper
+
+        def container_class_type
+          'repositories'
+        end
+
         def inherited(klass)
-          register_container_class(klass)
+          stage_class_for_registration(klass)
         end
 
         def mapper
@@ -14,7 +19,7 @@ module Appfuel
         end
 
         def create_mapper(maps = nil)
-          Mapper.new(maps)
+          Mapper.new(container_root_name, maps)
         end
       end
 
@@ -22,6 +27,15 @@ module Appfuel
         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

data/lib/appfuel/repository/mapper.rb

@@ -118,9 +118,12 @@ module Appfuel
       # @param entity [String] name of the entity
       # @param attr [String] name of the attribute
       # @return [Object]
-      def storage_class(domain_name, domain_attr, type)
-        entry = find(domain_name, attr)
+      def storage_class(entity_name, entity_attr, type)
+        entry = find(entity_name, entity_attr)
+        storage_class_from_entry(entry, type)
+      end
 
+      def storage_class_from_entry(entry, type)
         unless entry.storage?(type)
           fail "No (#{type}) storage has been mapped"
         end
@@ -128,26 +131,57 @@ module Appfuel
         container_name = entry.container_name
         unless container_root_name == container_name
           fail "You can not access a mapping outside of this container " +
-            "(#{container_root_name}, #{container_name})"
+            "(mapper: #{container_root_name}, entry: #{container_name})"
         end
-        app_container = Appfuel.app_container(entry.container)
+        app_container = Appfuel.app_container(entry.container_name)
         key = entry.storage(type)
         app_container[key]
       end
 
-      def to_entity_hash(domain_name,  data, opts = {})
+      def to_entity_hash(domain_name,  data)
         entity_attrs = {}
         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)
         end
 
         entity_attrs
       end
 
+      # Convert the domain into a hash of storage attributes that represent.
+      # Each storage class has its own hash of mapped attributes. A domain
+      # can have more than one storage class.
+      #
+      # @param domain [Appfuel::Domain::Entity]
+      # @param type [Symbol] type of storage :db, :file, :memory etc...
+      # @param opts [Hash]
+      # @option exclued [Array] list of columns to exclude from mapping
+      #
+      # @return [Hash] each key is a storage class with a hash of column
+      #                name/value
+      def to_storage(domain, type, opts = {})
+        unless domain.respond_to?(:domain_name)
+          fail "Domain entity must implement :domain_name"
+        end
+
+        excluded = opts[:exclude] || []
+        data     = {}
+        each_entity_attr(domain.domain_name) do |entry|
+          unless entry.storage?(type)
+            "storage type (#{type}) is not support for (#{domain.domain_name})"
+          end
+          storage_attr  = entry.storage_attr
+          storage_class = entry.storage(type)
+          next if excluded.include?(storage_attr) || entry.skip?
+
+          data[storage_class] = {} unless data.key?(storage_class)
+          data[storage_class][storage_attr] = entity_value(domain, entry)
+        end
+        data
+      end
+
       def update_entity_hash(domain_attr, value, hash)
         if domain_attr.include?('.')
           hash.deep_merge!(create_entity_hash(domain_attr, value))
@@ -159,7 +193,7 @@ module Appfuel
       def entity_value(domain, map_entry)
         value = resolve_entity_value(domain, map_entry.domain_attr)
         if map_entry.computed_attr?
-          value = map_entry.compute_attr(domain, value)
+          value = map_entry.computed_attr(value, domain)
         end
 
         value = nil if undefined?(value)

data/lib/appfuel/repository/mapping_dsl.rb

@@ -165,13 +165,13 @@ module Appfuel
         end
       end
 
-      def initialize_file_storage(value, opts = {})
+      def initialize_file_storage(value)
         key = translate_storage_key(:file, domain_name)
         case value
         when true
           {
-            model: 'storage.file.model',
-            path: "#{storage_path}/#{key.gsub(/\./,'/')}.yml"
+            model: 'file.model',
+            path: "#{storage_path}/#{key.tr('.', '/')}.yml"
           }
         end
       end
@@ -195,7 +195,7 @@ module Appfuel
 
         top, *parts = partial_key.split('.')
         top = "features.#{top}" unless top == 'global'
-        "#{top}.storage.#{type}.#{parts.join('.')}"
+        "#{top}.#{type}.#{parts.join('.')}"
       end
 
       def assign_storage(type, partial_key)

data/lib/appfuel/repository/mapping_entry.rb

@@ -51,10 +51,10 @@ module Appfuel
       end
 
       def computed_attr?
-        !computed_attr.nil?
+        !@computed_attr.nil?
       end
 
-      def compute_attr(value, domain)
+      def computed_attr(value, domain)
         fail "No lambda assigned to compute value" unless computed_attr?
         @computed_attr.call(value, domain)
       end

data/lib/appfuel/repository.rb

@@ -2,7 +2,6 @@ require_relative 'repository/base'
 require_relative 'repository/mapping_entry'
 require_relative 'repository/mapping_dsl'
 require_relative 'repository/mapper'
-require_relative 'repository/mapping_registry'
 require_relative 'repository/initializer'
 
 module Appfuel

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

@@ -1,41 +1,45 @@
 module Appfuel
   module Db
+    # ActiveRecord::Base that auto registers itself into the application
+    # container and symbolizes its attributes. This is used by the db
+    # mapper to persist and retreive domains to and from the database.
+    #
+    # NOTE: we are coupling ourselves to active record right now. I have
+    #       plans to resolve this but right now its a lower priority. You
+    #       can get around this by implementing your own mapper, and db model.
+    #
     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
+      include Appfuel::Application::AppContainer
+
+      self.abstract_class = true
+
+      # Contributes to the construction of a fully qualified container key
       #
-      # features.membership.db.account
-      # features.membership.yaml.account
+      # @example
+      #   global model:  global.db.user
+      #   feature model: features.membership.db.user
       #
+      # @return [String]
+      def self.container_class_type
+        'db'
+      end
+
+      # Registers the class inside the application container. The class
+      # being registered as the mixin required for registration.
       #
-      self.abstract_class = true
-      include Appfuel::Application::AppContainer
+      # @params klass [Class] class that is inheriting this one
+      # @return results from super
       def self.inherited(klass)
+        stage_class_for_registration(klass)
         super
-        register_container_class(klass)
       end
 
-
-      def entity_attributes
-        attributes.symbolize_keys.select {|_,value| !value.nil?}
+      # Symbolize active record attributes and remove attributes with
+      # nil values
+      #
+      # @return [Hash]
+      def domain_attrs
+        attributes.symbolize_keys.select {|_k, v| !v.nil? }
       end
     end
   end