chore-core 1.5.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDg1NjQ5Yzk0YzUwOGI5NDYxNWYyYmVhNTU4MmY5MTk2NWFjZjZmNA==
+  data.tar.gz: !binary |-
+    YmU5ZjI5YTFlNWUyODE3NzZlYzlkNjQ5NTFlZDViOWI4ZTZiYzU3Yg==
+SHA512:
+  metadata.gz: !binary |-
+    OWRlNjA2ZTI2Mjg2ZGRiYjk5MzY4Nzk1ZjNlMTMzM2UyMzU5NTdhZDI0ZDI2
+    Nzg1NTRkNGViZWI4NjgxNzkwYWQ4ZDM1YWU4MmQyMTgwNzRhMmYwMDRlYmMx
+    OTM3MDY5NWY5YjllZmZiM2I2NDJjZGE4NWRlZmY3MDcyYTI3Njg=
+  data.tar.gz: !binary |-
+    ODk0ZjIxYTI2YTU1MWQ0M2RiYzIyOGE4MGJjNTJkOTI1MmNhYjk4ZDFhODZl
+    YTQ5ZDIwMjAzOTEyY2JjYzBjNTZlMmFhYmEyZjYwYTU3Y2ZiMWUwYjZiYmRh
+    ZDg1YTg4MjBlZTkyNjQyMmRkNTZmZDkwMDBmYjFiNWJmYThiYjE=

data/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014, Tapjoy, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,260 @@
+# Chore: Job processing... for the future!
+
+## About
+
+Chore is a pluggable, multi-backend job processor. It was built from the ground up to be extremely flexible. We hope that you
+will find integrating and using Chore to be as pleasant as we do.
+
+The full docs for Chore can always be found at http://tapjoy.github.io/chore.
+
+## Configuration
+
+Chore can be integrated with any Ruby-based project by following these instructions:
+
+    gem 'chore-core', '~> 1.5'
+
+If you also plan on using SQS, you must also bring in dalli to use for memcached:
+
+    gem 'dalli'
+
+Create a `Chorefile` file in the root of your project directory. While you can configure Chore itself from this file, it's primarly used to direct the Chore binary toward the root of your application, so that it can locate all of the depdendencies and required code.
+
+    --require=./<FILE_TO_LOAD>
+
+Make sure that `--require` points to the main entry point for your app. If integrating with a Rails app, just point it to the directory of your application and it will handle loading the correct files on its own. 
+
+Other options include:
+
+    --concurrency 16 # number of concurrent worker processes, if using forked worker strategy
+    --worker-strategy Chore::Strategy::ForkedWorkerStrategy # which worker strategy class to use
+    --consumer Chore::Queues::SQS::Consumer # which consumer class to use Options are SQS::Consumer and Filesystem::Consumer. Filesystem is recommended for local and testing purposes only.
+    --consumer-strategy Chore::Queues::Strategies::Consumer::ThreadedConsumerStrategy # which consuming strategy to use. Options are SingleConsumerStrategy and ThreadedConsumerStrategy. Threaded is recommended for better tuning your consuming profile
+    --threads-per-queue 4 # number of threads per queue for consuming from a given queue.
+    --dedupe-servers # if using SQS or similiar queue with at-least once delivery and your memcache is running on something other than localhost
+    --batch-size 50 # how many messages are batched together before handing them to a worker
+    --queue_prefix prefixy # A prefix to prepend to queue names, mainly for development and qa testing purposes
+    --max-attempts 100 # The maximum number of times a job can be attempted
+    --dupe-on-cache-failure # Determines the deduping behavior when a cache connection error occurs. When set to `false`, the message is assumed not to be a duplicate. Defaults to `false`.
+    --queue-polling-size 10 # If your particular queueing system supports responding with messages in batches of a certain size, you can control that with this flag. SQS has a built in upper-limit of 10, but other systems will vary. 
+
+If you're using SQS, you'll want to add AWS keys so that Chore can authenticate with AWS.
+
+    --aws-access-key=<AWS KEY>
+    --aws-secret-key=<AWS SECRET>
+
+By default, Chore will run over all queues it detects among the required files. If you wish to change this behavior, you can use:
+
+    --queues QUEUE1,QUEUE2... # a list of queues to process
+    --except-queues QUEUE1,QUEUE2... # a list of queues _not_ to process
+
+Note that you can use one or the other but not both. Chore will quit and make fun of you if both options are specified.
+
+### Tips for configuring Chore
+
+When it comes to configuring Chore, you have 2 main use cases - as a producer of messages, or as a consumer of messages (the consumer is also able to produce messages if need be, but is running as it's own isolated instance of your application).
+
+For producers, you must do all of your Chore configuration in an intializer.
+
+For consumers, you need to either Chorefile or Chorefile + an initializer.
+
+Because you are likely to use the same app as the basis for both producing and consuming messages, you'll already have a considerable amount of configuration in your Producer - it makes sense to use Chorefile to simply provide the `require` option, and stick to the initializer for the rest of the configuration to keep things DRY.
+
+However, like many aspects of Chore, it is ultimately up to the developer to decide which use case fits their needs best. Chore is happy to let you configure it in almost any way you want.
+
+An example of how to configure chore via and initializer:
+
+```ruby
+Chore.configure do |c|
+  c.concurrency = 16
+  c.worker_strategy = Chore::Strategy::ForkedWorkerStrategy
+  c.max_attempts = 100
+  ...
+  c.batch_size = 50
+end
+```
+
+## Integration
+
+Add an appropriate line to your `Procfile`:
+
+    jobs: bundle exec chore -c config/chore.config
+
+If your queues do not exist, you must create them before you run the application:
+
+```ruby
+require 'aws-sdk'
+sqs = AWS::SQS.new
+sqs.queues.create("test_queue")
+```
+
+Finally, start foreman as usual
+
+    bundle exec foreman start
+
+## Chore::Job
+
+A Chore::Job is any class that includes `Chore::Job` and implements `perform(*args)` Here is an example job class:
+
+```ruby
+class TestJob
+  include Chore::Job
+  queue_options :name => 'test_queue'
+
+  def perform(args={})
+    Chore.logger.debug "My first async job"
+  end
+
+end
+```
+
+This job declares that the name of the queue it uses is `test_queue`, set in the queue_options method.
+
+### Chore::Job and perform signatures
+
+The perform method signature can have explicit argument names, but in practice this makes changing the signature more difficult later on. Once a Job is in production and is being used at a constant rate, it becomes problematic to begin mixing versions of jobs which have non-matching signatures.
+
+While this is able to be overcome with a number of techniques, such as versioning your jobs/queues, it increases the complexity of making changes.
+
+The simplest way to structure job signatures is to treat the arguments as a hash. This will allow you to maintain forwards and backwards compatibility between signature changes with the same job class.
+
+However, Chore is ultimately agnostic to your particular needs in this regard, and will let you use explicit arguments in your signatures as easily as you can use a simple hash - the choice is left to you, the developer.
+
+### Chore::Job and publishing Jobs
+
+Now that you've got a test job, if you wanted to publish to that job it's as simple as:
+```ruby
+TestJob.perform_async({"message"=>"YES, DO THAT THING."})
+```
+
+It's advisable to specify the Publisher chore uses to send messages globally, so that you can change it easily for local and test environments. To do this, you can add a configuration block to an initializer like so:
+
+```ruby
+Chore.configure do |c|
+  c.publisher = Some::Other::Publisher
+end
+```
+
+It is worth noting that any option that can be set via config file or command-line args can also be set in a configure block.
+
+If a global publisher is set, it can be overridden on a per-job basis by specifying the publisher in `queue_options`.
+
+
+## Hooks
+
+A number of hooks, both global and per-job, exist in Chore for your convenience.
+
+Global Hooks:
+
+* before_first_fork
+* before_fork
+* after_fork
+* around_fork
+* within_fork
+
+("within_fork" behaves similarly to around_fork, except that it is called after the worker process has been forked. In contrast, around_fork is called by the parent process.)
+
+Filesystem Consumer/Publisher
+
+* on_fetch(job_file, job_json)
+
+SQS Consumer
+
+* on_fetch(handle, body)
+
+Per Job:
+
+* before_publish
+* after_publish
+* before_perform(message)
+* after_perform(message)
+* on_rejected(message)
+* on_failure(message, error)
+* on_permanent_failure(queue_name, message, error)
+
+All per-job hooks can also be global hooks.
+
+Hooks can be added to a job class as so:
+
+```ruby
+class TestJob
+  include Chore::Job
+  queue_options :name => 'test_queue'
+
+  def perform(args={})
+    Chore.logger.debug "My first sync job"
+  end
+end
+```
+Global hooks can also be registered like so:
+
+```ruby
+Chore.add_hook :after_publish do
+  # your special handler here
+end
+```
+
+## Signals
+
+Signal handling can get complicated when you have multiple threads, process
+forks, and both signal handlers and application code making use of mutexes.
+
+To simplify the complexities around this, Chore introduces some additional
+behaviors on top of Ruby's default Signal.trap implementation.  This
+functionality is primarily inspired by sidekiq's signal handling @
+https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/cli.rb.
+
+In particular, Chore handles signals in a separate thread and does so
+sequentially instead of interrupt-driven.  See Chore::Signal for more details
+on the differences between Ruby's `Signal.trap` and Chore's `Chore::Signal.trap`.
+
+Chore will respond to the following Signals:
+
+* INT , TERM, QUIT - Chore will begin shutting down, taking steps to safely terminate workers and not interrupt jobs in progress unless it believes they may be hung
+* USR1 - Re-opens logfiles, useful for handling log rotations
+
+## Timeouts
+
+When using the forked worker strategy for processing jobs, inevitably there are
+cases in which child processes become stuck.  This could result from deadlocks,
+hung network calls, tight loops, etc.  When these jobs hang, they consume
+resources and can affect throughput.
+
+To mitigate this, Chore has built-in monitoring of forked child processes.
+When a fork is created to process a batch of work, that fork is assigned an
+expiration time -- if it doesn't complete by that time, the process is sent
+a KILL signal.
+
+Fork expiration times are determined from one of two places:
+1. The timeout associated with the queue.  For SQS, this is the visibility
+   timeout.
+2. The default queue timeout configured for Chore.  For Filesystem queues,
+   this is the value used.
+
+For example, if a worker is processing a batch of 5 jobs and each job's queue
+has a timeout of 60s, then the expiration time will be 5 minutes for the worker.
+
+To change the default queue timeout (when one can't be inferred), you can do
+the following:
+
+```ruby
+Chore.configure do |c|
+  c.default_queue_timeout = 3600
+end
+```
+
+A reasonable timeout would be based on the maximum amount of time you expect any
+job in your system to run.  Keep in mind that the process running the job may
+get killed if the job is running for too long.
+
+## Plugins
+
+Chore has several plugin gems available, which extend it's core functionality
+
+[New Relic](https://github.com/Tapjoy/chore-new_relic) - Integrating Chore with New Relic
+
+[Airbrake](https://github.com/Tapjoy/chore-airbrake) - Integrating Chore with Airbrake
+
+## Copyright
+
+Copyright (c) 2013 - 2014 Tapjoy. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+#RSpec::Core::RakeTask.new(:rcov) do |spec|
+#  spec.pattern = 'spec/**/*_spec.rb'
+#  spec.rcov = true
+#end
+
+task :default => :spec
+
+require 'yard'
+
+YARD::Rake::YardocTask.new do |yard|
+  require 'chore/version'
+  yard.options = [ '--output=rdoc', "title=#{Chore::Version::STRING}", 'main=README.md']
+end

data/bin/chore

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'chore'
+require 'chore/cli'
+require 'chore/signal'
+
+# This is a pure-ruby patch of something that resolves hostnames when making external calls
+# Without it, we have a chance to fork while the lock is held, which results in dead forks
+# This is not included anywhere else because this is the only Chore-specific code that is not
+# included in other projects by requiring chore, where this patch may be undesirable.
+require 'resolv-replace'
+
+["INT","TERM","QUIT"].each do |sig|
+  Chore::Signal.trap sig do
+    Chore::CLI.instance.shutdown
+  end
+end
+
+Chore::Signal.trap "USR1" do
+  Chore.reopen_logs
+end
+
+begin
+  cli = Chore::CLI.instance
+  cli.run!(ARGV)
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end
+ 
+

data/chore-core.gemspec

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+$: << File.expand_path('lib', File.dirname(__FILE__))
+
+require 'chore/version'
+
+Gem::Specification.new do |s|
+  s.name = "chore-core"
+  s.version = Chore::Version::STRING
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tapjoy"]
+  s.date = Time.new.strftime("%Y-%m-%d")
+  s.description = "Job processing with pluggable backends and strategies"
+  s.email = "eng-group-arch@tapjoy.com"
+
+  s.executables = Dir["bin/*"].map { |f| f.gsub(/bin\//, '') }
+  s.default_executable = "chore"
+
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = Dir[*%w(
+    chore-core.gemspec
+    LICENSE.txt
+    README.md
+    Rakefile
+    bin/*
+    lib/**/*
+    spec/**/*
+  )]
+
+  s.homepage = "http://github.com/Tapjoy/chore"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.25"
+  s.summary = "Job processing... for the future!"
+
+  s.add_runtime_dependency(%q<json>, [">= 0"])
+  s.add_runtime_dependency(%q<aws-sdk>, ["~> 1.12", ">= 1.12.0"])
+  s.add_runtime_dependency(%q<thread>, ["~> 0.1.3"])
+  s.add_development_dependency(%q<rspec>, ["~> 2.12.0"])
+  s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+  s.add_development_dependency(%q<bundler>, [">= 0"])
+end
+

data/lib/chore/cli.rb

@@ -0,0 +1,232 @@
+require 'pp'
+require 'singleton'
+require 'optparse'
+require 'chore'
+require 'erb'
+require 'set'
+
+require 'chore/manager'
+
+module Chore #:nodoc:
+
+  # Class that handles the command line interactions in Chore.
+  # It primarily is responsible for invoking the Chore process with the provided configuration
+  # to begin processing jobs.
+  class CLI
+    include Singleton
+    include Util
+
+    attr_reader :options, :registered_opts
+
+    def initialize
+      @options = {}
+      @registered_opts = {}
+      @stopping = false
+    end
+
+    #
+    # +register_option+ is a method for plugins or other components to register command-line config options.
+    # * <tt>key</tt> is the name for this option that can be referenced from Chore.config.+key+
+    # * <tt>*args</tt> is an <tt>OptionParser</tt> style list of options.
+    # * <tt>&blk</tt> is an option block, passed to <tt>OptionParser</tt>
+    #
+    # === Examples
+    #   Chore::CLI.register_option 'sample', '-s', '--sample-key SOME_VAL', 'A description of this value'
+    #
+    #   Chore::CLI.register_option 'something', '-g', '--something-complex VALUE', 'A description' do |arg|
+    #     # make sure your key here matches the key you register
+    #     options[:something] arg.split(',')
+    #   end
+    def self.register_option(key,*args,&blk)
+      instance.register_option(key,*args,&blk)
+    end
+
+    def register_option(key,*args,&blk) #:nodoc:
+      registered_opts[key] = {:args => args}
+      registered_opts[key].merge!(:block => blk) if blk
+    end
+
+    # Start up the consuming side of the application. This calls Chore::Manager#start.
+    def run!(args=ARGV)
+      parse(args)
+      @manager = Chore::Manager.new
+      @manager.start
+    end
+
+    # Begins the Chore shutdown process. This will call Chore::Manager#shutdown if it is not already in the process of stopping
+    # Exits with code 0
+    def shutdown
+      unless @stopping
+        @stopping = true
+        @manager.shutdown! if @manager
+        exit(0)
+      end
+    end
+
+    def parse_config_file(file) #:nodoc:
+      data = File.read(file)
+      data = ERB.new(data).result
+      parse_opts(data.split(/\s/).map!(&:chomp).map!(&:strip))
+    end
+
+    def parse(args=ARGV) #:nodoc:
+      Chore.configuring = true
+      setup_options
+
+      # parse once to load the config file & require options
+      parse_opts(args)
+      parse_config_file(@options[:config_file]) if @options[:config_file]
+
+      validate!
+      boot_system
+
+      # parse again to pick up options required by loaded classes
+      parse_opts(args)
+      parse_config_file(@options[:config_file]) if @options[:config_file]
+      detect_queues
+      Chore.configure(options)
+      Chore.configuring = false
+    end
+
+
+    private
+    def setup_options #:nodoc:
+      register_option "queues", "-q", "--queues QUEUE1,QUEUE2", "Names of queues to process (default: all known)" do |arg|
+        options[:queues] = arg.split(",")
+      end
+
+      register_option "except_queues", "-x", "--except QUEUE1,QUEUE2", "Process all queues (cannot specify --queues), except for the ones listed here" do |arg|
+        options[:except_queues] = arg.split(",")
+      end
+
+      register_option "verbose", "-v", "--verbose", "Print more verbose output. Use twice to increase." do
+        options[:log_level] ||= Logger::WARN
+        options[:log_level] = options[:log_level] - 1 if options[:log_level] > 0
+      end
+
+      register_option "environment", '-e', '--environment ENV', "Application environment"
+
+      register_option "config_file", '-c', '--config-file FILE', "Location of a file specifying additional chore configuration"
+
+      register_option 'require', '-r', '--require [PATH|DIR]', "Location of Rails application with workers or file to require"
+
+      register_option 'num_workers', '--concurrency NUM', Integer, 'Number of workers to run concurrently'
+
+      register_option 'queue_prefix', '--queue-prefix PREFIX', "Prefix to use on Queue names to prevent non-determinism in testing environments" do |arg|
+        options[:queue_prefix] = arg.downcase << "_"
+      end
+
+      register_option 'max_attempts', '--max-attempts NUM', Integer, 'Number of times to attempt failed jobs'
+
+      register_option 'worker_strategy', '--worker-strategy CLASS_NAME', 'Name of a class to use as the worker strategy (default: ForkedWorkerStrategy' do |arg|
+        options[:worker_strategy] = constantize(arg)
+      end
+
+      register_option 'consumer', '--consumer CLASS_NAME', 'Name of a class to use as the queue consumer (default: SqsConsumer)' do |arg|
+        options[:consumer] = constantize(arg)
+      end
+
+      register_option 'consumer_strategy', '--consumer-strategy CLASS_NAME', 'Name of a class to use as the consumer strategy (default: Chore::Strategy::ThreadedConsumerStrategy' do |arg|
+        options[:consumer_strategy] = constantize(arg)
+      end
+
+      register_option 'shutdown_timeout', '--shutdown-timeout SECONDS', Float, "Upon shutdown, the number of seconds to wait before force killing worker strategies (default: #{Chore::DEFAULT_OPTIONS[:shutdown_timeout]})"
+
+      register_option 'dupe_on_cache_failure', '--dupe-on-cache-failure BOOLEAN', 'Determines the deduping behavior when a cache connection error occurs. When set to false, the message is assumed not to be a duplicate. (default: false)'
+
+    end
+
+    def parse_opts(argv) #:nodoc:
+      @options ||= {}
+      @parser = OptionParser.new do |o|
+        registered_opts.each do |key,opt|
+          if opt[:block]
+            o.on(*opt[:args],&opt[:block])
+          else
+            o.on(*opt[:args]) do |arg|
+              options[key.to_sym] = arg
+            end
+          end
+        end
+      end
+
+      @parser.banner = "chore [options]"
+
+      @parser.on_tail "-h", "--help", "Show help" do
+        puts @parser
+        exit 1
+      end
+
+      @parser.parse!(argv)
+
+      @options
+    end
+
+
+    def detected_environment #:nodoc:
+      options[:environment] ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    def boot_system #:nodoc:
+      ENV['RACK_ENV'] = ENV['RAILS_ENV'] = detected_environment
+
+      raise ArgumentError, "#{options[:require]} does not exist" unless File.exist?(options[:require])
+
+      if File.directory?(options[:require])
+        require 'rails'
+        require 'chore/railtie'
+        require File.expand_path("#{options[:require]}/config/environment.rb")
+        ::Rails.application.eager_load!
+      else
+        require File.expand_path(options[:require])
+      end
+    end
+
+    def detect_queues #:nodoc:
+      if (options[:queues] && options[:except_queues])
+        raise ArgumentError, "Cannot specify both --except and --queues"
+      end
+
+      if !options[:queues]
+        options[:queues] = Set.new
+        Chore::Job.job_classes.each do |j|
+          klazz = constantize(j)
+          options[:queues] << klazz.options[:name] if klazz.options[:name]
+          options[:queues] -= (options[:except_queues] || [])
+        end
+      end
+
+      original_queues = options[:queues].dup
+      # Now apply the prefixing
+      # Because the prefix could have been detected via the apps chore config file
+      # Lets see if that is present before we check for a CLI passed prefix
+      prefix = Chore.config.queue_prefix || options[:queue_prefix]
+      options[:queues] = Set.new.tap do |queue_set|
+        original_queues.each {|oq_name| queue_set << "#{prefix}#{oq_name}"}
+      end
+      raise ArgumentError, "No queues specified. Either include classes that include Chore::Job, or specify the --queues option" if options[:queues].empty?
+    end
+
+    def missing_option!(option) #:nodoc:
+      puts "Missing argument: #{option}"
+      exit(255)
+    end
+
+    def validate! #:nodoc:
+
+      missing_option!("--require [PATH|DIR]") unless options[:require]
+
+      if !File.exist?(options[:require]) ||
+         (File.directory?(options[:require]) && !File.exist?("#{options[:require]}/config/application.rb"))
+        puts "=================================================================="
+        puts "  Please point chore to a Rails 3 application or a Ruby file    "
+        puts "  to load your worker classes with -r [DIR|FILE]."
+        puts "=================================================================="
+        puts @parser
+        exit(1)
+      end
+
+    end
+  end
+end
+

data/lib/chore/configuration.rb

@@ -0,0 +1,13 @@
+module Chore
+  # Wrapper around an OpenStruct to define configuration data
+  # (TODO): Add required opts, and validate that they're set
+  class Configuration < OpenStruct
+    # Helper method to make merging Hashes into OpenStructs easier
+    def merge_hash(hsh={})
+      hsh.keys.each do |k|
+        self.send("#{k.to_sym}=",hsh[k])
+      end
+      self
+    end
+  end
+end