ruby_storm 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTRkYTYzOGJkNjc1NmI5NjEwNzZjMjU5M2YwYzQwOTZjZDMyOTI1Zg==
+  data.tar.gz: !binary |-
+    MmE5YjkwMzkzYmMzMmZiYWFjNTZkNmRlMmM5NDM0OGY2NjU1ODIwZg==
+SHA512:
+  metadata.gz: !binary |-
+    ODEzZjZjZDJhZmM4MzgxYTQ3Y2E4NDhhZjNlZTUyYmQ2ODY1ODE3Y2IwOTQ0
+    ZWQ0ZWJiNGM4ZjhhZDc4NzBjNjZlNTI3NmMzYzExMmQ5ZDJmMGM2MGNmODk0
+    YjQxNzBlNTI1Y2RiZjVhYTc1N2JhNjAwOWFjMjQ2MWNkMzEwNDY=
+  data.tar.gz: !binary |-
+    OTA3YWZlZDZiZWJmOWM3Yjg4N2RmYTM4NTIwOTVjNzE1MTAxOWI1N2IwOTFl
+    MDc1OTEzNDk1ZjJjODYwYmNhZDQ3ZGYyZTZmN2QzNzA0ZDhjYTFkMThkMzhj
+    NGVkYWNiNjMzN2NlNWQyODkwNGNjNDk4NDM5ZWY4MDcxY2JlNDI=

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p448

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+gem 'pry'
+gem 'jazz_hands'
+gem 'awesome_print'
+gem 'activerecord'
+gem 'sqlite3'
+gem 'thread_safe'

data/Gemfile.lock

@@ -0,0 +1,117 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (4.1.7)
+      actionview (= 4.1.7)
+      activesupport (= 4.1.7)
+      rack (~> 1.5.2)
+      rack-test (~> 0.6.2)
+    actionview (4.1.7)
+      activesupport (= 4.1.7)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+    activemodel (4.1.7)
+      activesupport (= 4.1.7)
+      builder (~> 3.1)
+    activerecord (4.1.7)
+      activemodel (= 4.1.7)
+      activesupport (= 4.1.7)
+      arel (~> 5.0.0)
+    activesupport (4.1.7)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    arel (5.0.1.20140414130214)
+    awesome_print (1.2.0)
+    binding_of_caller (0.7.2)
+      debug_inspector (>= 0.0.1)
+    builder (3.2.2)
+    coderay (1.1.0)
+    columnize (0.8.9)
+    coolline (0.5.0)
+      unicode_utils (~> 1.4)
+    debug_inspector (0.0.2)
+    debugger (1.6.8)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.3.5)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.3.5)
+    diff-lcs (1.2.5)
+    diffy (3.0.7)
+    erubis (2.7.0)
+    grit (2.5.0)
+      diff-lcs (~> 1.1)
+      mime-types (~> 1.15)
+      posix-spawn (~> 0.3.6)
+    hirb (0.7.2)
+    i18n (0.6.11)
+    jazz_hands (0.5.2)
+      awesome_print (~> 1.2)
+      coolline (>= 0.4.2)
+      hirb (~> 0.7.1)
+      pry (~> 0.9.12)
+      pry-debugger (~> 0.2.2)
+      pry-doc (~> 0.4.6)
+      pry-git (~> 0.2.3)
+      pry-rails (~> 0.3.2)
+      pry-remote (>= 0.1.7)
+      pry-stack_explorer (~> 0.4.9)
+      railties (>= 3.0, < 5.0)
+    json (1.8.1)
+    method_source (0.8.2)
+    mime-types (1.25.1)
+    minitest (5.4.2)
+    posix-spawn (0.3.9)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-debugger (0.2.3)
+      debugger (~> 1.3)
+      pry (>= 0.9.10, < 0.11.0)
+    pry-doc (0.4.6)
+      pry (>= 0.9)
+      yard (>= 0.8)
+    pry-git (0.2.3)
+      diffy
+      grit
+      pry (>= 0.9.8)
+    pry-rails (0.3.2)
+      pry (>= 0.9.10)
+    pry-remote (0.1.8)
+      pry (~> 0.9)
+      slop (~> 3.0)
+    pry-stack_explorer (0.4.9.1)
+      binding_of_caller (>= 0.7)
+      pry (>= 0.9.11)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    railties (4.1.7)
+      actionpack (= 4.1.7)
+      activesupport (= 4.1.7)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.3.2)
+    slop (3.6.0)
+    sqlite3 (1.3.10)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unicode_utils (1.4.0)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  awesome_print
+  jazz_hands
+  pry
+  sqlite3
+  thread_safe

data/application/application.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require 'fileutils'
+
+module Storm
+  STORM_DIR = "#{File.dirname(__FILE__)}/../"
+  STORM_ENV = ENV['DATABASE_ENV'] || 'development'
+  VERSION = ENV['VERSION'] || nil
+  DATABASE_DIR = ENV['DATABASE_DIR'] || './db'
+  MIGRATIONS_DIR = "#{DATABASE_DIR}/migrate"
+  APP_DIR = File.expand_path("./")
+  APP_NAME = ENV['APP_NAME'] || Inflector::classify(File.basename(FileUtils.pwd))
+end

data/application/inflector.rb

@@ -0,0 +1,609 @@
+##
+# This Inflector code is an extract from Rails :: ActiveSupport
+# https://github.com/rails/rails/tree/master/activesupport
+#
+##
+module Inflector
+
+  def self.inflections(locale = :en)
+    if block_given?
+      yield Inflections.instance(locale)
+    else
+      Inflections.instance(locale)
+    end
+  end
+  # Returns the plural form of the word in the string.
+  #
+  # If passed an optional +locale+ parameter, the word will be
+  # pluralized using rules defined for that language. By default,
+  # this parameter is set to <tt>:en</tt>.
+  #
+  #   'post'.pluralize             # => "posts"
+  #   'octopus'.pluralize          # => "octopi"
+  #   'sheep'.pluralize            # => "sheep"
+  #   'words'.pluralize            # => "words"
+  #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+  #   'ley'.pluralize(:es)         # => "leyes"
+  def self.pluralize(word, locale = :en)
+    apply_inflections(word, inflections(locale).plurals)
+  end
+
+  # The reverse of +pluralize+, returns the singular form of a word in a
+  # string.
+  #
+  # If passed an optional +locale+ parameter, the word will be
+  # singularized using rules defined for that language. By default,
+  # this parameter is set to <tt>:en</tt>.
+  #
+  #   'posts'.singularize            # => "post"
+  #   'octopi'.singularize           # => "octopus"
+  #   'sheep'.singularize            # => "sheep"
+  #   'word'.singularize             # => "word"
+  #   'CamelOctopi'.singularize      # => "CamelOctopus"
+  #   'leyes'.singularize(:es)       # => "ley"
+  def self.singularize(word, locale = :en)
+    apply_inflections(word, inflections(locale).singulars)
+  end
+
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument
+  # to +camelize+ is set to <tt>:lower</tt> then +camelize+ produces
+  # lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting
+  # paths to namespaces.
+  #
+  #   'active_model'.camelize                # => "ActiveModel"
+  #   'active_model'.camelize(:lower)        # => "activeModel"
+  #   'active_model/errors'.camelize         # => "ActiveModel::Errors"
+  #   'active_model/errors'.camelize(:lower) # => "activeModel::Errors"
+  #
+  # As a rule of thumb you can think of +camelize+ as the inverse of
+  # +underscore+, though there are cases where that does not hold:
+  #
+  #   'SSLError'.underscore.camelize # => "SslError"
+  def self.camelize(term, uppercase_first_letter = true)
+    string = term.to_s
+    if uppercase_first_letter
+      string = string.sub(/^[a-z\d]*/) { inflections.acronyms[$&] || $&.capitalize }
+    else
+      string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { $&.downcase }
+    end
+    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
+    string.gsub!(/\//, '::')
+    string
+  end
+
+  # Makes an underscored, lowercase form from the expression in the string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  #   'ActiveModel'.underscore         # => "active_model"
+  #   'ActiveModel::Errors'.underscore # => "active_model/errors"
+  #
+  # As a rule of thumb you can think of +underscore+ as the inverse of
+  # +camelize+, though there are cases where that does not hold:
+  #
+  #   'SSLError'.underscore.camelize # => "SslError"
+  def self.underscore(camel_cased_word)
+    return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+    word = camel_cased_word.to_s.gsub(/::/, '/')
+    word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'}#{$2.downcase}" }
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
+  # Tweaks an attribute name for display to end users.
+  #
+  # Specifically, +humanize+ performs these transformations:
+  #
+  #   * Applies human inflection rules to the argument.
+  #   * Deletes leading underscores, if any.
+  #   * Removes a "_id" suffix if present.
+  #   * Replaces underscores with spaces, if any.
+  #   * Downcases all words except acronyms.
+  #   * Capitalizes the first word.
+  #
+  # The capitalization of the first word can be turned off by setting the
+  # +:capitalize+ option to false (default is true).
+  #
+  #   humanize('employee_salary')              # => "Employee salary"
+  #   humanize('author_id')                    # => "Author"
+  #   humanize('author_id', capitalize: false) # => "author"
+  #   humanize('_id')                          # => "Id"
+  #
+  # If "SSL" was defined to be an acronym:
+  #
+  #   humanize('ssl_error') # => "SSL error"
+  #
+  def self.humanize(lower_case_and_underscored_word, options = {})
+    result = lower_case_and_underscored_word.to_s.dup
+
+    inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+
+    result.sub!(/\A_+/, '')
+    result.sub!(/_id\z/, '')
+    result.tr!('_', ' ')
+
+    result.gsub!(/([a-z\d]*)/i) do |match|
+      "#{inflections.acronyms[match] || match.downcase}"
+    end
+
+    if options.fetch(:capitalize, true)
+      result.sub!(/\A\w/) { |match| match.upcase }
+    end
+
+    result
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to
+  # create a nicer looking title. +titleize+ is meant for creating pretty
+  # output. It is not used in the Rails internals.
+  #
+  # +titleize+ is also aliased as +titlecase+.
+  #
+  #   'man from the boondocks'.titleize   # => "Man From The Boondocks"
+  #   'x-men: the last stand'.titleize    # => "X Men: The Last Stand"
+  #   'TheManWithoutAPast'.titleize       # => "The Man Without A Past"
+  #   'raiders_of_the_lost_ark'.titleize  # => "Raiders Of The Lost Ark"
+  def self.titleize(word)
+    humanize(underscore(word)).gsub(/\b(?<!['`])[a-z]/) { $&.capitalize }
+  end
+
+  # Create the name of a table like Rails does for models to table names. This
+  # method uses the +pluralize+ method on the last word in the string.
+  #
+  #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
+  #   'egg_and_ham'.tableize     # => "egg_and_hams"
+  #   'fancyCategory'.tableize   # => "fancy_categories"
+  def self.tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+
+  # Create a class name from a plural table name like Rails does for table
+  # names to models. Note that this returns a string and not a Class (To
+  # convert to an actual class follow +classify+ with +constantize+).
+  #
+  #   'egg_and_hams'.classify # => "EggAndHam"
+  #   'posts'.classify        # => "Post"
+  #
+  # Singular names are not handled correctly:
+  #
+  #   'calculus'.classify     # => "Calculu"
+  def self.classify(table_name)
+    # strip out any leading schema name
+    camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  #   'puni_puni'.dasherize # => "puni-puni"
+  def self.dasherize(underscored_word)
+    underscored_word.tr('_', '-')
+  end
+
+  # Removes the module part from the expression in the string.
+  #
+  #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+  #   'Inflections'.demodulize                                       # => "Inflections"
+  #   '::Inflections'.demodulize                                     # => "Inflections"
+  #   ''.demodulize                                                  # => ""
+  #
+  # See also +deconstantize+.
+  def self.demodulize(path)
+    path = path.to_s
+    if i = path.rindex('::')
+      path[(i+2)..-1]
+    else
+      path
+    end
+  end
+
+  # Removes the rightmost segment from the constant expression in the string.
+  #
+  #   'Net::HTTP'.deconstantize   # => "Net"
+  #   '::Net::HTTP'.deconstantize # => "::Net"
+  #   'String'.deconstantize      # => ""
+  #   '::String'.deconstantize    # => ""
+  #   ''.deconstantize            # => ""
+  #
+  # See also +demodulize+.
+  def self.deconstantize(path)
+    path.to_s[0, path.rindex('::') || 0] # implementation based on the one in facets' Module#spacename
+  end
+
+  # Creates a foreign key name from a class name.
+  # +separate_class_name_and_id_with_underscore+ sets whether
+  # the method should put '_' between the name and 'id'.
+  #
+  #   'Message'.foreign_key        # => "message_id"
+  #   'Message'.foreign_key(false) # => "messageid"
+  #   'Admin::Post'.foreign_key    # => "post_id"
+  def self.foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+
+  # Tries to find a constant with the name specified in the argument string.
+  #
+  #   'Module'.constantize     # => Module
+  #   'Test::Unit'.constantize # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter
+  # whether it starts with "::" or not. No lexical context is taken into
+  # account:
+  #
+  #   C = 'outside'
+  #   module M
+  #     C = 'inside'
+  #     C               # => 'inside'
+  #     'C'.constantize # => 'outside', same as ::C
+  #   end
+  #
+  # NameError is raised when the name is not in CamelCase or the constant is
+  # unknown.
+  def self.constantize(camel_cased_word)
+    names = camel_cased_word.split('::')
+
+    # Trigger a built-in NameError exception including the ill-formed constant in the message.
+    Object.const_get(camel_cased_word) if names.empty?
+
+    # Remove the first blank element in case of '::ClassName' notation.
+    names.shift if names.size > 1 && names.first.empty?
+
+    names.inject(Object) do |constant, name|
+      if constant == Object
+        constant.const_get(name)
+      else
+        candidate = constant.const_get(name)
+        next candidate if constant.const_defined?(name, false)
+        next candidate unless Object.const_defined?(name)
+
+        # Go down the ancestors to check if it is owned directly. The check
+        # stops when we reach Object or the end of ancestors tree.
+        constant = constant.ancestors.inject do |const, ancestor|
+          break const    if ancestor == Object
+          break ancestor if ancestor.const_defined?(name, false)
+          const
+        end
+
+        # owner is in Object, so raise
+        constant.const_get(name, false)
+      end
+    end
+  end
+
+  # Tries to find a constant with the name specified in the argument string.
+  #
+  #   'Module'.safe_constantize     # => Module
+  #   'Test::Unit'.safe_constantize # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter
+  # whether it starts with "::" or not. No lexical context is taken into
+  # account:
+  #
+  #   C = 'outside'
+  #   module M
+  #     C = 'inside'
+  #     C                    # => 'inside'
+  #     'C'.safe_constantize # => 'outside', same as ::C
+  #   end
+  #
+  # +nil+ is returned when the name is not in CamelCase or the constant (or
+  # part of it) is unknown.
+  #
+  #   'blargle'.safe_constantize  # => nil
+  #   'UnknownModule'.safe_constantize  # => nil
+  #   'UnknownModule::Foo::Bar'.safe_constantize  # => nil
+  def self.safe_constantize(camel_cased_word)
+    constantize(camel_cased_word)
+  rescue NameError => e
+    raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+      e.name.to_s == camel_cased_word.to_s)
+  rescue ArgumentError => e
+    raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
+  end
+
+  # Returns the suffix that should be added to a number to denote the position
+  # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  #   ordinal(1)     # => "st"
+  #   ordinal(2)     # => "nd"
+  #   ordinal(1002)  # => "nd"
+  #   ordinal(1003)  # => "rd"
+  #   ordinal(-11)   # => "th"
+  #   ordinal(-1021) # => "st"
+  def self.ordinal(number)
+    abs_number = number.to_i.abs
+
+    if (11..13).include?(abs_number % 100)
+      "th"
+    else
+      case abs_number % 10
+        when 1; "st"
+        when 2; "nd"
+        when 3; "rd"
+        else    "th"
+      end
+    end
+  end
+
+  # Turns a number into an ordinal string used to denote the position in an
+  # ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  #   ordinalize(1)     # => "1st"
+  #   ordinalize(2)     # => "2nd"
+  #   ordinalize(1002)  # => "1002nd"
+  #   ordinalize(1003)  # => "1003rd"
+  #   ordinalize(-11)   # => "-11th"
+  #   ordinalize(-1021) # => "-1021st"
+  def self.ordinalize(number)
+    "#{number}#{ordinal(number)}"
+  end
+
+  private
+
+  # Mounts a regular expression, returned as a string to ease interpolation,
+  # that will match part by part the given constant.
+  #
+  #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
+  #   const_regexp("::")            # => "::"
+  def self.const_regexp(camel_cased_word) #:nodoc:
+    parts = camel_cased_word.split("::")
+
+    return Regexp.escape(camel_cased_word) if parts.blank?
+
+    last  = parts.pop
+
+    parts.reverse.inject(last) do |acc, part|
+      part.empty? ? acc : "#{part}(::#{acc})?"
+    end
+  end
+
+  # Applies inflection rules for +singularize+ and +pluralize+.
+  #
+  #  apply_inflections('post', inflections.plurals)    # => "posts"
+  #  apply_inflections('posts', inflections.singulars) # => "post"
+  def self.apply_inflections(word, rules)
+    result = word.to_s.dup
+
+    if word.empty? || inflections.uncountables.include?(result.downcase[/\b\w+\Z/])
+      result
+    else
+      rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+      result
+    end
+  end
+end
+
+class Inflections
+  @__instance__ = ThreadSafe::Cache.new
+
+  def self.instance(locale = :en)
+    @__instance__[locale] ||= new
+  end
+
+  attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
+
+  def initialize
+    @plurals, @singulars, @uncountables, @humans, @acronyms, @acronym_regex = [], [], [], [], {}, /(?=a)b/
+  end
+
+  # Private, for the test suite.
+  def initialize_dup(orig) # :nodoc:
+    %w(plurals singulars uncountables humans acronyms acronym_regex).each do |scope|
+      instance_variable_set("@#{scope}", orig.send(scope).dup)
+    end
+  end
+
+  # Specifies a new acronym. An acronym must be specified as it will appear
+  # in a camelized string. An underscore string that contains the acronym
+  # will retain the acronym when passed to +camelize+, +humanize+, or
+  # +titleize+. A camelized string that contains the acronym will maintain
+  # the acronym when titleized or humanized, and will convert the acronym
+  # into a non-delimited single lowercase word when passed to +underscore+.
+  #
+  #   acronym 'HTML'
+  #   titleize 'html'     # => 'HTML'
+  #   camelize 'html'     # => 'HTML'
+  #   underscore 'MyHTML' # => 'my_html'
+  #
+  # The acronym, however, must occur as a delimited unit and not be part of
+  # another word for conversions to recognize it:
+  #
+  #   acronym 'HTTP'
+  #   camelize 'my_http_delimited' # => 'MyHTTPDelimited'
+  #   camelize 'https'             # => 'Https', not 'HTTPs'
+  #   underscore 'HTTPS'           # => 'http_s', not 'https'
+  #
+  #   acronym 'HTTPS'
+  #   camelize 'https'   # => 'HTTPS'
+  #   underscore 'HTTPS' # => 'https'
+  #
+  # Note: Acronyms that are passed to +pluralize+ will no longer be
+  # recognized, since the acronym will not occur as a delimited unit in the
+  # pluralized result. To work around this, you must specify the pluralized
+  # form as an acronym as well:
+  #
+  #    acronym 'API'
+  #    camelize(pluralize('api')) # => 'Apis'
+  #
+  #    acronym 'APIs'
+  #    camelize(pluralize('api')) # => 'APIs'
+  #
+  # +acronym+ may be used to specify any word that contains an acronym or
+  # otherwise needs to maintain a non-standard capitalization. The only
+  # restriction is that the word must begin with a capital letter.
+  #
+  #   acronym 'RESTful'
+  #   underscore 'RESTful'           # => 'restful'
+  #   underscore 'RESTfulController' # => 'restful_controller'
+  #   titleize 'RESTfulController'   # => 'RESTful Controller'
+  #   camelize 'restful'             # => 'RESTful'
+  #   camelize 'restful_controller'  # => 'RESTfulController'
+  #
+  #   acronym 'McDonald'
+  #   underscore 'McDonald' # => 'mcdonald'
+  #   camelize 'mcdonald'   # => 'McDonald'
+  def acronym(word)
+    @acronyms[word.downcase] = word
+    @acronym_regex = /#{@acronyms.values.join("|")}/
+  end
+
+  # Specifies a new pluralization rule and its replacement. The rule can
+  # either be a string or a regular expression. The replacement should
+  # always be a string that may include references to the matched data from
+  # the rule.
+  def plural(rule, replacement)
+    @uncountables.delete(rule) if rule.is_a?(String)
+    @uncountables.delete(replacement)
+    @plurals.unshift([rule, replacement])
+  end
+
+  # Specifies a new singularization rule and its replacement. The rule can
+  # either be a string or a regular expression. The replacement should
+  # always be a string that may include references to the matched data from
+  # the rule.
+  def singular(rule, replacement)
+    @uncountables.delete(rule) if rule.is_a?(String)
+    @uncountables.delete(replacement)
+    @singulars.unshift([rule, replacement])
+  end
+
+  # Specifies a new irregular that applies to both pluralization and
+  # singularization at the same time. This can only be used for strings, not
+  # regular expressions. You simply pass the irregular in singular and
+  # plural form.
+  #
+  #   irregular 'octopus', 'octopi'
+  #   irregular 'person', 'people'
+  def irregular(singular, plural)
+    @uncountables.delete(singular)
+    @uncountables.delete(plural)
+
+    s0 = singular[0]
+    srest = singular[1..-1]
+
+    p0 = plural[0]
+    prest = plural[1..-1]
+
+    if s0.upcase == p0.upcase
+      plural(/(#{s0})#{srest}$/i, '\1' + prest)
+      plural(/(#{p0})#{prest}$/i, '\1' + prest)
+
+      singular(/(#{s0})#{srest}$/i, '\1' + srest)
+      singular(/(#{p0})#{prest}$/i, '\1' + srest)
+    else
+      plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
+      plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
+      plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
+      plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
+
+      singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
+      singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
+      singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
+      singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+    end
+  end
+
+  # Specifies words that are uncountable and should not be inflected.
+  #
+  #   uncountable 'money'
+  #   uncountable 'money', 'information'
+  #   uncountable %w( money information rice )
+  def uncountable(*words)
+    @uncountables += words.flatten.map(&:downcase)
+  end
+
+  # Specifies a humanized form of a string by a regular expression rule or
+  # by a string mapping. When using a regular expression based replacement,
+  # the normal humanize formatting is called after the replacement. When a
+  # string is used, the human form should be specified as desired (example:
+  # 'The name', not 'the_name').
+  #
+  #   human /_cnt$/i, '\1_count'
+  #   human 'legacy_col_person_name', 'Name'
+  def human(rule, replacement)
+    @humans.prepend([rule, replacement])
+  end
+
+  # Clears the loaded inflections within a given scope (default is
+  # <tt>:all</tt>). Give the scope as a symbol of the inflection type, the
+  # options are: <tt>:plurals</tt>, <tt>:singulars</tt>, <tt>:uncountables</tt>,
+  # <tt>:humans</tt>.
+  #
+  #   clear :all
+  #   clear :plurals
+  def clear(scope = :all)
+    case scope
+      when :all
+        @plurals, @singulars, @uncountables, @humans = [], [], [], []
+      else
+        instance_variable_set "@#{scope}", []
+    end
+  end
+end
+
+
+
+Inflector.inflections(:en) do |inflect|
+  inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/^(ax|test)is$/i, '\1es')
+  inflect.plural(/(octop|vir)us$/i, '\1i')
+  inflect.plural(/(octop|vir)i$/i, '\1i')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+  inflect.plural(/([ti])um$/i, '\1a')
+  inflect.plural(/([ti])a$/i, '\1a')
+  inflect.plural(/sis$/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  inflect.plural(/(hive)$/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+  inflect.plural(/^(m|l)ouse$/i, '\1ice')
+  inflect.plural(/^(m|l)ice$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/^(oxen)$/i, '\1')
+  inflect.plural(/(quiz)$/i, '\1zes')
+
+  inflect.singular(/s$/i, '')
+  inflect.singular(/(ss)$/i, '\1')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([ti])a$/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+  inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/([lr])ves$/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.singular(/(s)eries$/i, '\1eries')
+  inflect.singular(/(m)ovies$/i, '\1ovie')
+  inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+  inflect.singular(/^(m|l)ice$/i, '\1ouse')
+  inflect.singular(/(bus)(es)?$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(cris|test)(is|es)$/i, '\1is')
+  inflect.singular(/^(a)x[ie]s$/i, '\1xis')
+  inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
+  inflect.singular(/(alias|status)(es)?$/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  inflect.singular(/(matr)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+  inflect.singular(/(database)s$/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+  inflect.irregular('zombie', 'zombies')
+
+  inflect.uncountable(%w(equipment information rice money species series fish sheep jeans police))
+end

data/application/jazz_hands.rb

@@ -0,0 +1,58 @@
+##
+#  Jazz Hands for console and debugging
+##
+require 'jazz_hands'
+require 'awesome_print'
+
+JazzHands.colored_prompt = true
+JazzHands.enable_syntax_highlighting_as_you_type!
+
+Pry.config.print = ->(output, value) do
+  return if JazzHands._hirb_output && Hirb::View.view_or_page_output(value)
+  pretty = value.ai(indent: 2)
+  Pry::Helpers::BaseHelpers.stagger_output("=> #{pretty}", output)
+end
+
+# Friendlier prompt - line number, app name, nesting levels look like
+# directory paths.
+#
+# Heavy use of lazy lambdas so configuration (like Pry.color) can be
+# changed later or even during console usage.
+#
+# Custom color helpers using hints \001 and \002 so that good readline
+# libraries (GNU, rb-readline) correctly ignore color codes when
+# calculating line length.
+
+name = Storm::APP_NAME
+
+color = -> { Pry.color && JazzHands.colored_prompt }
+red  = ->(text) { color[] ? "\001\e[0;31m\002#{text}\001\e[0m\002" : text.to_s }
+blue = ->(text) { color[] ? "\001\e[0;34m\002#{text}\001\e[0m\002" : text.to_s }
+bold = ->(text) { color[] ? "\001\e[1m\002#{text}\001\e[0m\002"    : text.to_s }
+
+separator = -> { red.(JazzHands.prompt_separator) }
+colored_name = -> { blue.(name) }
+
+line = ->(pry) { "[#{bold.(pry.input_array.size)}] " }
+target_string = ->(object, level) do
+  level = 0 if level < 0
+  unless (string = Pry.view_clip(object)) == 'main'
+    "(#{'../' * level}#{string})"
+  else
+    ''
+  end
+end
+
+Pry.config.prompt = [
+  ->(object, level, pry) do      # Main prompt
+    "#{line.(pry)}#{colored_name.()}#{target_string.(object, level)} #{separator.()}  "
+  end,
+  ->(object, level, pry) do      # Wait prompt in multiline input
+    spaces = ' ' * (
+      "[#{pry.input_array.size}] ".size +  # Uncolored `line.(pry)`
+      name.size +
+      target_string.(object, level).size
+    )
+    "#{spaces} #{separator.()}  "
+  end
+]

data/bin/storm

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'thread_safe'
+
+module Storm
+  require File.expand_path("./../../application/inflector", __FILE__)
+  require File.expand_path("./../../application/application", __FILE__)
+
+  def self.perform!(namespace, args=ARGV)
+    begin
+      names = namespace.to_s.split(':')
+      generator(names)
+      if klass = generator(names)
+        puts "#{klass} #{args.length > 1 ? args[1..-1] : ''}"
+        Dir["./*/*.rb"].each{|file| require file } if klass.name != "Storm::Init"
+        klass.start(args[1..-1])
+      else
+        puts "Could not find generator '#{names}'. "
+      end
+    rescue Exception => e
+      puts e.message
+      return 1
+    end
+    return 0
+  end
+
+  def self.generator(names)
+    generators_and_paths = names.map{|name|
+      [name.capitalize,name.downcase]
+    }
+    klass = "::Storm::"+generators_and_paths.map(&:first).join("::")
+    path = File.expand_path("./../../generators/#{generators_and_paths.map(&:last).join("/")}.rb", __FILE__)
+
+    if File.exists?(path)
+      require path
+      return eval(klass)
+    end
+  end
+end
+
+exit Storm::perform!(ARGV[0])

data/bin/storm_console

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+Dir["./*/*.rb"].each{|file| require file }
+
+Bundler.require(:default)
+require 'thread_safe'
+require 'pry'
+require 'active_record'
+
+require File.expand_path("./../../application/inflector", __FILE__)
+require File.expand_path("./../../application/application", __FILE__)
+require File.expand_path("./../../application/jazz_hands", __FILE__)
+
+ActiveRecord::Base.establish_connection YAML.load_file('./db/databases.yml')[Storm::STORM_ENV] rescue nil
+
+load Gem.bin_path('pry', 'pry', ">= 0.9")
+
+
+

data/bin/stormc

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+Kernel::exec "bundle exec #{File.expand_path("./../storm_console", __FILE__)}"
+
+

data/generators/db/create.rb

@@ -0,0 +1,42 @@
+require "#{Storm::STORM_DIR}/generators/db/db_command"
+
+module Storm::Db
+  class Create  < Storm::DBCommand
+    def self.start(args)
+      options = {:charset => 'utf8', :collation => 'utf8_unicode_ci'}
+
+      create_db = lambda do |config|
+        # drops and create need to be performed with a connection to the 'postgres' (system) database
+        if config["adapter"] == 'postgres'
+          ::ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+        end
+        # drop the old database (if it exists)
+        ::ActiveRecord::Base.connection.drop_database config["database"] rescue nil
+        # create new
+        ::ActiveRecord::Base.connection.create_database(config["database"]) rescue nil
+        ::ActiveRecord::Base.establish_connection(config)
+      end
+
+      begin
+        create_db.call self.config
+      rescue Exception => sqlerr
+        if sqlerr.errno == 1405
+          print "#{sqlerr.error}. \nPlease provide the root password for your mysql installation\n>"
+          root_password = $stdin.gets.strip
+
+          grant_statement = <<-SQL
+            GRANT ALL PRIVILEGES ON #{config['database']}.*
+              TO '#{config['username']}'@'localhost'
+              IDENTIFIED BY '#{config['password']}' WITH GRANT OPTION;
+          SQL
+
+          create_db.call config.merge('database' => nil, 'username' => 'root', 'password' => root_password)
+        else
+          $stderr.puts sqlerr.error
+          $stderr.puts "Couldn't create database for #{config.inspect}, charset: utf8, collation: utf8_unicode_ci"
+          $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config['charset']
+        end
+      end
+    end
+  end
+end

data/generators/db/db_command.rb

@@ -0,0 +1,13 @@
+class Storm::DBCommand
+  require 'active_record'
+  require 'yaml'
+  def self.config
+    @config ||= ::YAML.load_file('./db/databases.yml')[Storm::STORM_ENV]
+  end
+
+  def self.connect
+    self.config
+    ::ActiveRecord::Base.establish_connection self.config
+    ::ActiveRecord::Base.logger = Logger.new STDOUT if @config['logger']
+  end
+end

data/generators/db/drop.rb

@@ -0,0 +1,13 @@
+require "#{Storm::STORM_DIR}/generators/db/db_command"
+
+module Storm::Db
+  class Drop < Storm::DBCommand
+    def self.start(args)
+      ::ActiveRecord::Base.connection.drop_database self.connect['database'] rescue
+      if self.config['adapter'] == 'sqlite3'
+        db_file = File.expand_path("./"+self.config['database'])
+        File.delete(db_file)
+      end
+    end
+  end
+end

data/generators/db/generate.rb

@@ -0,0 +1,36 @@
+require 'fileutils'
+require "#{Storm::STORM_DIR}/generators/db/migration_generator"
+
+module Storm::Db
+  class Generate < Storm::MigrationGenerator
+    def self.start(args)
+      filename = next_migration_file_name(args)
+      model_name, *columns = args
+      model_source = Inflector::singularize(Inflector::tableize(model_name))
+      create_table = \
+      ["class Generate#{::Inflector::pluralize(::Inflector::classify(model_name))} < ActiveRecord::Migration",
+      "  def change",
+      "    create_table :#{::Inflector::tableize(model_name)} do |t|",
+            columns.map do |col|
+              col_name, col_type = col.split(":")
+              col_type ||= "string"
+              "      t.#{col_type} :#{::Inflector::singularize(::Inflector::tableize(col_name))}"
+            end,
+       "      t.timestamps",
+       "     end",
+       "  end",
+       "end"].flatten
+
+      FileUtils.mkdir_p("./models/")
+      File.open("./models/#{model_source}.rb", "w+") do |f|
+        f.puts "\
+class #{::Inflector::classify(model_name)} < ActiveRecord::Base
+end
+"
+      end
+      File.open("./db/migrate/#{filename}", "w+") do |f|
+        f.puts create_table.join("\n")
+      end
+    end
+  end
+end

data/generators/db/migrate.rb

@@ -0,0 +1,11 @@
+require "#{Storm::STORM_DIR}/generators/db/db_command"
+
+module Storm::Db
+  class Migrate < Storm::DBCommand
+    def self.start *_
+      self.connect
+      ::ActiveRecord::Migration.verbose = true
+      ::ActiveRecord::Migrator.migrate File.expand_path(Storm::MIGRATIONS_DIR), Storm::VERSION && Storm::VERSION.to_i
+    end
+  end
+end

data/generators/db/migration_generator.rb

@@ -0,0 +1,10 @@
+module Storm::Db
+  class Storm::MigrationGenerator
+    def self.next_migration_file_name(args)
+      ::Inflector::tableize("#{Time.now.strftime("%Y%m%d%H%M%S")}_#{self.name.split("::").last}_#{args[0]}")+".rb"
+    end
+
+    def self.last_migration_timestamp
+    end
+  end
+end

data/generators/db/modify.rb

@@ -0,0 +1,20 @@
+require "#{Storm::STORM_DIR}/generators/db/migration_generator"
+
+module Storm::Db
+  class Modify < Storm::MigrationGenerator
+    def self.start(args)
+      filename = next_migration_file_name(args)
+      model_name, *_ = args
+
+      create_table = \
+      ["class Modify#{::Inflector::classify(model_name)} < ActiveRecord::Migration",
+      "  def change",
+       "  end",
+       "end"].flatten
+
+      File.open("./db/migrate/#{filename}", "w+") do |f|
+        f.puts create_table.join("\n")
+      end
+    end
+  end
+end

data/generators/db/rollback.rb

@@ -0,0 +1,11 @@
+require "#{Storm::STORM_DIR}/generators/db/db_command"
+
+module Storm::Db
+  class Rollback < Storm::DBCommand
+    def self.start (*args)
+      self.connect
+      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+      ::ActiveRecord::Migrator.rollback ::Storm::MIGRATIONS_DIR, step
+    end
+  end
+end

data/generators/db/version.rb

@@ -0,0 +1,10 @@
+require "#{Storm::STORM_DIR}/generators/db/db_command"
+
+module Storm::Db
+  class Version < Storm::DBCommand
+    def self.start(*args)
+      self.connect
+      puts "Current version: #{::ActiveRecord::Migrator.current_version}"
+    end
+  end
+end

data/generators/init.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+
+module Storm
+  class Init
+    def self.start(args)
+      app_name = args[0]
+      class_name = Inflector::classify(app_name)
+      file_name = "#{Inflector::underscore(app_name)}.rb"
+      dir_name = "#{Inflector::underscore(app_name)}"
+      FileUtils.mkdir_p(dir_name)
+      FileUtils.mkdir_p("./#{dir_name}/#{MIGRATIONS_DIR}") rescue nil
+      gemfile(dir_name)
+      appfile(dir_name, file_name, class_name)
+      dbfile(dir_name)
+    end
+
+    #
+    # Write project Gemfile
+    #
+    def self.gemfile(dir_name)
+  File.open("./#{dir_name}/Gemfile", "w+") do |f|
+    f.puts "\
+source 'https://rubygems.org'
+gem 'ruby_storm'
+"
+      end
+    end
+
+    #
+    # Write app entry point
+    #
+    def self.appfile(dir_name, file_name, class_name)
+      File.open("./#{dir_name}/#{file_name}", "w+") do |f|
+        f.puts "\
+class #{class_name}
+  def self.main(env)
+  end
+end
+  "
+      end
+    end
+
+    #
+    # Write databases.yml
+    #
+    def self.dbfile(dir_name)
+      File.open("./#{dir_name}/db/databases.yml", "w+") do |f|
+        f.puts "\
+default: &default
+  adapter: sqlite3
+  pool: 5
+  timeout: 5000
+
+development:
+  <<: *default
+  database: db/development.sqlite3
+  "
+      end
+    end
+  end
+end
+

data/generators/version.rb

@@ -0,0 +1,8 @@
+module Storm
+  class Version
+    def self.to_s(*args)
+      "0.0.2"
+    end
+    alias_method :start, :to_s
+  end
+end

data/ruby_storm.gemspec

@@ -0,0 +1,26 @@
+require './generators/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ruby_storm'
+  s.version     = Storm::Version.to_s
+  s.date        = '2014-11-02'
+  s.summary     = "Ruby storm is a stand alone Object Relational Mapper"
+  s.description = "Ruby storm is a stand alone Object Relational Mapper that wraps ActiveRecord."
+  s.authors     = ["Wouter Coppieters"]
+  s.email       = 'wouter.coppieters@youdo.co.nz'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = ['stormc', 'storm']
+
+  s.add_runtime_dependency 'pry', '~> 0.9'
+  s.add_runtime_dependency 'jazz_hands', '~> 0.5'
+  s.add_runtime_dependency 'awesome_print', '~> 1.0'
+  s.add_runtime_dependency 'activerecord', '~> 4.1'
+  s.add_runtime_dependency 'sqlite3', '~> 1.3'
+  s.add_runtime_dependency 'thread_safe', '~> 0.3'
+  s.add_runtime_dependency 'bundler', '~> 1.5'
+
+  s.homepage    = 'http://rubygems.org/gems/ruby_storm'
+  s.license     = 'MIT'
+end

data/rubystorm.todo

@@ -0,0 +1,11 @@
+ ☐ Require packages for app and daemon. 'storm/app', 'storm/daemon'. Main class inherits from Storm::App or Storm::Daemon
+ ☐ generate either daemon or app. (Both have gemfile and bin-dir)
+ ☐ Allow ENV VARS for migration dir, model dir
+ ☐ Create deploy procedure
+ ☐ Release!
+
+＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
+Archive:
+ ✔ generate and include gemfile in project dir @done (14-11-06 15:22)
+ ✔ Different Bundle.requires for storm and stormc. @done (14-11-06 15:22)
+ ✔ ALlow splitting of dependencies into groups. @done (14-11-06 15:22)

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: ruby_storm
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Wouter Coppieters
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: jazz_hands
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Ruby storm is a stand alone Object Relational Mapper that wraps ActiveRecord.
+email: wouter.coppieters@youdo.co.nz
+executables:
+- stormc
+- storm
+extensions: []
+extra_rdoc_files: []
+files:
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- application/application.rb
+- application/inflector.rb
+- application/jazz_hands.rb
+- bin/storm
+- bin/storm_console
+- bin/stormc
+- generators/db/create.rb
+- generators/db/db_command.rb
+- generators/db/drop.rb
+- generators/db/generate.rb
+- generators/db/migrate.rb
+- generators/db/migration_generator.rb
+- generators/db/modify.rb
+- generators/db/rollback.rb
+- generators/db/version.rb
+- generators/init.rb
+- generators/version.rb
+- ruby_storm.gemspec
+- rubystorm.todo
+homepage: http://rubygems.org/gems/ruby_storm
+licenses:
+- MIT
+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.3.0
+signing_key: 
+specification_version: 4
+summary: Ruby storm is a stand alone Object Relational Mapper
+test_files: []
+has_rdoc: