quarter_system 0.1.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 caleon.
+
+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.rdoc

@@ -0,0 +1,36 @@
+= QuarterSystem
+
+Currently the types of quarters are hardcoded but it shouldn't be tough to expand the kinds of quarter systems you wish to define for your specific project. By default the gem sets up the US fiscal calendar's definition of quarters (October-December, January-March, April-June, and July-September).
+
+== Usage
+
+=== Quarter.general()
+
+Calling Quarter.general(n) where n refers to the n'th quarter of this particular year returns the Quarter object (which is a subclass of Range with a begin and end date). The boundary dates are of a subclass QuarterBoundaryDate.
+
+If n exceeds the number of quarters in the current system, it will cycle so that in a system with 4 quarters, Quarter.general(1) is the same as Quarter.general(5) or Quarter.general(4n+1).
+
+
+=== Quarter.specific()
+
+On the other hand, Quarter.specific(n) where n exceeds the number of quarters will increment or decrement the year as required, so Quarter.specific(20) is a call for the value of the Quarter object which is the 20th quarter from the current calendar year.
+
+=== Quarter.current()
+
+Quarter.current simply returns the Quarter object which contains the current date, and Quarter.current_number returns the numeric value of the current quarter in the quarter system (i.e. 1 for 1st quarter of the year).
+
+== Additional information
+
+=== Contributors
+
+We have a short list of valued contributors. Check them all at:
+
+http://github.com/caleon/quarter_system/contributors
+
+=== Maintainers
+
+* caleon (http://github.com/caleon)
+
+== License
+
+MIT License. Copyright 2011 caleon.

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CoreUtilities'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/quarter_system/argumentation/argument_merger.rb

@@ -0,0 +1,120 @@
+class ArgumentMerger
+  instance_methods.each do |method|
+    undef_method(method) if method !~ /^(__|instance_eval|class|object_id|respond_to?|puts|logger|extend|kind_of?)/
+  end
+  
+  attr_accessor :archetype
+  def initialize(archetype, arguments, opts={})
+    @archetype  = archetype
+    @arguments  = arguments.compact
+    @opts       = opts.tap { |o| o[:else] ||= nil }
+    self
+  end
+  
+  ######
+  ## Shit, all Private
+  ######
+  private unless Rails.env.development?
+  def archetype_respond_to_proc
+    proc { |method_sym| @archetype.__send__(:respond_to?, method_sym) }
+  end
+  
+  def archetype_send_proc
+    proc { |method_sym, *args, &b| @archetype.__send__(method_sym, *constrained_args_for(method_sym, args)) }
+  end
+  
+  def archetype_respond_to?(method_sym)
+    archetype_respond_to_proc.call(method_sym)
+  rescue NameError => e
+    throw(:argument_error, raise(ArchetypeMethodsError, "For #{@archetype}, calling #archetype_respond_to? using method_sym=#{method_sym} led to argument_error"))
+  end
+  
+  def archetype_send(method_sym, *args, &b)
+    archetype_send_proc.call(method_sym, *args, &b)
+  rescue NameError => e
+    throw(:argument_error, raise(ArchetypeMethodsError, "For #{@archetype}, calling #archetype_send using method_sym=#{method_sym} and args=#{args} with &b=#{b} led to argument_error"))
+  end
+  
+  #####
+  # @_archetype.method Info grabbing.
+  def archetype_method(method_sym)
+    @archetype.method(method_sym)
+  end
+  
+  def archetype_method_params(method_sym)
+    archetype_method(method_sym).parameters
+  end
+  
+  def archetype_method_params_size(method_sym)
+    archetype_method_params(method_sym).size
+  end
+  
+  def archetype_method_arity(method_sym)
+    archetype_method(method_sym).arity
+  end
+  
+  #####
+  # Minimum number of args
+  def minimum_args_from_params(method_sym)
+    archetype_method_params(method_sym).count { |type, meth| type == :req }
+  end
+  
+  def minimum_args_from_arity(method_sym)
+    archetype_method_arity(method_sym).if?(:negative?).succ.abs # upto succ only happens to negatives.
+  end
+  
+  def minimum_args(method_sym)
+    Array.new(2, "minimum_args_from_").zip(%w(params arity)).map { |strs| self.__send__(strs.join, method_sym) }.max
+  end
+  
+  ####
+  # Maximum number of args
+  def maximums_for_param_types
+    { :req => 1, :opt => 1, :block => 1, :rest => 1.0/0 }
+  end
+  
+  def maximum_args_from_params(method_sym)
+    return 1.0/0 if archetype_method_params(method_sym).detect { |type, meth| type == :rest }
+    archetype_method_params(method_sym).inject(0) { |sum, (type, meth)| sum += maximums_for_param_types[type] }
+  end
+  
+  def maximum_args_from_arity(method_sym)
+    archetype_method_arity(method_sym).abs
+  end
+  
+  def maximum_args(method_sym)
+    Array.new(2, "maximum_args_from_").zip(%w(params arity)).map { |strs| self.__send__(strs.join, method_sym) }.max # from .min...
+  end
+  
+  ####
+  # All those for these
+  def constrained_args_for(method_sym, args)
+    args.take(maximum_args(method_sym).unless?(:finite?) { args.size })
+  end
+  
+  def provided_minimum_arguments?(method_sym, arguments)
+    minimum_args(method_sym) >  maximum_args(method_sym)  and raise ArchetypeError, "Range of argument arity is invalid!"
+    minimum_args(method_sym) <= arguments.size
+  end
+  
+  def method_missing(method_sym, *arguments, &block)
+    return @opts[:else] if check_conditions?
+    arguments = Array.wrap(arguments.last.is_a?(Proc) ? lambda { |*args| @arguments | arguments.pop.call(*args) } : @arguments) + arguments.compact
+    
+    catch(:argument_error) do
+      archetype_respond_to?(method_sym)                   or raise ArchetypeMethodsError,   "Issue with #{method_sym}"
+      provided_minimum_arguments?(method_sym, arguments)  or raise ArchetypeArgumentsError, "Issue with #{method_sym}"
+      archetype_send(method_sym, *arguments, &block)
+    end
+  rescue ArchetypeError => e
+    logger.error "<errorClass>#{e.class}: <method>#{method_sym}: <msg>#{e.message}" if Rails.env.development?
+    super
+  rescue
+    logger.error "Giving up rescuing #{@archetype.name rescue nil}##{method_sym}. Arguments are #{arguments.inspect}" if Rails.env.development?
+    @opts[:else]
+  end
+  
+  def check_conditions?
+    @opts[:nonnil] && arguments.empty? or @opts[:present] && arguments.any?(:present?)
+  end
+end

data/lib/quarter_system/argumentation/arguments.rb

@@ -0,0 +1,39 @@
+class Arguments < Array
+  def self.new(args)
+    arguer = args.last.is_a?(Class) && args.pop
+    super.tap {|args_obj| args_obj.arguer = arguer }
+  end
+  
+  attr_accessor :arguer
+  
+  # kondition needs to be a string to be evaluated when appended to the element. Refer to Arguments#passes_condition?
+  def find_with_reqs(reqs={}) # Arguments itself can be any length. But these three are things allowed to be defined.
+    [ total_match_value(reqs[:class], reqs[:condition]), quey_match_value(reqs[:quey]), default_value_for(reqs[:quey]) ].compact.first
+  end
+
+  protected
+  def default_value_for(quey) # not schrod. arguer can be nil or methodmissing or result in raise.
+    arguer.send(:"default_#{quey}") rescue nil
+  end
+  
+  def total_match_value(*args)
+    detect { |arg| total_match?(arg, *args) }
+  end
+  
+  def quey_match_value(quey=nil) # hm, allowing nil as quey
+    last[quey] if last.is_a?(Hash)
+  end
+  
+  private
+  def matches_class?(arg, klass=nil)
+    arg.is_a?(klass || Object)
+  end
+  
+  def passes_condition?(arg, konditions=nil)
+    instance_eval(%{arg#{konditions}})
+  end
+  
+  def total_match?(arg, *checks) # total_match?(thing, klass, konditions)
+    matches_class?(arg, checks[0]) && passes_condition?(arg, checks[1])
+  end
+end

data/lib/quarter_system/argumentation/constants.rb

@@ -0,0 +1,14 @@
+REGES = { :with_method_name                   => '(?:_with_([a-z0-9]+(?:[a-z0-9]|_(?![_=\b]))*?))?',
+               :method_name                   =>          '([a-z0-9]+(?:[a-z0-9]|_(?![_=\b]))*?)',
+               :method_name_with_setter       =>          '([a-z0-9]+(?:[a-z0-9]|_(?![_=\b]))*?)(=?)',
+               :method_name_without_capture   =>        '(?:[a-z0-9]+(?:[a-z0-9]|_(?![_=\b]))*?)' }
+               
+# REGEX is the Regular Expression that is not anchored.
+REGEX = Hash[*REGES.to_a.map do |arr|
+[ arr[0], 
+  if arr[1].is_a?(Hash)
+    Hash[*arr[1].to_a.map { |key, reges| [ key, Regexp.new(reges, Regexp::IGNORECASE) ] }.flatten]
+  else
+    Regexp.new(arr[1], Regexp::IGNORECASE)
+  end ]
+end.flatten]

data/lib/quarter_system/argumentation/errors.rb

@@ -0,0 +1,33 @@
+#########
+# Error classes.
+class ArgumentMergerLogger < ActiveSupport::BufferedLogger
+  SEVERITIES = Severity.constants.inject([]) { |arr, c| arr[Severity.const_get(c)] = c; arr }
+  
+  def format_message(severity, timestamp, progname, msg)
+    "(#{timestamp.to_s(:db)})[#{SEVERITIES[severity]}]: #{msg.strip}\n"
+  end
+  
+  def add(severity, message=nil, progname=nil, &block)
+    return if @level > severity
+    message = (message || block.try(:call) || progname).to_s
+    message = format_message(severity, Time.zone.now, progname, message)
+    buffer << message
+    auto_flush
+    message
+  end
+end
+
+# ArgumentMerger.send(:include, SetupLoggers)
+# ArgumentMerger.logger = ArgumentMergerLogger.new(File.join(Rails.root, 'log', "argument_merger_#{Rails.env}.log"))
+
+class ArchetypeError < StandardError
+   def initialize(msg=nil, opts={})
+     ArgumentMerger.logger.send(opts[:severity] || :warn, "#{name}: #{msg}")
+   end
+   
+   def name
+     this.class.name
+    end
+end
+class ArchetypeMethodsError < ArchetypeError; end
+class ArchetypeArgumentsError < ArchetypeError; end

data/lib/quarter_system/argumentation/object.rb

@@ -0,0 +1,18 @@
+##########################
+# Custom handling or arguments:
+# Allows things like User.with_arguments(1, 2, 3).find(:order => 'id DESC')
+#    result: => User.find(1, 2, 3, :order => 'id DESC')
+# but also checks to see that arguments are valid.
+#
+# Also, allows us to condense patterns like:  record.perform_action! if record.respond_to?(:perform_action!)
+# by doing the following instead              record.maybe.perform_action!
+class Object
+  def with_arguments(*arguments)
+    arg_merger = ArgumentMerger.new(self, arguments)
+    block_given? ? yield(arg_merger) : arg_merger
+  end
+  [ :with_argument, :maybe_with, :maybe ].each { |meth| alias_method meth, :with_arguments; }
+  
+  def with_nonnil(*arguments);  with_arguments(*arguments.merge_options(:nonnil   => true)); end
+  def with_present(*arguments); with_arguments(*arguments.merge_options(:present  => true)); end
+end

data/lib/quarter_system/argumentation.rb

@@ -0,0 +1,28 @@
+require 'quarter_system/argumentation/constants'
+
+module Argumentation
+  def build_arguments(*args)
+    args = args.first if args.size == 1 and args.first.is_a?(Array)
+    Arguments.new(args + [self])
+  end
+  
+  private
+  def find_from_args(arguments, reqs={})
+    build_arguments(*arguments).find_with_reqs(reqs)
+  end
+  
+  def method_missing(method_symbol, *arguments, &block)    
+    method_symbol.to_s.match(methods_match_regexp).only_if_a?(MatchData) do |md|
+      md[1].split('_and_').push(md[2]).map { |prop_name| :"#{prop_name}_from_args" }.map { |method_sym| send(method_sym, *arguments) if respond_to?(method_sym) }
+    end || super
+  end
+
+  def methods_match_regexp
+    /^((?:#{REGEX[:method_name_without_capture].source}(?:_and_)(?!from_args))+)#{REGEX[:method_name].source}_from_args$/
+  end
+end
+
+require 'quarter_system/argumentation/arguments'
+require 'quarter_system/argumentation/object'
+require 'quarter_system/argumentation/argument_merger'
+require 'quarter_system/argumentation/errors'

data/lib/quarter_system/integer.rb

@@ -0,0 +1,11 @@
+# There is already a Fixnum#ordinalize
+class Integer
+  ORDINALS = %w(first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth)
+  def ordinal(nonnumeric=false)
+    if nonnumeric && (1..ORDINALS.size.succ).include?(self)
+      ORDINALS[pred]
+    elsif nonnumeric
+      to_s + ([ [ nil, 'st','nd','rd' ], [] ][self / 10 == 1 && 1 || 0][self % 10] || 'th')
+    end
+  end
+end

data/lib/quarter_system/quarter.rb

@@ -0,0 +1,120 @@
+class Quarter < Range
+  extend Argumentation
+  
+  DEFAULTS = { :us_fiscal => [ [ 10, 12 ],  # Q1
+                               [  1,  3 ],  # Q2
+                               [  4,  6 ],  # Q3
+                               [  7,  9 ] ] # Q4
+              }
+              
+  
+  class << self
+    def default_type
+      :us_fiscal
+    end
+    
+    def default_year
+      Time.zone_default.today.year rescue Time.new.year
+    end # depends on time zone.
+    
+    def default_number
+      1
+    end
+    
+    # Changing this so that table type can be input as an option. This is so that when changing quarter system, the dev can use
+    # the with_options to change the type easily for all relevant calls.
+    # Ex: Quarter.quarters_table(:uk_fiscal)
+    #     Quarter.quarters_table(:type => :uk_fiscal)
+    def quarters_table(*args)
+      DEFAULTS[type_from_args(args)]
+    end
+    
+    def number_of_quarters(*args);
+      quarters_table(*args).size
+    end
+    
+    # Sequential returns the Quarter for the correct year depending on the magnitude of the `number` argument.
+    def specific(*args)
+      number, year, type  = number_and_year_and_type_from_args(*args)
+      index               = number.pred % number_of_quarters(*args)
+      opts                = args.extract_options! # at this point, args not needed in its original form.
+      
+      months_array            = quarters_table(type)[index]
+      first_months_array      = quarters_table(type)[0]
+      specified_quarter_month =       months_array[0]
+      first_quarter_month     = first_months_array[0]
+      
+      year += opts[:this_year] ?  0 : (number.pred / number_of_quarters) + (first_quarter_month > specified_quarter_month ? 1 : 0)
+      
+      new(Date.new(year, months_array[0], 1), Date.new(year, months_array[1], 1).end_of_month, :number => number)
+    end
+    
+    def all(*args)
+      type, year = type_and_year_from_args(*args)
+      1.upto(number_of_quarters(type)).map { |number| specific(*args.merge_options(:number => number)) }
+    end
+    
+    def general(*args)
+      specific(*args.merge_options(:this_year => true))
+    end
+    
+    def current(*args)
+      all(*args.merge_options(:this_year => true)).detect { |rng| rng.include? ::Time.zone_default.today }
+    end
+    
+    def current_number(*args)
+      current(*args).number
+    end
+    
+    # ARGUMENTS MUST NOT BE SPLATTED INTO THIS. Point is for this method to not be destructive.
+    # Also, whatever `type` is defined within normal list of arguments overrides any written as a hash value.
+    # Thing about this whole file is that `type` is the only argument ever that's a symbol,
+    #                                     `year` is the only argument that's ever a Numeric of length == 4,
+    #                                   `number` is the only argument that's ever a Numeric of length < 4.
+    def type_from_args(*args)
+      find_from_args(args, :quey => :type, :class => Symbol)
+    end
+    
+    def year_from_args(*args)
+      find_from_args(args, :quey => :year, :class => Numeric, :condition => ".to_s.size == 4")
+    end
+    
+    def number_from_args(*args)
+      find_from_args(args, :quey => :number, :class => Numeric, :condition => ".to_s.size < 3")
+    end
+    
+    def method_missing(method_symbol, *arguments, &block)
+      ordinals = Integer::ORDINALS
+      method_symbol.to_s.match(/^(#{ordinals.join('|')})$/).only_if_a?(MatchData) { |md| specific(ordinals.index(md[1]), *arguments) } || super
+    end
+    private :method_missing
+  end
+  
+  attr_accessor :count, :number, :type
+  
+  def initialize(*args)
+    attrs       = args.extract_options!
+    self.type   = attrs.delete(:type)
+    self.count  = attrs.delete(:number)
+    self.number = (self.count.pred % Quarter.number_of_quarters(:type => self.type)).next
+    super
+  end
+  
+  def include?(date_or_time)
+    if date_or_time.is_a?(Time)
+      super(date_or_time.in_time_zone(Time.zone_default).to_date)
+    else
+      super
+    end
+  end
+  
+  # Instance method from a Quarter object, such that quarter.next returns the following Quarter object. Doesn't mean next one in relation to the current.
+  # for that you would need to use Quarter.current.next or Quarter.next on the class itself.
+  %w(next prev).each_with_index do |method_name, i|
+    class_eval(%{
+      def #{method_name}(size=1)
+        Quarter.specific(number.send(:#{%w(+ -)[i]}, size))
+      end
+    })
+  end
+end

data/lib/quarter_system/quarter_boundary_date.rb

@@ -0,0 +1,18 @@
+class QuarterBoundaryDate < Date
+  # args for Date#new are year, month, day, and an optional "day of calendar reform"
+  # just not gonna worry about day of calendar reform at all.
+  def self.new(*args)
+    args.unshift(this_year) if args.size < 2
+    super(*args)
+  end
+end
+
+class QuarterBeginDate < QuarterBoundaryDate
+  
+end
+
+class QuarterEndDate   < QuarterBoundaryDate
+  def self.new(*args)
+    super.end_of_month
+  end
+end

data/lib/quarter_system/version.rb

@@ -0,0 +1,3 @@
+module QuarterSystem
+  VERSION = "0.1.1"
+end

data/lib/quarter_system.rb

@@ -0,0 +1,13 @@
+require 'active_support/core_ext/numeric/time'
+require 'active_support/time_with_zone'
+require 'active_support/values/time_zone'
+
+require 'quarter_system/argumentation'
+
+require 'quarter_system/quarter'
+require 'quarter_system/quarter_boundary_date'
+require 'quarter_system/integer'
+
+module QuarterSystem
+  
+end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,9 @@
+// This is a manifest file that'll be compiled into including all the files listed below.
+// Add new JavaScript/Coffee code in separate files in this directory and they'll automatically
+// be included in the compiled file accessible from http://example.com/assets/application.js
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *= require_self
+ *= require_tree . 
+*/

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application" %>
+  <%= javascript_include_tag "application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/test/dummy/config/application.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require
+require "quarter_system"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # Activate observers that should always be running.
+    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable the asset pipeline
+    config.assets.enabled = true
+
+    # Version of your assets, change this if you want to expire all your assets
+    config.assets.version = '1.0'
+  end
+end
+

data/test/dummy/config/boot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)

data/test/dummy/config/database.yml

@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000

data/test/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!