perfume 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cdbf43b151d7f376a9858e70e92c2a86dc815a73
+  data.tar.gz: 44e31ee400a397f536e36ee94eea30f7abe6fc06
+SHA512:
+  metadata.gz: 1506aa517bcc89219aabaa16765d51f140fc5d841625f3f8f8a4a7813485f76057fc83e8608bfb8c316c039224ad474bac11efb4286703a200acb98e77a69a07
+  data.tar.gz: cf04e57c3e583617460867bae3d1b45df456daedac7e4206c576c34ee2ed829129bdf5204b24de088bf739a30e2a444af397db8eca361b7c9f011885c02e9e67

data/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+...
+
+## [0.1.0]
+
+### Added
+
+- Project extracted from other library and moved into this standalone gem.

data/Dockerfile

@@ -0,0 +1,11 @@
+FROM ruby:2.2
+
+ENV GEM_NAME perfume
+ENV WORKDIR /usr/local/src/$GEM_NAME
+
+RUN mkdir -p $WORKDIR
+WORKDIR $WORKDIR
+ADD . $WORKDIR
+RUN bundle install
+
+CMD bundle exec rake spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in perfume.gemspec
+gemspec

data/README.md

@@ -0,0 +1,78 @@
+# Rake Bump
+
+[![Status](https://codeship.com/projects/xxx/status?branch=master)](https://codeship.com/projects/xxx)
+
+Perfume is a set of fragrances to make your (micro)services code smell nice. It's bunch of common practices and
+shorthands to deal with common problems. At the moment it includes the following stuff:
+
+* So called SuperObject - a lightweight hash-initialized struct-like object.
+* So called Service - a callable object that's designed to implement your business processes.
+* So called Promise - extended Service with ignorable errors.
+* Unified and pre-configured logging (adapted Log4r).
+* Shell services.
+* Console interaction service.
+* Exit (abort) service.
+* Various core extensions.
+* Testing utilities.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'perfume', '0.1.0'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install perfume --version 0.1.0
+
+## Usage
+
+TODO: ...
+
+## Development
+
+You have two options to work with this project. The [docker flow](#setup-with-docker) is suggested since solves problems of compatibility of tools.
+
+### Manual Setup
+
+First off, make sure you have **Ruby 2.2+** and latest version of **Bundler** on your machine. After checking out the repo, you can install dependencies and prepare the project with:
+
+    $ bin/setup
+
+Now you can run tests:
+
+    $ bundle exec rake spec
+
+You can also connect to interactive prompt that will allow you to experiment. To do this, run:
+
+    $ bundle exec bin/console
+
+To install this gem onto your local machine, run:
+
+    $ bundle exec rake install
+
+### Setup with Docker
+
+If you're lazy and don't wanna get into how the setup works, here's something for you. This project comes fully [dockerized](http://docker.io/). Install docker toolchain and then go for:
+
+    $ docker-compose build
+
+All done, you can do testing and fiddling around:
+
+    $ docker-compose run perfume bash
+    root@xyyyyxx:/usr/local/src/perfume# bundle exec rake spec
+    root@xyyyyxx:/usr/local/src/perfume# bundle exec bin/console
+
+### Releasing new version
+
+This project is powered by rake-bump. To release gem version, follow [this continuous releasing guide](https://github.com/jobandtalent/rake-bump#continuous-releasing)
+
+## Contributing
+
+Bug reports and pull requests are welcome [here](https://github.com/kkvlk/perfume/issues).

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "perfume/version"
+# require "rake/bump/tasks"
+require "rake/testtask"
+
+# Rake::Bump::Tasks.new do |t|
+#   t.gem_name = 'perfume'
+#   t.gem_current_version = Perfume::VERSION
+# end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "perfume"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

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

data/docker-compose.yml

@@ -0,0 +1,4 @@
+perfume:
+  build: .
+  volumes:
+    - .:/usr/local/src/perfume:rw

data/lib/perfume/all.rb

@@ -0,0 +1,9 @@
+module Perfume
+  require 'perfume/logging'
+  require 'perfume/service'
+  require 'perfume/promise'
+  require 'perfume/shell'
+  require 'perfume/exit'
+  require 'perfume/console'
+  require 'perfume/core_ext/dir'
+end

data/lib/perfume/console.rb

@@ -0,0 +1,62 @@
+require 'perfume/super_object'
+
+module Perfume
+  # Public: Sometimes there's a need to ask user a question or to get stuff from him.
+  # This simple class handles this. You can initialize this virtual "Console" pointed to
+  # given input and output stream and perform common operations like getting user input,
+  # asking questions (yes/no questions too), etc.
+  class Console < SuperObject
+    args :input, :output
+
+    def defaults
+      { input: STDIN, output: STDOUT }
+    end
+
+    # Public: Reads user input from given input stream. The answer can be either obtained
+    # from result or yielded value.
+    def read_user_input(&block)
+      value = @input.gets.to_s.strip
+      block_given? ? block.call(value) : value
+    end
+
+    # Public: Asks user a question. As with #read_user_input, the answer can be obtained
+    # from both, return value and yielded argument.
+    #
+    # Example
+    #
+    #   console = Console.new
+    #   console.ask("How much do you know?") do |answer|
+    #     puts "So you know #{answer}"
+    #   end
+    #
+    #   $ How much do you know?: nothing
+    #   $ So you know nothing...
+    #
+    def ask(question, &block)
+      @output.write(question + ': ')
+      read_user_input(&block)
+    end
+
+    # Public: Same like #ask, but converts the answer to boolean value. It also formats
+    # the question a little bit to indicate that we're asking about the boolean. Any other
+    # answer than case insensitive "y" or "yes" will be converted to false.
+    #
+    # Example
+    #
+    #   console = Console.new
+    #   console.ask("Are you Jon Snow?") do |answer|
+    #     puts "Answer: #{answer.inspect}"
+    #   end
+    #
+    #   $ Are you Jon Snow? [y/N]: Yes
+    #   $ Answer: true
+    #
+    def ask_yes_or_no(question, &block)
+      ask(question + ' [y/N]') do |answer|
+        %[y yes].include?(answer.downcase).tap do |bool_answer|
+          yield bool_answer if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/perfume/core_ext/dir.rb

@@ -0,0 +1,16 @@
+module Perfume
+  module CoreExt
+    module Dir
+      # Public: A helper that's a fusion of Dir.mktmpdir and Dir.chdir. Lazieness FTW!
+      def chtmpdir(&block)
+        ::Dir.mktmpdir do |dir|
+          ::Dir.chdir(dir) do
+            yield dir
+          end
+        end
+      end
+    end
+  end
+end
+
+Dir.extend(Perfume::CoreExt::Dir)

data/lib/perfume/exit.rb

@@ -0,0 +1,23 @@
+require 'perfume/service'
+
+module Perfume
+  # Public: There's often need to exit from the app in a testable and graceful manner.
+  # Simple call to Kernel#exit isn't such. This simple wrapper around the Kernel method
+  # allows to say goodbye message via service logging as well as status code.
+  class Exit < Service
+    args :message, :code, :log
+
+    def defaults
+      { message: "Exiting...", code: 1 }
+    end
+
+    def log
+      @log ||= self.class.log
+    end
+
+    def call
+      log.error(@message)
+      Kernel.exit(@code)
+    end
+  end
+end

data/lib/perfume/logging/command_line_output_formatter.rb

@@ -0,0 +1,25 @@
+module Perfume
+  module Logging
+    # Internal: For command line apps we rather don't want to display all the logging information
+    # to the user. Just to avoid noise, INFO messages are displayed as is, and any other log levels
+    # are prefixed with the level name. Example:
+    #
+    #   This is simple info message.
+    #   And another one.
+    #   WARN: Uups, something's not right here...
+    #   And another info message.
+    #   DEBUG: We need to go deeper!
+    #   ERROR: Limbo!
+    #
+    class CommandLineOutputFormatter < Log4r::Formatter
+      def initialize
+        @info_formatter = Log4r::PatternFormatter.new(:pattern => "%m")
+        @else_formatter = Log4r::PatternFormatter.new(:pattern => "%l: %m")
+      end
+
+      def format(logevent)
+        (Log4r::INFO == logevent.level ? @info_formatter : @else_formatter).format(logevent)
+      end
+    end
+  end
+end

data/lib/perfume/logging/log4r_adapter.rb

@@ -0,0 +1,33 @@
+module Perfume
+  module Logging
+    # Internal: Adapter for Log4r logging system. It's a poor version of what Slf4j does to Log4j in
+    # java apps. Just tiny layer to improve on logging payloads.
+    class Log4rAdapter
+      class Event
+        def initialize(message, payload)
+          @message, @payload = message, payload || {}
+          @payload_formatted = @payload.map { |k,v| "#{k}=#{v.inspect}" }.join(" ")
+          @s = [ @message,  @payload_formatted.empty? ? nil : @payload_formatted].compact.join("; ")
+        end
+
+        def to_s
+          @s
+        end
+      end
+
+      def initialize(log)
+        @log = log
+      end
+
+      def method_missing(method, *args, &block)
+        @log.send(method, *args, &block)
+      end
+
+      %w[debug info warn error fatal].each do |level|
+        define_method(level) do |obj_or_msg, payload=nil|
+          @log.send(level, obj_or_msg.is_a?(String) ? Event.new(obj_or_msg, payload).to_s : obj_or_msg)
+        end
+      end
+    end
+  end
+end

data/lib/perfume/logging/package_logger.rb

@@ -0,0 +1,25 @@
+require 'log4r'
+require 'perfume/logging/log4r_adapter'
+
+module Perfume
+  module Logging
+    # Public: Similarly to Perfume::Logging no point to initialize global logger for your
+    # modules/packages. Include this mixin to define LOGGER constant and log class method
+    # shortcut.
+    #
+    # Often used practice is to define such top level logger as a parent with default
+    # outputters, formatters, log level, etc.
+    module PackageLogger
+      def self.included(klass)
+        klass.const_set(:LOGGER, Logging::Log4rAdapter.new(Log4r::Logger.new(klass.name)))
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def log
+          const_get(:LOGGER)
+        end
+      end
+    end
+  end
+end

data/lib/perfume/logging.rb

@@ -0,0 +1,26 @@
+require 'log4r'
+
+module Perfume
+  # Public: Log4r is awesome, but why initialize it for every class manually if you
+  # can use simple extension that will do it for you. This one injects class and
+  # instance `log` methods to access class logger.
+  module Logging
+    require 'perfume/logging/log4r_adapter'
+    require 'perfume/logging/command_line_output_formatter'
+    require 'perfume/logging/package_logger'
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    def log
+      self.class.log
+    end
+
+    module ClassMethods
+      def log
+        @log ||= Log4rAdapter.new(Log4r::Logger.new(self.name))
+      end
+    end
+  end
+end

data/lib/perfume/promise.rb

@@ -0,0 +1,121 @@
+require 'perfume/service'
+
+module Perfume
+  # Public: Very often we're in a situation that we have to catch and eventuall log some
+  # errors, or even more, solely catch errors for purpose of logging. Other times we must
+  # perform multiple actions in different places according to the results produces by our
+  # method or service. We'd normally have to pass these results around deppening our stack
+  # trace. Here comes this a bit twisted implementation of a promise. Maybe twisted is
+  # wrong description, it's rather simplified. It's not parallel, it's simple to the bones.
+  # It just allows you to define three kinds of callbacks: before call, on success and
+  # on failure of course. Since it inherits from our own Service, it essentially is one
+  # with own logging and access to class level call method.
+  #
+  # Here's few interesting properties:
+  #
+  # 1. Define your logic in #call! method. Yes call with bang.
+  #
+  #      class FindWally < Perfume::Promise
+  #        NotFoundWarning = Class.new(Warning)
+  #
+  #        def call!
+  #          Wally.latest_location.tap do |location|
+  #            raise NotFoundWarning, "No idea where is Wally!" if location.nil?
+  #          end
+  #        end
+  #      end
+  #
+  # 2. Failures are dependent on the kind of error thrown. It means that the flow
+  #    is directed by raised errors. Slow you might say, but benchmarking this shows that
+  #    the overhead is negligible in real life apps. This also allows a nifty trick. Look
+  #    at the example of `FindWally` above. Why there's `NotFoundWarning` inhertiting from
+  #    magical `Warning` class? The `Warning` is bundled into each new promise defined.
+  #    This errors are not thrown like regular exceptions. Instead they're handled and
+  #    logged as warnings. This error will be passed to our `failure` callbacks as well.
+  #    Check example:
+  #
+  #      FindWally.call do |_location|
+  #        raise StandardError, "Something went wrong!"
+  #      end
+  #
+  #    This one raises `StandardError`, while this one:
+  #
+  #      find_wally = FindWally.new
+  #      find_wally.failure { |err| puts err.message }
+  #      find_wally.call { |_location| raise FindWally::Warning, "Uuups!" }
+  #
+  #    Will log WARNING with "Uuups!" message.
+  #
+  # 3. Block passed to call is added to on success callbacks:
+  #
+  #      FindWally.call do |location|
+  #        puts location
+  #      end
+  #
+  #      $ "Madrid"
+  #
+  class Promise < Service
+    Warning = Class.new(Exception)
+
+    def self.inherited(child)
+      child.const_set(:Warning, Warning)
+    end
+
+    def initialize(*)
+      super
+
+      @__before     = []
+      @__on_success = []
+      @__on_failure = []
+    end
+
+    def before(&block)
+      @__before << block
+      self
+    end
+
+    def success(&block)
+      @__on_success << block
+      self
+    end
+
+    def failure(&block)
+      @__on_failure << block
+      self
+    end
+
+    def success?
+      @__ok
+    end
+
+    def failure?
+      !success?
+    end
+
+    # Public: Your logic goes here. Flow is broken by raising an exception of local Error
+    # class or child classes. Any return value will be passed to on-success callbacks.
+    def call!
+      raise NotImplementedError
+    end
+
+    # Pubic: Safely executes your logic defined in call!, taking care that all callbacks
+    # are properly called.
+    def call(&block)
+      @__ok = false
+      @__before.each(&:call)
+      success_callbacks = @__on_success + [block]
+      call!.tap { |result| success_callbacks.compact.each { |callback| callback.call(result) } }
+      @__ok = true
+      self
+    rescue Warning => err
+      log.warn(err)
+      @__on_failure.each { |callback| callback.call(err) }
+      return nil
+    end
+  end
+
+  # Public: Shorthand to define a Promise with accessors.
+  def self.Promise(*names, &block)
+    Class.new(Promise, &block).tap { |klass| klass.args_accessor(*names) }
+  end
+end

data/lib/perfume/service.rb

@@ -0,0 +1,38 @@
+require 'active_support/core_ext/hash/keys'
+require 'perfume/super_object'
+
+module Perfume
+  # Public: The pattern is simple, our Service is a struct with init arguments that
+  # additionally is callable. It also comes with class level `call` method that
+  # executes stuff on new instance of the object.
+  class Service < SuperObject
+    include Logging
+
+    # Public: Shorthand to instantionante with arguments and perform call in one shot.
+    # You should actually always intend to use this method as it's easier to mock
+    # in testing.
+    def self.call(args = {}, &block)
+      new(args).call(&block)
+    end
+
+    # Public: Implement this one on your own. Your logic goes here.
+    def call(&block)
+      raise NotImplementedError
+    end
+
+    protected
+
+    def system_call(*args, &block)
+      Shell::SystemCall.call(*args, &block)
+    end
+
+    def exec(*args, &block)
+      Shell::Exec.call(*args, &block)
+    end
+  end
+
+  # Public: Shorthand to define a Service with accessors.
+  def self.Service(*names, &block)
+    Class.new(Service, &block).tap { |klass| klass.args_accessor(*names) }
+  end
+end

data/lib/perfume/shell/base.rb

@@ -0,0 +1,38 @@
+require 'perfume/service'
+
+module Perfume
+  module Shell
+    # Internal: Executing shell commands isn't good practice. Especially it's bad when
+    # calling ruby methods like `exec` or `system`. This is dangerous and completely
+    # untestable. So here it comes base wrapper around shell calls.
+    #
+    # Check Perfume::Shell::Exec and Perfume::Shell:SystemCall for two most common
+    # use cases.
+    class Base < Perfume::Service(:cmd, :root, :log)
+      def init
+        @root = Pathname.new(@root)
+      end
+
+      def log
+        @log or self.class.log
+      end
+
+      def defaults
+        { root: Dir.pwd }
+      end
+
+      def before
+      end
+
+      def to_s
+        cmd.to_s
+      end
+
+      protected
+
+      def fail!(msg = "Shell command execution failed!")
+        raise ExecutionError, msg
+      end
+    end
+  end
+end

data/lib/perfume/shell/exec.rb

@@ -0,0 +1,57 @@
+module Perfume
+  module Shell
+    # Public: Go for Exec when you need to obtain standard output of the command. It uses
+    # the %x[] call under the hood. Note that it doesn't raise errors when return status
+    # is different than 0. Same as with Perfume::Shell::SystemCall, you should go for
+    # inheriting from this class:
+    #
+    #   class GitDirtyTreeValidation < Perfume::Shell::Exec
+    #     Error = Class.new(StandardError)
+    #
+    #     def cmd
+    #       'git status -s'
+    #     end
+    #
+    #     def fail_on_error?
+    #       true
+    #     end
+    #
+    #     def handle
+    #       raise Error, "Uncommited changes detected!" unless output.strip.empty?
+    #     end
+    #   end
+    #
+    class Exec < Base
+      args :fail_on_error
+      attr_reader :output, :rc
+
+      def init
+        @__done = []
+        @fail_on_error = false if @fail_on_error.nil?
+      end
+
+      def fail_on_error?
+        @fail_on_error
+      end
+
+      def call(&block)
+        Dir.chdir(@root.to_s) do
+          before
+          log.debug("Executing shell command and waiting for result", cmd: cmd, root: @root.to_s)
+          @output, @rc = [ %x[#{cmd} 2>&1], $?.to_i ]
+          fail! if fail_on_error? and @rc != 0
+          result = respond_to?(:handle) ? handle : [ @output, @rc ]
+          yield result if block_given?
+          return result
+        end
+      end
+
+      protected
+
+      def fail!(*)
+        $stderr.write(@output)
+        super
+      end
+    end
+  end
+end

data/lib/perfume/shell/system_call.rb

@@ -0,0 +1,32 @@
+module Perfume
+  module Shell
+    # Public: Simple system call. Use it when you need to just execute something, eventually
+    # silently and you don't care about the result. Uses `system` under the hood. Feel free
+    # to inherit from this class, example:
+    #
+    #   class GitCommit < Perfume::Shell::SystemCall
+    #     args :message
+    #
+    #     def cmd
+    #       'git commit -m #{@message.inspect}'
+    #     end
+    #   end
+    #
+    class SystemCall < Base
+      args :quiet
+
+      def defaults
+        super.merge(quiet: false)
+      end
+
+      def call
+        Dir.chdir(@root.to_s) do
+          before
+          log.debug("Executing shell command", cmd: cmd, root: @root.to_s)
+          system([ cmd, !!@quiet ? ' &>/dev/null' : nil ].compact.join(' '))
+          fail! unless $?.to_i == 0
+        end
+      end
+    end
+  end
+end

data/lib/perfume/shell.rb

@@ -0,0 +1,10 @@
+module Perfume
+  module Shell
+    # Public: Raised when shell command returned non-zero exit status.
+    ExecutionError = Class.new(StandardError)
+
+    require 'perfume/shell/base'
+    require 'perfume/shell/system_call'
+    require 'perfume/shell/exec'
+  end
+end

data/lib/perfume/super_object.rb

@@ -0,0 +1,93 @@
+module Perfume
+  # Public: Premise is tha using method arguments sucks because you need to remember the order,
+  # sucks even more when you might have lot of them (like structure/service initializers).
+  #
+  # It's often seen in ruby to declare classes that inherit from Struct. There we have problem
+  # of arguments order. Maybe I wanna specify defaults? Maybe I wanna pass only one argument
+  # from the middle of the list? For such cases people use OpenStruct or third-party stuff
+  # like Hashie::Dash. Not a good idea either because those classes are bloated with useless
+  # methods.
+  #
+  # Here's how this super object works:
+  #
+  #   class Women < SuperObject(:name, :surname)
+  #     args :married
+  #
+  #     def title
+  #       @married ? 'Mrs.' : 'Miss'
+  #     end
+  #
+  #     def to_s
+  #       [ title, name, surname ].join(' ')
+  #     end
+  #   end
+  #
+  #   ada = Women.new(name: "Ada", surname: "Lovelace", married: true)
+  #   ada.name                        # => "Ada"
+  #   ada.surname                     # => "Lovelace"
+  #   ada.to_s                        # => "Mrs. Ada Lovelace"
+  #
+  #   mary = Women.new(name: "mary", surname: "Cassat", married: false)
+  #   mary.to_s                       # => "Miss Mary Cassat"
+  #   mary.married                    # => NoMethodError
+  #
+  #   Women.new(unknown: 'Something') # => ArgumentError
+  #
+  # By default `args` method defines only instance variables. Then we have `args_accessor`,
+  # which is called for all class parameters, `args_reader` and `args_writer` if you need
+  # to expose some stuff.
+  class SuperObject
+    # Public: Returns list of defined arguments. Note that superclass arguments are inherited
+    # by child class.
+    def self.init_args
+      @init_args ||= superclass.respond_to?(:init_args) ? superclass.init_args.dup : []
+    end
+
+    # Public: Defines unaccessible arguments.
+    def self.args(*names)
+      init_args.concat(names)
+    end
+
+    # Public: Defines given init arguments alongside with accessor methods.
+    def self.args_accessor(*names)
+      names = names.map(&:to_sym)
+      args(*names)
+      attr_accessor(*names)
+    end
+
+    # Public: Defines given init arguments alongside with reader method.
+    def self.args_reader(*names)
+      args(*names)
+      attr_reader(*names)
+    end
+
+    # Public: Defines given init arguments alongside with writer method.
+    def self.args_writer(*names)
+      args(*names)
+      attr_writer(*names)
+    end
+
+    def initialize(args = {})
+      args.symbolize_keys!
+      unknown_args = args.keys - self.class.init_args
+      raise ArgumentError, "Unknown arguments: #{unknown_args.map(&:inspect).join(', ')}" unless unknown_args.empty?
+      args = defaults.symbolize_keys.merge(args)
+      self.class.init_args.each { |name| instance_variable_set("@#{name}", args[name]) }
+      init
+    end
+
+    # Public: Extra initialization.
+    def init
+    end
+
+    # Public: Override it with your own default arguments.
+    def defaults
+      {}
+    end
+  end
+
+  # Public: Shorthand to define a super object with accessors.
+  def self.SuperObject(*names, &block)
+    Class.new(SuperObject, &block).tap { |klass| klass.args_accessor(*names) }
+  end
+end

data/lib/perfume/testing/fixture_files.rb

@@ -0,0 +1,38 @@
+require 'pathname'
+require 'forwardable'
+
+module Perfume
+  module Testing
+    # Public: Sometimes you have to test file contents or some biggest chunks of data. Put them in fixtures
+    # folder and load using this helper class. Example:
+    #
+    #   MY_FIXTURE_FILES = FixtureFiles.load('path/to/fixtures/*.txt')
+    #   MY_FIXTURE_FILES.each { |content| ... }
+    #   puts MY_FIXTURE_FILES['filename.txt']
+    #
+    class FixtureFiles
+      extend Forwardable
+      def_delegators :@fixtures, :[], :size, :each
+
+      include Enumerable
+
+      class << self
+        alias :load :new
+      end
+
+      def initialize(dir)
+        @fixtures = load_fixtures(dir)
+      end
+
+      private
+
+      def load_fixtures(dir)
+        {}.tap do |fixtures|
+          Pathname.glob(dir.to_s) do |entry|
+            fixtures[entry.basename.to_s] = entry.read if entry.file?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/perfume/testing/support.rb

@@ -0,0 +1,15 @@
+require 'pathname'
+
+module Perfume
+  module Testing
+    # Public: You load support files in pretty much every test/spec helper. It's stupid to repeat yourself
+    # like this. Use following helper to load support stuff from given directory.
+    module Support
+      def self.require_all(dir)
+        Dir.glob(dir.join('*.rb').to_s) do |f|
+          require f
+        end
+      end
+    end
+  end
+end

data/lib/perfume/testing.rb

@@ -0,0 +1,6 @@
+module Perfume
+  module Testing
+    require 'perfume/testing/support'
+    require 'perfume/testing/fixture_files'
+  end
+end

data/lib/perfume/version.rb

@@ -0,0 +1,3 @@
+module Perfume
+  VERSION = '0.1.0'
+end

data/lib/perfume.rb

@@ -0,0 +1,3 @@
+module Perfume
+  require 'perfume/version'
+end

data/perfume.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'perfume/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "perfume"
+  spec.version = Perfume::VERSION
+  spec.authors = ["jobandtalent", "Kris Kovalik"]
+  spec.email = ["kris.kovalik@jobandtalent.com", "hi@kkvlk.me"]
+
+  spec.summary = %q{Tooling for writing (micro)services in Ruby.}
+  spec.description = %q{Bunch of tools and utilities for common day-to-day tasks while working with microservices.!}
+  spec.homepage = "https://github.com/jobandtalent/perfume"
+  spec.license = 'Apache-2.0'
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1"
+  spec.add_development_dependency "mocha", "~> 1.1"
+  # spec.add_development_dependency "rake-bump", "~> 0.4"
+
+  spec.add_dependency "activesupport", "~> 4.2", ">= 3.0"
+  spec.add_dependency "log4r", "~> 1.1", ">= 1.1"
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: perfume
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jobandtalent
+- Kris Kovalik
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Bunch of tools and utilities for common day-to-day tasks while working
+  with microservices.!
+email:
+- kris.kovalik@jobandtalent.com
+- hi@kkvlk.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- CHANGELOG.md
+- Dockerfile
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docker-compose.yml
+- lib/perfume.rb
+- lib/perfume/all.rb
+- lib/perfume/console.rb
+- lib/perfume/core_ext/dir.rb
+- lib/perfume/exit.rb
+- lib/perfume/logging.rb
+- lib/perfume/logging/command_line_output_formatter.rb
+- lib/perfume/logging/log4r_adapter.rb
+- lib/perfume/logging/package_logger.rb
+- lib/perfume/promise.rb
+- lib/perfume/service.rb
+- lib/perfume/shell.rb
+- lib/perfume/shell/base.rb
+- lib/perfume/shell/exec.rb
+- lib/perfume/shell/system_call.rb
+- lib/perfume/super_object.rb
+- lib/perfume/testing.rb
+- lib/perfume/testing/fixture_files.rb
+- lib/perfume/testing/support.rb
+- lib/perfume/version.rb
+- perfume.gemspec
+homepage: https://github.com/jobandtalent/perfume
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Tooling for writing (micro)services in Ruby.
+test_files: []