appfuel 0.2.0

data/.travis.yml

@@ -0,0 +1,19 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.13.7
+
+deploy:
+  on:
+    tags: true
+  provider: rubygems
+  api_key:
+    secure: Z4sBUqVeIuNJNKxXa+oYDxnfXlVaCAYl3f+8rWm4pKnHpLQYP1M8vj5LM3cmdHtUQiy/085zkvt5C6p2045PZ5sX3rueojoShqfvmNHgr3wYWQ2MZ3oHy3Vl6UJ3JYGoM/2wEclmqWQ49s1Zk4gnNZR4QyNZ/P4SWZ4FmJ9VmlI=
+
+addons:
+  code_climate:
+    repo_token: 11e7712330b39d9d748126a0fccccb0dc60f19536ad3d46f2ca484003ff4899c
+
+after_success:
+  - bundle exec codeclimate-test-reporter

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at rsb.code@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in appfuel.gemspec
+gemspec
+
+group :test do
+  gem "simplecov", "~> 0.13"
+  gem "codeclimate-test-reporter", "~> 1.0.0"
+end

data/README.md

@@ -0,0 +1,38 @@
+[![Travis Build Status](https://travis-ci.org/rsb/appfuel.svg?branch=master)](https://travis-ci.org/rsb/appfuel)
+[![Code Climate](https://codeclimate.com/github/rsb/appfuel/badges/gpa.svg)](https://codeclimate.com/github/rsb/appfuel)
+[![Test Coverage](https://codeclimate.com/github/rsb/appfuel/badges/coverage.svg)](https://codeclimate.com/github/rsb/appfuel/coverage)
+[![Issue Count](https://codeclimate.com/github/rsb/appfuel/badges/issue_count.svg)](https://codeclimate.com/github/rsb/appfuel)
+
+# Appfuel
+Appfuel is a library that employs a set of conventions and patterns used to separate your business code from the API framework in which it lives, while providing a consistent interface for your api code to interact with it. The idea is that your business code should live isolated in its own gem making the api boundary, your rails app for example, just another client..
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'appfuel'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install appfuel
+
+## Usage
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/appfuel. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/appfuel.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'appfuel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "appfuel"
+  spec.version       = Appfuel::VERSION
+  spec.authors       = ["Robert Scott-Buccleuch"]
+  spec.email         = ["rsb.code@gmail.com"]
+
+  spec.summary       = %q{Appfuel decouples your business code from its API framework}
+  spec.description   = %q{A library that allows you to isolate your business code}
+  spec.homepage      = "https://github.com/rsb/appfuel"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # we have to lock dry-types due to failures I am encountering
+  # when dynamically creating form validators. Not sure if it is the library
+  # or the way I am using it.
+  spec.add_dependency "activerecord",     "~> 5.0.2"
+  spec.add_dependency "dry-types",        "0.9.2"
+  spec.add_dependency "dry-container",    "~> 0.6"
+  spec.add_dependency "dry-validation",   "~> 0.10.5"
+  spec.add_dependency "dry-monads",       "~> 0.2"
+  spec.add_dependency "dry-configurable", "~> 0.6"
+
+  spec.add_development_dependency "bundler",            "~> 1.13"
+  spec.add_development_dependency "rake",               "~> 10.0"
+  spec.add_development_dependency "rspec",              "~> 3.5"
+  spec.add_development_dependency "pry",                "~> 0.10"
+  spec.add_development_dependency "awesome_print",      "~> 1.7"
+  spec.add_development_dependency "pry-awesome_print",  ">= 9.6.1"
+  spec.add_development_dependency "database_cleaner",   "~> 1.5"
+  spec.add_development_dependency "faker",              "~> 1.7"
+  spec.add_development_dependency "factory_girl",       "~> 4.8"
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "appfuel"
+require "pry"
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/appfuel.rb

@@ -0,0 +1,210 @@
+# Third party dependencies
+require "json"
+require "dry-validation"
+require "active_record"
+
+require "appfuel/version"
+
+# Appfuel framework for Action/Comand pattern
+require "appfuel/types"
+require "appfuel/errors"
+require "appfuel/run_error"
+
+require "appfuel/configuration"
+require "appfuel/application"
+require "appfuel/initialize"
+require "appfuel/feature"
+
+# Action/command input/output interfaces
+require "appfuel/response"
+require "appfuel/response_handler"
+require "appfuel/request"
+
+# Custom predicates & validators
+require "appfuel/predicates"
+require "appfuel/validation"
+
+# Interface for dscribing domain queries
+
+# Dependency management for actions, commands and repos
+require "appfuel/root_module"
+
+require "appfuel/presenter"
+
+require "appfuel/repository"
+require "appfuel/db_model"
+require "appfuel/repository_runner"
+require "appfuel/storage"
+
+# callable operations
+require "appfuel/handler"
+
+module Appfuel
+  # The appfuel top level interface mainly deals with interacting with both
+  # the application dependency injection container and the framework di
+  # container.
+  class << self
+    attr_writer :framework_container
+
+    # The framework dependency injection container holds information
+    # specific to appfuel plus an app container for each app it will manage.
+    # While it is most common to has only a single app it is designed to
+    # host multiple app since all there dependencies are contained in one
+    # container.
+    #
+    # @return [Dry::Container]
+    def framework_container
+      @framework_container ||= Dry::Container.new
+    end
+
+
+    # The default app name must exist and the container must be registered
+    # for this to be true
+    #
+    # @return [Bool]
+    def default_app?
+      framework_container.key?(:default_app_name) &&
+        framework_container.key?(framework_container[:default_app_name])
+    end
+
+    # Used when retrieving, resolving an item from or registering an item
+    # with an application container without using its name. The default
+    # app is considered the main app where all others have to be specified
+    # manually. This is assigned during setup via the module
+    # Appfuel::Initialize::Setup
+    #
+    # @raises Dry::Container::Error when default_app_name is not registered
+    #
+    # @return [String]
+    def default_app_name
+      framework_container[:default_app_name]
+    end
+
+    # The application container is a di container used to hold all dependencies
+    # for the given application.
+    #
+    # @raises Dry::Container::Error when name is not registered
+    #
+    # @param name [String, Nil]  default name is used when name is nil
+    # @return [Dry::Container]
+    def app_container(name = nil)
+      framework_container[name || default_app_name]
+    end
+
+    # Resolve an item out of the application container
+    #
+    # @raises RuntimeError when container does not implement :resolve
+    # @raises Dry::Container::Error when key is not registered
+    # @raises Dry::Container::Error when app_name is not registered
+    #
+    # @param key [String] key of the item in the app container
+    # @param app_name [String, Nil] name of the app container
+    # @return the item that was resolved with name
+    def resolve(key, app_name = nil)
+      di = app_container(app_name)
+      unless di.respond_to?(:resolve)
+        fail "Application container (#{app_name}) does not implement :resolve"
+      end
+      di.resolve(key)
+    end
+
+
+    # Register an item in the application container
+    #
+    # @raises RuntimeError when container does not implement :register
+    # @raises Dry::Container::Error when key is not registered
+    # @raises Dry::Container::Error when app_name is not registered
+    #
+    # @param key [String] key of the item in the app container
+    # @param app_name [String, Nil] name of the app container
+    # @return the item that was resolved with name
+    def register(key, value, app_name = nil)
+      di = app_container(app_name)
+      unless di.respond_to?(:register)
+        fail "Application container (#{app_name}) does not implement :register"
+      end
+      di.register(key, value)
+    end
+
+
+    def setup_container_dependencies(namespace_key, container)
+      container.namespace(namespace_key) do
+        register('initializers', ThreadSafe::Array.new)
+        register('validators', {})
+        register('repositories', {})
+        register('validator_pipes', {})
+        register('domain_builders', {})
+        register('presenters', {})
+      end
+      container
+    end
+
+    # Run all initializers registered in the app container
+    #
+    # @param container [Dry::Container] application container
+    # @param app_name [String] name of the app for errors
+    # @param params [Hash]
+    # @option excludes [Array] list of initializers to exclude from running
+    # @return [Dry::Container] same container passed in
+    def run_initializers(key, container, exclude = [])
+      unless exclude.is_a?(Array)
+        fail ArgumentError, ":exclude must be an array"
+      end
+      exclude.map! {|item| item.to_s}
+
+      env    = container[:env]
+      config = container[:config]
+      container["#{key}.initializers"].each do |init|
+        if !init.env_allowed?(env) || exclude.include?(init.name)
+          next
+        end
+
+        begin
+          init.call(config, container)
+        rescue => e
+          app_name = container[:app_name]
+          msg = "[Appfuel:#{app_name}] Initialization FAILURE - " + e.message
+          error = RuntimeError.new(msg)
+          error.set_backtrace(e.backtrace)
+          raise error
+        end
+      end
+      container.register("#{key}.initialized", true)
+
+      container
+    end
+
+    # memberships.user => features.memberships.presenters.user
+    # global.user      => global.presenters.user
+    #
+    # array
+    #   global
+    #   user
+    #
+    # array
+    #   membership
+    #   user
+    def presenter(key, opts = {}, &block)
+      key = expect_container_key(key, 'presenters')
+      container = app_container(root_name | default_app_name)
+
+      container.register(key, '')
+
+    end
+
+    def expand_container_key(key, category)
+      parts = key.to_s.split('.')
+      parts.insert(1, category)
+      if parts.first != 'global'
+        parts.unshift('features')
+      end
+      parts.join('.')
+    end
+
+  end
+end
+
+# Domain Entities
+require "appfuel/domain"
+
+

data/lib/appfuel/application.rb

@@ -0,0 +1,4 @@
+require_relative 'application/root'
+require_relative 'application/app_container'
+require_relative 'application/container_key'
+require_relative 'application/container_class_registration'

data/lib/appfuel/application/app_container.rb

@@ -0,0 +1,223 @@
+module Appfuel
+  module Application
+    # Mixins to allow you to handle application container keys. The application
+    # container operates based on certain conventions which we take into account
+    # here.
+    module AppContainer
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.extend(ContainerClassRegistration)
+      end
+
+      module ClassMethods
+        # Parse the namespace assuming it is a ruby namespace and assign
+        # the list to container_path_list
+        #
+        # @param namespace [String]
+        # @return [Array]
+        def load_path_from_ruby_namespace(namespace)
+          self.container_path = parse_list_string(namespace, '::')
+        end
+
+        # Parse the namespace assuming it is a dry container namespace and
+        # assign the list to container_path_list
+        #
+        # @param namespace [String]
+        # @return [Array]
+        def load_path_from_container_namespace(namespace)
+          self.container_path = parse_list_string(namespace, '.')
+        end
+
+        # @param namespace [String] encoded string that represents a path
+        # @param char [String] character used to split the keys into a list
+        # @return [Array] an array of lower case snake cased strings
+        def parse_list_string(namespace, char)
+          fail "split char must be '.' or '::'" unless ['.', '::'].include?(char)
+          namespace.to_s.split(char).map {|i| i.underscore }
+        end
+
+        # return [Boolean]
+        def container_path?
+          !@container_path.nil?
+        end
+        # @param list [Array] list of container namespace parts including root
+        # @return [Array]
+        def container_path=(list)
+          fail "container path list must be an array" unless list.is_a?(Array)
+          @container_path = list
+          @container_path.freeze
+        end
+
+        # An array representation of the application container namespace, where
+        # the root is the name of the application and not part of the namespace
+        # and the rest is hierarchical path to features or globals
+        #
+        # @return [Array]
+        def container_path
+          load_path_from_ruby_namespace(self.to_s) unless container_path?
+          @container_path
+        end
+
+        # This is the application name used to identify the application container
+        # that is stored in the framework container
+        #
+        # @return string
+        def container_root_name
+          container_path.first
+        end
+
+        # All root namespace for anything inside features, use this name. It is
+        # important to note that to avoid long namespace in ruby features are the
+        # name of the module directly below the root.
+        #
+        # @return [String]
+        def container_features_root_name
+          @container_features_root_name ||= 'features'
+        end
+
+
+        # The actual name of the feature
+        #
+        # @return [String]
+        def container_feature_name
+          container_path[1]
+        end
+
+        # The feature name is the second item in the path, that is always prexfix
+        # with "features"
+        #
+        # @return [String]
+        def container_feature_key
+          @container_feature_key ||= (
+            "#{container_features_root_name}.#{container_feature_name}"
+          )
+        end
+
+        # Container key relative from feature or global, depending on which class
+        # this is mixed into
+        #
+        # @return [String]
+        def container_relative_key
+          @container_relative_key ||= container_path[2..-1].join('.')
+        end
+
+        # This refers to either the global path or the path to a particular
+        # feature
+        #
+        # @return [String]
+        def top_container_key
+          container_global_path? ? container_global_name : container_feature_key
+        end
+
+        def container_key_basename
+          @container_path.last
+        end
+
+        # Fully qualified key, meaning you can access the class this was mixed into
+        # if you stored it into the container using this key
+        #
+        # @return [String]
+        def container_qualified_key
+          @container_qualified_key ||= (
+            "#{top_container_key}.#{container_relative_key}"
+          )
+        end
+
+        # Determines if the container path represents a global glass
+        #
+        # @return [Boolean]
+        def container_global_path?
+          container_path[1] == container_global_name
+        end
+
+        # @return [String]
+        def container_global_name
+          @container_global_name ||= 'global'
+        end
+
+        # Convert the injection key to a fully qualified namespaced key that
+        # is used to pull an item out of the app container.
+        #
+        # Rules:
+        #   1) split the injection key by '.'
+        #   2) use the feature_key as the initial namespace
+        #   3) when the first part of the key is "global" use that instead of
+        #      the feature_key
+        #   4) append the type_key to the namespace unless it is "container"
+        #      type_key like "repositories" or "commands" removes the need for
+        #      the user to have to specify it since they already did that when
+        #      they used the type param.
+        #
+        #
+        #   note: feature_key in these examples will be "features.my-feature"
+        #   @example of a feature repository named foo
+        #
+        #       convert_to_qualified_container_key('foo', 'repositories')
+        #
+        #       returns 'features.my-feature.repositories.foo'
+        #
+        #   @example of a global command names bar
+        #
+        #       convert_to_qualified_container_key('global.bar', 'commands')
+        #
+        #       returns 'gloval.commands.bar'
+        #
+        #   @example of a container item baz
+        #     NOTE: feature container items are not in any namespace, they are any item
+        #           that can resolve from the namespace given by "feature_key"
+        #
+        #      convert_to_qualified_container_key('baz', 'container')
+        #
+        #      returns 'features.my-feature.baz'
+        #
+        #   @example of a global container item baz
+        #     NOTE: global container items are not in any namespace, they are any item
+        #           you can resolve from the application container.
+        #
+        #     convert_to_qualified_container_key('global.baz', 'container')
+        #
+        #     returns 'baz'
+        #
+        # @param key [String] partial key to be built into fully qualified key
+        # @param type_ns [String] namespace for key
+        # @return [String] fully qualified namespaced key
+        def qualify_container_key(key, type_ns)
+          parts     = key.to_s.split('.')
+          namespace = "#{container_feature_key}."
+          if parts[0].downcase == 'global'
+            namespace = 'global.'
+            parts.shift
+          elsif parts[0] == container_feature_name
+            parts.shift
+          end
+
+          # when the key is a global container the namespace is only the path
+          if type_ns == "container"
+            namespace = '' if namespace == 'global.'
+            type_ns = ''
+          else
+            type_ns = "#{type_ns}."
+          end
+
+          path = parts.join('.')
+          "#{namespace}#{type_ns}#{path}"
+        end
+
+        def app_container
+          Appfuel.app_container(container_root_name)
+        end
+
+      end
+
+      # Instance methods
+      def qualify_container_key(key, type_ns)
+        self.class.qualify_container_key(key, type_ns)
+      end
+
+      def app_container
+        self.class.app_container
+      end
+
+    end
+  end
+end