appfuel 0.2.0

data/lib/appfuel/configuration.rb

@@ -0,0 +1,14 @@
+require_relative 'configuration/file_loader'
+require_relative 'configuration/search'
+require_relative 'configuration/populate'
+require_relative 'configuration/definition_dsl'
+
+module Appfuel
+  module Configuration
+    def self.define(key, &block)
+      definition = DefinitionDsl.new(key)
+      definition.instance_eval(&block)
+      definition
+    end
+  end
+end

data/lib/appfuel/configuration/definition_dsl.rb

@@ -0,0 +1,175 @@
+module Appfuel
+  module Configuration
+    # A configuration definition holds the methods that are exposed in
+    # Config dsl. This definition allows you to define a given configuration
+    # as it would exist in a hash. The dsl collects information like where
+    # the file that holds the config data is stored, validation for that
+    # data and default values. Just like hashes can have nested hashes
+    # you can have nested definitions using the "define" method
+    #
+    # NOTE: currently we only support yaml config files
+    #
+    # @example of dsl usage
+    #
+    # Appfuel::Configuration.define :foo do
+    #   file /etc/startplus/offers.yml
+    #   defaults bar: 'bif',
+    #            baz: 'biz'
+    #
+    #   env FOO_BAR: :bar,
+    #       FOO_BAZ: :baz
+    #
+    #   unsafe :some_key, :other_key
+    #
+    #   validator  {
+    #     required(:name).filled
+    #   }
+    #
+    #   define :bam do
+    #     defaults bat: 'hit',
+    #              rat: 'cheese'
+    #
+    #     validator {
+    #       required(:cheese_type).filled
+    #     }
+    #   end
+    # end
+    #
+    # Results in something like this
+    #
+    # hash = {
+    #   foo: {
+    #     bar: 'bif',
+    #     baz: 'baz',
+    #     name: <user supplied>,
+    #     bam: {
+    #       bat: 'hit',
+    #       rat: 'cheese',
+    #       cheese_type: <user supplied>
+    #     }
+    #   }
+    # }
+    #
+    class DefinitionDsl
+      include FileLoader
+      include Search
+      include Populate
+      attr_reader :key
+
+      # A definition must be created with a key that will be used in the
+      # resulting configuration hash that is built
+      #
+      # @param key Symbol|String key used config hash
+      # @return Definition
+      def initialize(key)
+        @key       = key
+        @defaults  = {}
+        @file      = []
+        @validator = nil
+        @children  = {}
+        @env       = {}
+      end
+
+      # Dsl command used to set the file path. When used without params
+      # it returns the file path set.
+      #
+      # @param path String
+      # @return String | nil
+      def file(path = nil)
+        return @file  if path.nil?
+        path = [path] if path.is_a?(String)
+
+        unless path.is_a?(Array)
+          fail "file path must be a String or Array of Strings"
+        end
+        @file = path
+      end
+
+      def file?
+        !@file.empty?
+      end
+
+      # Dsl used when you expected to manually pass in the configuration data
+      # and ignore the configuration in the file
+      #
+      # @return nil
+      def delete_file
+        @file = []
+      end
+
+      # Dsl command used to set default values. When used without params
+      # it returns the full default hash
+      #
+      # @param settings Hash
+      # @return Hash
+      def defaults(settings = nil)
+        return @defaults if settings.nil?
+        unless settings.is_a?(Hash)
+          fail ArgumentError, 'defaults must be a hash'
+        end
+
+        @defaults = settings
+      end
+
+      # Dsl command used to define what env variables will me mapped to config
+      # keys
+      #
+      # @param settings Hash
+      # @option <key>=><value> The key is the env variable and the value is
+      #                        the config key it maps to
+      # @return Hash
+      def env(settings = nil)
+        return @env if settings.nil?
+        unless settings.is_a?(Hash)
+          fail ArgumentError, 'config env settings must be a hash'
+        end
+
+        @env = settings
+      end
+
+      # Dsl to assign validator. When no params are given then it returns
+      # the assigned validator. We use the validation library dry-validation
+      # http://dry-rb.org/gems/dry-validation/. We will consider any object
+      # that implements `call` method a validator.
+      #
+      # @params validator Dry::Validation::Schema
+      # @return validator
+      def validator(&block)
+        return @validator unless block_given?
+
+        @validator = Dry::Validation.Schema(&block)
+      end
+
+      def validator?
+        !@validator.nil?
+      end
+
+      # Dsl to add a configuration definition as a child of another
+      # definition
+      #
+      # @param key Symbol
+      # @return Details
+      def define(key, &block)
+        definition = self.class.new(key)
+        definition.instance_eval(&block)
+        self << definition
+      end
+
+      def delete(name)
+        @children.delete(name)
+      end
+
+      # Append a definition to this definition's children
+      #
+      # @param definitions Array | Definition
+      def <<(definitions)
+        list = definitions.is_a?(Array) ? definitions : [definitions]
+        list.each {|item| children[item.key] = item}
+      end
+
+      protected
+      attr_accessor :children
+
+    end
+  end
+end

data/lib/appfuel/configuration/file_loader.rb

@@ -0,0 +1,61 @@
+module Appfuel
+  module Configuration
+    # Handle loading files and parsing them correctly based on their type.
+    # The file loader used for loading configuration data into a definition
+    module FileLoader
+      attr_writer :file_module, :json_module, :yaml_module
+
+      def file_module
+        @file_module ||= ::File
+      end
+
+      def json_module
+        @json_module || ::JSON
+      end
+
+      def yaml_module
+        @yaml_module ||= YAML
+      end
+
+      # @param path [String]
+      # @return [Hash]
+      def parse_json(path)
+        file = file_module.read(path)
+        json_module.parse(file)
+      end
+
+      # @param path [String]
+      # @return [Hash]
+      def parse_yaml(path)
+        yaml_module.load_file(path)
+      end
+
+      # Load file will search through a configuration's definition file
+      # paths and use the first on that exists. It parse it based on
+      # the file type.
+      #
+      # @raises [RuntimeException] when no files are found
+      #
+      # @param definition [DefinitionDsl]
+      # @return [Hash]
+      def load_file(definition)
+        paths = definition.file
+        key   = definition.key
+
+        paths.each do |path|
+          ext = file_module.extname(path).strip.downcase[1..-1]
+          parse_method = "parse_#{ext}"
+          unless respond_to?(parse_method)
+            fail "extension (#{ext}), for (#{key}: #{path}) is not valid, " +
+                 "only yaml and json are supported"
+          end
+
+          return public_send(parse_method, path) if file_module.exists?(path)
+        end
+
+        list = paths.join(',')
+        fail "none of :#{key} config files exist at (#{list})"
+      end
+    end
+  end
+end

data/lib/appfuel/configuration/populate.rb

@@ -0,0 +1,95 @@
+module Appfuel
+  module Configuration
+    module Populate
+      # This converts a definition into a hash of configuation values. It does
+      # this using the following steps
+      #
+      # 1. load config data from a yaml or json file if a file is defined
+      # 2. populate all children
+      # 3. merge defaults into config data that has been given or resolved
+      #    from the config file
+      # 4. merge override data into the results from step 3
+      # 5. run validation and assign clean data to config with the key
+      #
+      # @throws RuntimeError when validation fails
+      # @param data Hash holds overrides and config source data
+      # @return Hash
+      def populate(data = {})
+        overrides = data[:overrides] || {}
+        config    = data[:config]    || {}
+        env_data  = data[:env]       || ENV
+
+        if overrides.key?(:config_file) && !overrides[:config_file].nil?
+          file overrides[:config_file]
+        end
+
+        if file?
+          config = load_file(self)
+          config = config[key]
+        end
+
+        config ||= {}
+
+        config = defaults.deep_merge(config)
+        config = config.deep_merge(load_env(env_data, self))
+        config = config.deep_merge(overrides || {})
+
+        populate_children(children, config, env_data) unless children.empty?
+
+        handle_validation(config)
+      end
+
+      #
+      # @param definition [DefinitionDsl]
+      # @return [Hash]
+      def load_env(env_data, definition)
+        config = {}
+        definition.env.each do |env_key, config_key|
+          env_key = env_key.to_s
+          next unless env_data.key?(env_key)
+          config[config_key] = env_data[env_key]
+        end
+        config
+      end
+
+      protected
+
+      def populate_children(child_hash, data, env_data = {})
+        child_hash.each do |(def_key, definition)|
+
+          data[def_key] ||= {}
+          data[def_key] = load_file(definition) if definition.file?
+          data[def_key] = definition.defaults.deep_merge(data[def_key])
+          data[def_key] = data[def_key].deep_merge(load_env(env_data, definition))
+          unless definition.children.empty?
+            populate_children(definition.children, data[def_key], env_data)
+          end
+
+          data[def_key] = definition.handle_validation(data[def_key])
+       end
+      end
+
+      def handle_validation(data)
+        return data unless validator?
+
+        result = validator.call(data)
+        if result.failure?
+          msg = validation_error_message(result.errors(full: true))
+          fail msg
+        end
+        result.to_h
+      end
+
+      def validation_error_message(errors)
+        msg = ''
+        errors.each do |(error_key, values)|
+          if values.is_a?(Hash)
+            values = values.values.uniqu
+          end
+          msg << "[#{key}] #{error_key}: #{values.join("\n")}\n"
+        end
+        msg
+      end
+    end
+  end
+end

data/lib/appfuel/configuration/search.rb

@@ -0,0 +1,45 @@
+module Appfuel
+  module Configuration
+    module Search
+      # Allow you to access child definitions as if it were a hash.
+      # If you add a space separated list of names this will traverse
+      # the child hierarchy and return the last name in the list
+      #
+      # @param name String name or names to search
+      # @return Definition | nil
+      def [](name)
+        find @children, name.to_s.split(" ")
+      end
+
+      # Allows you to search child definitions using an array of names
+      # instead of a space separated string
+      #
+      # @param names Array of strings
+      # @return Definition | nil
+      def search(*names)
+        return nil if names.empty?
+        find children, names
+      end
+
+      protected
+
+      # Recursively locate a child definition in the hierarchy
+      #
+      # @param child_list Hash
+      # @param terms Array of definition keys
+      def find(child_list, terms)
+        while term = terms.shift
+          child_list.each do |(definition_key, definition)|
+            next unless definition_key == term
+            result = if terms.empty?
+                       definition
+                     else
+                       find(definition.children, terms)
+                     end
+            return result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appfuel/db_model.rb

@@ -0,0 +1,16 @@
+module Appfuel
+  class DbModel < ActiveRecord::Base
+    self.abstract_class = true
+    extend Appfuel::Application::ContainerKey
+    extend Appfuel::Application::ContainerClassRegistration
+
+    def self.inherited(klass)
+      super
+      register_container_class(klass)
+    end
+
+    def entity_attributes
+      attributes.symbolize_keys.select {|_,value| !value.nil?}
+    end
+  end
+end

data/lib/appfuel/domain.rb

@@ -0,0 +1,7 @@
+require_relative "domain/domain_name_parser"
+require_relative "domain/dsl"
+require_relative "domain/expr"
+require_relative "domain/entity"
+require_relative "domain/value_object"
+require_relative "domain/entity_collection"
+require_relative "domain/criteria"

data/lib/appfuel/domain/criteria.rb

@@ -0,0 +1,436 @@
+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.
+    class Criteria
+      include DomainNameParser
+
+      DEFAULT_PAGE = 1
+      DEFAULT_PER_PAGE = 20
+
+      attr_reader :domain, :domain_name, :feature, :repo_name, :exprs, :order,
+        :exists, :exec, :all
+
+      # Parse out the domain into feature, domain, determine the name of the
+      # repo this criteria is for and initailize basic settings.
+      #
+      # @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, opts = {})
+        @feature, @domain, @domain_name = parse_domain_name(domain)
+        @exists       = nil
+        @exprs        = []
+        @order        = []
+        @limit        = nil
+        @exec         = nil
+        @all          = false
+        @first        = false
+        @last         = false
+        @params       = {}
+        @page         = DEFAULT_PAGE
+        @per_page     = DEFAULT_PER_PAGE
+        @disable_pagination = opts[:disable_pagination] == true
+        @repo_name    = "#{(opts[:repo] || @domain).classify}Repository"
+
+        empty_dataset_is_valid!
+        if opts[:error_on_empty] == true
+          error_on_empty_dataset!
+        end
+
+        # default is to expect a collection for this critria unless you declare
+        # you want a single
+        collection
+        public_send(:first) if opts[:single] == true || opts[:first] == true
+        public_send(:last)  if opts[:last] == true
+      end
+
+      # Add param to the instantiated criteria
+      #
+      # @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
+
+      # Remove operators and keep key filters. It returns a cleaned
+      # list of filters.
+      #
+      # @example
+      #   criteria.filter([
+      #     {projects.offer.id: 6},
+      #     {last_name: 'SirFooish', op: 'like'},
+      #     {first_name: Bob, op: 'like', or: false}
+      #   ])
+      #
+      # @raise [RuntimeError] when the attribute is not an array
+      # @raise [RuntimeError] when the filter is not a Hash
+      #
+      # @param list [Array<Hash>] The list of filters to implement in criteria
+      # @return [Array<Hash>, nil] List of filters with values or nil in case of array empty
+      def filter(list)
+        fail 'the attribute must be an Array' unless list.is_a? Array
+
+        list.each do |item|
+          fail 'filters must be a Hash' unless item.is_a? Hash
+
+          operator      = extract_relational_operator(item)
+          relational_or = extract_relational_condition(item)
+          key, value    = item.first
+
+          where(key, operator => value, or: relational_or)
+        end
+      end
+
+      def where?
+        !exprs.empty? || all?
+      end
+
+      # Adds an expression to the list that will be joined to
+      # the next expression with an `:and` operator
+      #
+      # @param domain_attr [String]
+      # @param data [Hash]
+      # @option <operator> the key is the operator like :eq and value is value
+      # @option :or  with a value of true will join this expression with the
+      #              previous expression using a relation or. relation and
+      #              is by default
+      #
+      # @return [Criteria]
+      def where(domain_attr, data)
+        domain_attr = domain_attr.to_s
+
+        relational_op = :and
+        if data.key?(:or)
+          value = data.delete(:or)
+          relational_op = :or if value == true
+        end
+
+        domain_entity = domain_name
+        if domain_attr.count('.') == 2
+          domain_entity, domain_attr = parse_domain_attr(domain_attr)
+        end
+
+        expr = {
+          expr: create_expr(domain_entity, domain_attr, data),
+          relational_op: relational_op
+        }
+        exprs << expr
+        self
+      end
+
+      alias_method :and, :where
+
+      # Adds an expression to the list that will be joined to
+      # the next expression with an `:or` operator
+      #
+      # @param attr [String]
+      # @param value [Hash]
+      # @return [Criteria]
+      def or(domain_attr, data)
+        data[:or] = true
+        where(domain_attr, data)
+      end
+
+      # Adds an expression to order list.
+      #
+      # @param list [list]
+      # @return [Criteria]
+      def order_by(dict, order_dir = 'ASC')
+        if dict.is_a?(String) || dict.is_a?(Symbol)
+          dict = {dict.to_s => order_dir}
+        end
+
+        dict.each do |domain_attr, dir|
+          domain_entity = domain_name
+
+          if domain_attr.count('.') == 2
+            domain_entity, domain_attr = parse_domain_attr(domain_attr)
+          end
+
+          @order <<  create_expr(domain_entity, domain_attr, eq: dir.to_s.upcase)
+        end
+
+        self
+      end
+
+      def order?
+        !@order.empty?
+      end
+
+      def limit?
+        !@limit.nil?
+      end
+
+      # @param limit [Integer]
+      # @return [Criteria]
+      def limit(value = nil)
+        return @limit if value.nil?
+
+        value = Integer(value)
+        fail "limit must be an integer gt 0" unless value > 0
+        @limit = value
+        self
+      end
+
+      # @param page [Integer]
+      # @return [Criteria]
+      def page(value = nil)
+        return @page if value.nil?
+
+        @page = Integer(value)
+        self
+      end
+
+      # @param per_page [Integer]
+      # @return [Criteria]
+      def per_page(value=nil)
+        return @per_page if value.nil?
+
+        @per_page = Integer(value)
+        self
+      end
+
+      # The repo uses this to determine what kind of dataset to return
+      #
+      # @return [Boolean]
+      def single?
+        first? || last?
+      end
+
+      # Tell the repo to only return a single entity for this criteria
+      #
+      # @return [Criteria]
+      def single
+        first
+        self
+      end
+
+      # Set false @first and @last instance variables
+      def clear_single
+        clear_first
+        clear_last
+      end
+
+      def first
+        @first = true
+        clear_last
+        self
+      end
+
+      def first?
+        @first
+      end
+
+      def clear_first
+        @first = false
+      end
+
+      def last?
+        @last
+      end
+
+      def last
+        clear_first
+        @last = true
+        self
+      end
+
+      def clear_last
+        @last = false
+      end
+
+      def disable_pagination?
+        @disable_pagination
+      end
+
+      def disable_pagination
+        @disable_pagination = true
+      end
+
+      # Tell the repo to return a collection for this criteria. This is the
+      # default setting
+      #
+      # @return Criteria
+      def collection
+        clear_single
+        self
+      end
+
+      def all?
+        @all
+      end
+
+      # Tell the repo to return all records for this criteria. It is import
+      # to understand that for database queries you are calling all on the
+      # map for the specified domain.
+      #
+      # @example
+      #   Criteria.new('projects.offer').all
+      #
+      #   UserRepository has a mapper with a map for 'offer' in this case
+      #   all will be called on the db class for this map.
+      #
+      # @return [Criteria]
+      def all
+        @all = true
+        collection
+        self
+      end
+
+      # Used to determin if this criteria belongs to a feature
+      #
+      # @return [Boolean]
+      def feature?
+        !@feature.nil?
+      end
+
+      # Used to determin if this criteria belongs to a global domain
+      #
+      # @return [Boolean]
+      def global_domain?
+        !feature?
+      end
+
+      # Determines if a domain exists in this repo
+      #
+      # @param attr [String]
+      # @param value [Mixed]
+      # @return [Criteria]
+      def exists(domain_attr, value)
+        domain_attr   = domain_attr.to_s
+        domain_entity = domain_name
+        if domain_attr.count('.') == 3
+          domain_entity, domain_attr = parse_domain_attr(domain_attr)
+        end
+        @exists = create_expr(domain_entity, domain_attr, eq: value)
+        self
+      end
+
+      # @return [DbEntityExpr]
+      def exists_expr
+        @exists
+      end
+
+      # exec is used to indicate we want a custom method on the repo
+      # to used with this criteria
+      #
+      # @param name [String]
+      # @return [String, Criteria] when used as a dsl it returns the criteria
+      def exec(name = nil)
+        return @exec if name.nil?
+
+        @exec = name.to_sym
+        self
+      end
+
+      def exec?
+        !@exec.nil?
+      end
+
+      # @yield  expression and operator
+      # @return [Enumerator] when no block is given
+      def each
+        return exprs.each unless block_given?
+
+        exprs.each do |expr|
+          yield expr[:expr], expr[:relational_op]
+        end
+      end
+
+      def error_on_empty_dataset?
+        @error_on_empty
+      end
+
+      # Tells the repo to return an error when entity is not found
+      #
+      # @return Criteria
+      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 Criteria
+      def empty_dataset_is_valid!
+        @error_on_empty = false
+        self
+      end
+
+      private
+      def parse_domain_name(name)
+        if !name.is_a?(String) && !name.respond_to?(:domain_name)
+          fail "domain name must be a string or implement method :domain_name"
+        end
+
+        name = name.domain_name if name.respond_to?(:domain_name)
+        feature, domain = name.split('.', 2)
+        if domain.nil?
+          domain  = feature
+          feature = nil
+        end
+        [feature, domain, name]
+      end
+
+      def create_expr(domain_name, domain_attr, value)
+        Expr.new(domain_name, domain_attr, value)
+      end
+
+      def extract_relational_condition(filter_item)
+        relational_or = (filter_item.delete(:or) == true) if filter_item.key?(:or)
+        relational_or
+      end
+
+      def extract_relational_operator(filter_item)
+        operator = "eq"
+        operator = filter_item.delete(:op) if filter_item.key?(:op)
+        if filter_item[:insensitive]
+          operator = "ilike"
+          filter_item.delete(:insensitive)
+        end
+        operator
+      end
+    end
+  end
+end