appfuel 0.2.0

data/lib/appfuel/repository/mapping_dsl.rb

@@ -0,0 +1,210 @@
+module Appfuel
+  module Repository
+    # A mapping dsl that allows the collection of database columns to domain
+    # attributes. The reason this dsl is separated from the DbEntityMapper
+    # is due to the fact that we use method_missing for collecting column names
+    # and don't want any incorrect method_missing calls to be confused when
+    # collecting mapped values vs when defining them.
+    class MappingDsl
+      attr_reader :domain_name, :storage, :entries, :entry_class,
+                  :container_name
+
+      STORAGE_TYPES = [:db, :file, :memory]
+
+      # 1) mapping 'feature.domain', db: true, do
+      #    ...
+      #    end
+      #
+      # 2) mapping 'feature.domain', db: 'foo.bar', do
+      #    ...
+      #    end
+      #
+      # 3) mapping 'feature.domain', db: 'global.bar' do
+      #    ...
+      #    end
+      #
+      # 4) mapping 'feature.domain', db: 'foo.bar.baz', key_translation: false)
+      # 4) mapping 'feature.domain', storage: [:db, :file] do
+      #    ...
+      #    end
+      #
+      # a file model requires the domain_name it represents.
+      #
+      #   case1 - build a model with default settings
+      #   file: storage.file.model
+      #           path: <root_path>/storage/file/{key}.yaml
+      #           adapter: storage.file.model
+      #
+      #   case2 - build a model with given settings
+      #           note: if path is absolute nothing is done
+      #                 if path is relative we will prepend root_path
+      #                 if no yaml extension the key is translated to a path
+      #
+      #           path: foo/bar/baz.yml -> <root_path>/foo/bar/baz.yml
+      #           path: /foo/bar/baz.yml -> /foo/bar/baz.yml
+      #           path  auth.user -> <root_path>/storage/features/auth/file/user.yml
+      #           path gobal.user -> <root_path/storage/global/auth/file/user.yml
+      #
+      #   case3 - build a model with adapter and path
+      #     path: sames as above
+      #     adapter translates key to location of adapter in storage
+      #
+      #     container
+      #         default key -> storage.file.model is default
+      #         auth.user -> features.auth.storage.file.user
+      #
+      # file 'storage.file.model'
+      #
+      # storage db: 'foo.user_user'
+      # storage :file
+      # storage :memory
+      #
+      # storage db: 'foo.user_ath',
+      #         file: 'storage.file.model',
+      #         memory: 'storage.memory.model'
+      #
+      def initialize(domain_name, options = {})
+        fail "options must be a hash" unless options.is_a?(Hash)
+
+        @entries        = []
+        @domain_name    = domain_name.to_s
+        @entry_class    = options[:entry_class] || MappingEntry
+        @container_name = options[:container] || Appfuel.default_app_name
+        @storage        = initialize_storage(options)
+
+        fail "entity name can not be empty" if @domain_name.empty?
+      end
+
+      def db(key)
+        @storage[:db] = translate_storage_key(key)
+      end
+
+      # 5) mapping 'feature.domain' db: true do
+      #    end
+      #
+      # 6) mapping 'feature.domain', db: true do
+      #      storage :db, 'foo.bar'
+      #      storage :file
+      #    end
+      #  storage(type = nil, options = {})
+      #
+      def storage(type = nil, *args)
+        return @storage if type.nil?
+        unless type.respond_to?(:to_sym)
+          fail "Storage type must implement :to_sym"
+        end
+        type = type.to_sym
+
+        if all_storage_symbols?(*args)
+          args.unshift(type)
+          args.each do |storage_type|
+            @storage[storage_type] = send("initialize_#{storage_type}_storage", true)
+          end
+
+          return self
+        end
+
+        args = [true] if args.empty?
+
+        key  = args.shift
+        opts = args.shift
+        data = {type => key}
+        if opts.is_a?(Hash)
+          data.merge!(opts)
+        end
+
+        @storage.merge!(initialize_storage(data))
+        self
+      end
+
+      def all_storage_symbols?(*args)
+        result = args - STORAGE_TYPES
+        result.empty?
+      end
+
+      def map(name, domain_attr = nil, opts = {})
+        domain_attr = name if domain_attr.nil?
+
+        data = opts.merge({
+          domain_name: domain_name,
+          domain_attr: domain_attr,
+          storage: storage,
+          storage_attr: name,
+          container: container_name,
+        })
+
+        @entries << entry_class.new(data)
+      end
+
+      private
+
+      def initialize_storage(data)
+        storage = {}
+        if data.key?(:db)
+          value = data[:db]
+          storage[:db] = initialize_db_storage(value, data)
+        elsif data.key?(:file)
+          value = data[:file]
+          storage[:file] = initialize_default_storage(value, :file)
+        elsif data.key?(:storage) && data[:storage].is_a?(Array)
+          data[:storage].each do |type|
+            storage[type] = send("initialize_#{type}_storage", true)
+          end
+        end
+        storage
+      end
+
+      def initialize_db_storage(value, opts = {})
+        case
+        when value == true
+          translate_storage_key(:db, domain_name)
+        when opts.is_a?(Hash) && opts[:key_translation] == false
+          value
+        else
+          translate_storage_key(:db, value)
+        end
+      end
+
+      def initialize_file_storage(value, opts = {})
+        key = translate_storage_key(:file, domain_name)
+        case value
+        when true
+          {
+            model: 'storage.file.model',
+            path: "#{storage_path}/#{key.gsub(/\./,'/')}.yml"
+          }
+        end
+      end
+
+      def storage_path
+        app_container = Appfuel.app_container(container_name)
+        path = app_container[:root_path]
+        if app_container.key?(:storage_path)
+          path = app_container[:storage_path]
+        end
+        path
+      end
+
+      #
+      # global.user
+      # global.storage.db.user
+      # membership.user
+      # features.membership.{type}.user
+      def translate_storage_key(type, partial_key)
+        fail "#{type} can not be empty" if partial_key.empty?
+
+        top, *parts = partial_key.split('.')
+        top = "features.#{top}" unless top == 'global'
+        "#{top}.storage.#{type}.#{parts.join('.')}"
+      end
+
+      def assign_storage(type, partial_key)
+        @storage[type] = translate_storage_key(partial_key)
+      end
+
+      def assign_default_storage(type)
+        @storage[type] = "#{type.to_s.underscore}.model"
+      end
+    end
+  end
+end

data/lib/appfuel/repository/mapping_entry.rb

@@ -0,0 +1,76 @@
+module Appfuel
+  module Repository
+    class MappingEntry
+      attr_reader :domain_name, :domain_attr, :computed_attr, :storage_attr,
+                  :container_name, :container_key
+
+      def initialize(data)
+        unless data.respond_to?(:to_h)
+          fail "Map entry data must respond to :to_h"
+        end
+
+        data = data.to_h
+        @domain_name = data.fetch(:domain_name) {
+          fail "Fully qualified domain name is required"
+        }.to_s
+
+        @storage = data.fetch(:storage) {
+          fail "Storage classes hash is required"
+        }
+
+        @storage_attr = data.fetch(:storage_attr) {
+          fail "Storage attribute is required"
+        }.to_s
+
+        @domain_attr = data.fetch(:domain_attr) {
+          fail "Domain attribute is required"
+        }
+
+        @skip = data[:skip] == true ? true : false
+
+        if data.key?(:computed_attr)
+          computed_attr_lambda(data[:computed_attr])
+        end
+
+        @container_name = data[:container]
+        @container_key = "mappings.#{domain_name}.#{domain_attr}"
+      end
+
+      def storage(type)
+        fail "Storage #{type} is not registered" unless storage?(type)
+
+        @storage[type]
+      end
+
+      def storage?(type)
+        @storage.key?(type)
+      end
+
+      def skip?
+        @skip
+      end
+
+      def computed_attr?
+        !computed_attr.nil?
+      end
+
+      def compute_attr(value, domain)
+        fail "No lambda assigned to compute value" unless computed_attr?
+        @computed_attr.call(value, domain)
+      end
+
+      private
+      def computed_attr_lambda(value)
+        unless value.lambda?
+          fail "computed attributes require a lambda as a value"
+        end
+
+        if value.arity != 2
+          fail "computed attribute lambda's must accept 2 param"
+        end
+
+        @computed_attr = value
+      end
+    end
+  end
+end

data/lib/appfuel/repository/mapping_registry.rb

@@ -0,0 +1,121 @@
+module Appfuel
+  module Repository
+    # The mapping registry holds all entity to db mappings. Mappings are
+    # contained within a DbEntityMapEntry object and are arranged by
+    # entity name. Each entity will hold a hash where the keys are the
+    # attribute names and the value is the entry
+    class MappingRegistry
+        attr_reader :map, :container_root_name
+
+        def initialize(app_name, map)
+          @container_root_name = app_name
+          @map = map
+        end
+
+        # Determine if an entity has been added
+        #
+        # @param entity [String]
+        # @return [Boolean]
+        def domain?(domain_name)
+          map.key?(domain_name)
+        end
+
+        # Determine if an attribute is mapped for a given entity
+        #
+        # @param entity [String] name of the entity
+        # @param attr [String] name of the attribute
+        # @return [Boolean]
+        def domain_attr?(domain_name, domain_attr)
+          return false unless entity?(domain_name)
+          map[domain_name].key?(domain_attr)
+        end
+
+        # Returns a mapping entry for a given entity
+        #
+        # @raise [RuntimeError] when entity not found
+        # @raise [RuntimeError] when attr not found
+        #
+        # @param entity [String] name of the entity
+        # @param attr [String] name of the attribute
+        # @return [Boolean]
+        def find(domain_name, domain_attr)
+          validate_entity(domain_name)
+
+          unless map[domain_name].key?(domain_attr)
+            fail "Entity (#{domain_name}) attr (#{domain_attr}) not registered"
+          end
+          map[domain_name][domain_attr]
+        end
+
+        # Iterates over all entries for a given entity
+        #
+        # @yield [attr, entry] expose the entity attr name and entry
+        #
+        # @param entity [String] name of the entity
+        # @return [void]
+        def each_domain_attr(domain_name)
+          validate_domain(domain_name)
+
+          map[domain_name].each do |attr, entry|
+            yield attr, entry
+          end
+        end
+
+        # Determine if an column is mapped for a given entity
+        #
+        # @param entity [String] name of the entity
+        # @param attr [String] name of the attribute
+        # @return [Boolean]
+        def persistence_attr_mapped?(domain_name, persistence_attr)
+          result = false
+          each_domain_attr(entity) do |_attr, entry|
+            result = true if persistence_attr == entry.persistence_attr
+          end
+          result
+        end
+
+        # Returns a column name for an entity's attribute
+        #
+        # @raise [RuntimeError] when entity not found
+        # @raise [RuntimeError] when attr not found
+        #
+        # @param entity [String] name of the entity
+        # @param attr [String] name of the attribute
+        # @return [String]
+        def persistence_attr(domain_name, attr)
+          find(entity, attr).persistence_attr
+        end
+
+        # Returns the db model for a given entity attr
+        # container:
+        #   domains:
+        #     domain_name -> domain
+        #    persistence
+        #       db:
+        #         persistence_name: -> class
+        #
+        #   container[persistence.db.name]
+        #
+        # @raise [RuntimeError] when entity not found
+        # @raise [RuntimeError] when attr not found
+        # @raise [Dry::Contriner::Error] when db_class is not registered
+        #
+        # @param entity [String] name of the entity
+        # @param attr [String] name of the attribute
+        # @return [Object]
+        def persistence_class(type, domain_name, attr)
+          entry = find(domain_name, attr)
+          name  = entry.persistence[type]
+          key   = "persistence.#{type}.#{name}"
+          Appfuel.app_container(root_name)[key]
+        end
+
+        private
+        def validate_entity(entity)
+          unless entity?(entity)
+            fail "Entity (#{entity}) is not registered"
+          end
+        end
+    end
+  end
+end

data/lib/appfuel/repository_runner.rb

@@ -0,0 +1,60 @@
+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