swiss_db 0.4.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd2a370a37a19234396bc2c7723ba6cdb58c1c5f
-  data.tar.gz: 7727c32732c7ea4732314f63a03576e2fd67dfdb
+  metadata.gz: e116c10e8cc3bd87e03a39c0070503942d9705e5
+  data.tar.gz: 772ccee76d341e64f1d86cdaa6270ef3edef91a2
 SHA512:
-  metadata.gz: e4a9449d966ef4f2da5517fec85af7fdcc5a565ca4ea974f94eef41cced3ff1ae6794722288a45437d9727a85fa5a176cf621b560f4c72f140032db152c00f35
-  data.tar.gz: a9331cca35341d96a6597f2e11997880488c260630702172d5007c8ffaa23a16cdb91a663e08d2d01e9f2c6ead7b876502d037442e2a499ee5d8dc52d7531126
+  metadata.gz: 9ec1a9330cc0b83769f4e07e710679ee1ab06f8ef2b1598d79806877b7a6b8213a8a24d7861d8885e85271ecf0f53ddc49c93f48cd38ba26dc4c6077b439b1b7
+  data.tar.gz: c222afa056499b831c5547c57a8777d1d4de71f60e74a243ebb91a02900edaeb958588519b5e1c51e93c6b5c5e826c98703b7ca99782d20b4a67e847aa49eb8c

data/README.md

@@ -20,12 +20,10 @@ Or install it yourself as:
 
 ## Usage
 
-Schemas are the exact same from CoreDataQuery and go in the same place.
+Schemas are the exact same from CoreDataQuery and go in the same place. (schemas/)
 
-Don't forget to add your schema folder in your Rakefile.
+Schema name does nothing.
 
-```ruby
-  app.files += Dir.glob("schemas/*.rb")
 ```
 
 Models are as such:
@@ -33,8 +31,8 @@ Models are as such:
 ```ruby
 class Model < SwissModel
 
-  set_table_name "model"
-  set_primary_key "primary_key_name"
+  set_class_name "Model" # there are currently no hacks to automatically get this. sorry.
+  set_primary_key "primary_key_name" # if not set, will default to "id"
 
 end
 ```
@@ -54,6 +52,12 @@ end
 
 That's it! #all, #last, #first, #count, #save, #update_attributes and the usual are now available!
 
+KNOWN LIMITATION: This ORM compiles in the database name and the database version as a constant. Unfortunately I don't know of a way around this yet. This means no DB migrations yet by doing the simple version bump that is supported by Android. If we get a way to configure these from outside the gem, it will open up possibilities such as multiple schemas and migrations. To get around this simply delete your local database when you need to migrate. You can delete the app from the simulator/device (probably) or use my convenience command:
+
+```ruby
+   DataStore.new($app_context).drop_db #=> true if the DB was dropped, false if not
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/lib/motion-support/array.rb

@@ -0,0 +1,7 @@
+class Array
+  # The human way of thinking about adding stuff to the end of a list is with append
+  alias_method :append,  :<<
+
+  # The human way of thinking about adding stuff to the beginning of a list is with prepend
+  alias_method :prepend, :unshift
+end

data/lib/motion-support/inflections.rb

@@ -0,0 +1,227 @@
+module MotionSupport
+  module Inflector
+    class << self
+
+      # A singleton instance of this class is yielded by Inflector.inflections,
+      # which can then be used to specify additional inflection rules.
+      #
+      #   MotionSupport::Inflector.inflections do |inflect|
+      #     inflect.plural /^(ox)$/i, '\1\2en'
+      #     inflect.singular /^(ox)en/i, '\1'
+      #
+      #     inflect.irregular 'octopus', 'octopi'
+      #
+      #     inflect.uncountable 'equipment'
+      #   end
+      #
+      # New rules are added at the top. So in the example above, the irregular
+      # rule for octopus will now be the first of the pluralization and
+      # singularization rules that is runs. This guarantees that your rules run
+      # before any of the rules that may already have been loaded.
+      class Inflections
+        def self.instance
+          @__instance__ ||= 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
+
+        def plurals
+          @plurals
+        end
+
+        def singulars
+          @singulars
+        end
+
+        def uncountables
+          @uncountables
+        end
+
+        def humans
+          @humans
+        end
+
+        def acronyms
+          @acronyms
+        end
+
+        def acronym_regex
+          @acronym_regex
+        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.prepend([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.prepend([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
+
+        # Add uncountable words that shouldn't be attempted inflected.
+        #
+        #   uncountable 'money'
+        #   uncountable 'money', 'information'
+        #   uncountable %w( money information rice )
+        def uncountable(*words)
+          (@uncountables << words).flatten!
+        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
+
+      # Yields a singleton instance of Inflector::Inflections so you can specify
+      # additional inflector rules.
+      #
+      #   MotionSupport::Inflector.inflections do |inflect|
+      #     inflect.uncountable 'rails'
+      #   end
+      def inflections
+        if block_given?
+          yield Inflections.instance
+        else
+          Inflections.instance
+        end
+      end
+
+    end
+  end
+end

data/lib/motion-support/inflector.rb

@@ -0,0 +1,322 @@
+module MotionSupport
+  # The Inflector transforms words from singular to plural, class names to table
+  # names, modularized class names to ones without, and class names to foreign
+  # keys. The default inflections for pluralization, singularization, and
+  # uncountable words are kept in inflections.rb.
+  module Inflector
+    class << self
+
+      # Returns the plural form of the word in the string.
+      #
+      #   'post'.pluralize             # => "posts"
+      #   'octopus'.pluralize          # => "octopi"
+      #   'sheep'.pluralize            # => "sheep"
+      #   'words'.pluralize            # => "words"
+      #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+      def pluralize(word)
+        apply_inflections(word, inflections.plurals)
+      end
+
+      # The reverse of +pluralize+, returns the singular form of a word in a
+      # string.
+      #
+      #   'posts'.singularize            # => "post"
+      #   'octopi'.singularize           # => "octopus"
+      #   'sheep'.singularize            # => "sheep"
+      #   'word'.singularize             # => "word"
+      #   'CamelOctopi'.singularize      # => "CamelOctopus"
+      def singularize(word)
+        apply_inflections(word, inflections.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 camelize(term, uppercase_first_letter = true)
+        string = term.to_s
+        if uppercase_first_letter
+          string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
+        else
+          string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+        end
+        string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }.gsub('/', '::')
+      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 underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!('::', '/')
+        word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.gsub!("-", "_")
+        word.downcase!
+        word
+      end
+
+      # Capitalizes the first word and turns underscores into spaces and strips a
+      # trailing "_id", if any. Like +titleize+, this is meant for creating pretty
+      # output.
+      #
+      #   'employee_salary'.humanize # => "Employee salary"
+      #   'author_id'.humanize       # => "Author"
+      def humanize(lower_case_and_underscored_word)
+        result = lower_case_and_underscored_word.to_s.dup
+        inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+        result.gsub!(/_id$/, "")
+        result.gsub!('_', ' ')
+        result.gsub(/([a-z\d]*)/i) { |match|
+          "#{inflections.acronyms[match] || match.downcase}"
+        }.gsub(/^\w/) { |match| match.upcase }
+      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 titleize(word)
+        humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { |match| match.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 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:
+      #
+      #   'business'.classify     # => "Busines"
+      def 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 dasherize(underscored_word)
+        underscored_word.gsub('_', '-')
+      end
+
+      # Removes the module part from the expression in the string.
+      #
+      #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+      #   'Inflections'.demodulize                                       # => "Inflections"
+      #
+      # See also +deconstantize+.
+      def 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 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 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 constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || 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 it it's owned
+            # directly before we reach Object or the end of ancestors.
+            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 safe_constantize(camel_cased_word)
+        constantize(camel_cased_word)
+      rescue NameError => e
+        raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
+          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 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 ordinalize(number)
+        "#{number}#{ordinal(number)}"
+      end
+
+      private
+
+      # Mount a regular expression that will match part by part of the constant.
+      # For instance, Foo::Bar::Baz will generate Foo(::Bar(::Baz)?)?
+      def const_regexp(camel_cased_word) #:nodoc:
+        parts = camel_cased_word.split("::")
+        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 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
+  end
+end

data/lib/motion-support/methods.rb

@@ -0,0 +1,322 @@
+module MotionSupport
+  # The Inflector transforms words from singular to plural, class names to table
+  # names, modularized class names to ones without, and class names to foreign
+  # keys. The default inflections for pluralization, singularization, and
+  # uncountable words are kept in inflections.rb.
+  module Inflector
+    class << self
+
+      # Returns the plural form of the word in the string.
+      #
+      #   'post'.pluralize             # => "posts"
+      #   'octopus'.pluralize          # => "octopi"
+      #   'sheep'.pluralize            # => "sheep"
+      #   'words'.pluralize            # => "words"
+      #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+      def pluralize(word)
+        apply_inflections(word, inflections.plurals)
+      end
+
+      # The reverse of +pluralize+, returns the singular form of a word in a
+      # string.
+      #
+      #   'posts'.singularize            # => "post"
+      #   'octopi'.singularize           # => "octopus"
+      #   'sheep'.singularize            # => "sheep"
+      #   'word'.singularize             # => "word"
+      #   'CamelOctopi'.singularize      # => "CamelOctopus"
+      def singularize(word)
+        apply_inflections(word, inflections.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 camelize(term, uppercase_first_letter = true)
+        string = term.to_s
+        if uppercase_first_letter
+          string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
+        else
+          string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+        end
+        string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }.gsub('/', '::')
+      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 underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!('::', '/')
+        word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.gsub!("-", "_")
+        word.downcase!
+        word
+      end
+
+      # Capitalizes the first word and turns underscores into spaces and strips a
+      # trailing "_id", if any. Like +titleize+, this is meant for creating pretty
+      # output.
+      #
+      #   'employee_salary'.humanize # => "Employee salary"
+      #   'author_id'.humanize       # => "Author"
+      def humanize(lower_case_and_underscored_word)
+        result = lower_case_and_underscored_word.to_s.dup
+        inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+        result.gsub!(/_id$/, "")
+        result.gsub!('_', ' ')
+        result.gsub(/([a-z\d]*)/i) { |match|
+          "#{inflections.acronyms[match] || match.downcase}"
+        }.gsub(/^\w/) { |match| match.upcase }
+      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 titleize(word)
+        humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { |match| match.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 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:
+      #
+      #   'business'.classify     # => "Busines"
+      def 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 dasherize(underscored_word)
+        underscored_word.gsub('_', '-')
+      end
+
+      # Removes the module part from the expression in the string.
+      #
+      #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+      #   'Inflections'.demodulize                                       # => "Inflections"
+      #
+      # See also +deconstantize+.
+      def 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 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 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 constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || 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 it it's owned
+            # directly before we reach Object or the end of ancestors.
+            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 safe_constantize(camel_cased_word)
+        constantize(camel_cased_word)
+      rescue NameError => e
+        raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
+          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 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 ordinalize(number)
+        "#{number}#{ordinal(number)}"
+      end
+
+      private
+
+      # Mount a regular expression that will match part by part of the constant.
+      # For instance, Foo::Bar::Baz will generate Foo(::Bar(::Baz)?)?
+      def const_regexp(camel_cased_word) #:nodoc:
+        parts = camel_cased_word.split("::")
+        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 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
+  end
+end

data/lib/motion-support/string.rb

@@ -0,0 +1,178 @@
+# String inflections define new methods on the String class to transform names for different purposes.
+# For instance, you can figure out the name of a table from the name of a class.
+#
+#   'ScaleScore'.tableize # => "scale_scores"
+#
+class String
+  # Returns the plural form of the word in the string.
+  #
+  # If the optional parameter +count+ is specified,
+  # the singular form will be returned if <tt>count == 1</tt>.
+  # For any other value of +count+ the plural will be returned.
+  #
+  #   'post'.pluralize             # => "posts"
+  #   'octopus'.pluralize          # => "octopi"
+  #   'sheep'.pluralize            # => "sheep"
+  #   'words'.pluralize            # => "words"
+  #   'the blue mailman'.pluralize # => "the blue mailmen"
+  #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+  #   'apple'.pluralize(1)         # => "apple"
+  #   'apple'.pluralize(2)         # => "apples"
+  def pluralize(count = nil)
+    if count == 1
+      self
+    else
+      MotionSupport::Inflector.pluralize(self)
+    end
+  end
+
+  # The reverse of +pluralize+, returns the singular form of a word in a string.
+  #
+  #   'posts'.singularize            # => "post"
+  #   'octopi'.singularize           # => "octopus"
+  #   'sheep'.singularize            # => "sheep"
+  #   'word'.singularize             # => "word"
+  #   'the blue mailmen'.singularize # => "the blue mailman"
+  #   'CamelOctopi'.singularize      # => "CamelOctopus"
+  def singularize
+    MotionSupport::Inflector.singularize(self)
+  end
+
+  # +constantize+ tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.  See MotionSupport::Inflector.constantize
+  #
+  #   'Module'.constantize  # => Module
+  #   'Class'.constantize   # => Class
+  #   'blargle'.constantize # => NameError: wrong constant name blargle
+  def constantize
+    MotionSupport::Inflector.constantize(self)
+  end
+
+  # +safe_constantize+ tries to find a declared constant with the name specified
+  # in the string. It returns nil when the name is not in CamelCase
+  # or is not initialized.  See MotionSupport::Inflector.safe_constantize
+  #
+  #   'Module'.safe_constantize  # => Module
+  #   'Class'.safe_constantize   # => Class
+  #   'blargle'.safe_constantize # => nil
+  def safe_constantize
+    MotionSupport::Inflector.safe_constantize(self)
+  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_record'.camelize                # => "ActiveRecord"
+  #   'active_record'.camelize(:lower)        # => "activeRecord"
+  #   'active_record/errors'.camelize         # => "ActiveRecord::Errors"
+  #   'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
+  def camelize(first_letter = :upper)
+    case first_letter
+    when :upper
+      MotionSupport::Inflector.camelize(self, true)
+    when :lower
+      MotionSupport::Inflector.camelize(self, false)
+    end
+  end
+  alias_method :camelcase, :camelize
+
+  # 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"
+  def titleize
+    MotionSupport::Inflector.titleize(self)
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+  #
+  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+  #
+  #   'ActiveModel'.underscore         # => "active_model"
+  #   'ActiveModel::Errors'.underscore # => "active_model/errors"
+  def underscore
+    MotionSupport::Inflector.underscore(self)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  #   'puni_puni'.dasherize # => "puni-puni"
+  def dasherize
+    MotionSupport::Inflector.dasherize(self)
+  end
+
+  # Removes the module part from the constant expression in the string.
+  #
+  #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
+  #   'Inflections'.demodulize                                       # => "Inflections"
+  #
+  # See also +deconstantize+.
+  def demodulize
+    MotionSupport::Inflector.demodulize(self)
+  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 deconstantize
+    MotionSupport::Inflector.deconstantize(self)
+  end
+
+  # Creates 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 tableize
+    MotionSupport::Inflector.tableize(self)
+  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.
+  #
+  #   'business'.classify # => "Busines"
+  def classify
+    MotionSupport::Inflector.classify(self)
+  end
+
+  # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
+  # Like +titleize+, this is meant for creating pretty output.
+  #
+  #   'employee_salary'.humanize # => "Employee salary"
+  #   'author_id'.humanize       # => "Author"
+  def humanize
+    MotionSupport::Inflector.humanize(self)
+  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 foreign_key(separate_class_name_and_id_with_underscore = true)
+    MotionSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+  end
+end

data/lib/swiss_db/swiss_model.rb

@@ -16,6 +16,10 @@ class SwissModel
     @store
   end
 
+  def self.set_class_name(class_name) # hack, class.name not functioning in RM Android...
+    set_table_name(class_name.tableize)
+  end
+
   def self.set_table_name(table_name)
     @table_name = table_name
   end
@@ -29,7 +33,7 @@ class SwissModel
   end
 
   def self.primary_key
-    @primary_key
+    @primary_key.nil? ? "id" : @primary_key
   end
 
   def self.all
@@ -60,7 +64,7 @@ class SwissModel
     # create a row
     result = store.insert(@table_name, obj)
       if result == -1
-        puts "An error occured inserting values into #{@@table_name}"
+        puts "An error occured inserting values into #{@table_name}"
       else
         return result
       end
@@ -75,6 +79,18 @@ class SwissModel
     store.destroy_all(@table_name)
   end
 
-  # something for method missing that gets class and then returns it from the cursor
+  # borrowed from rails
+  private
+
+  def 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.gsub!("-", "_")
+    word.downcase!
+    word
+  end
 
 end

data/lib/swiss_db.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # SwissDB by jsilverMDX
+
 if defined?(Motion) && defined?(Motion::Project::Config)
-  # puts "MOTION PROJECT CONFIG IS DEFINED"
   lib_dir_path = File.dirname(File.expand_path(__FILE__))
   Motion::Project::App.setup do |app|
     # unless platform_name == "android"
@@ -13,10 +13,14 @@ if defined?(Motion) && defined?(Motion::Project::Config)
     # the end of the list
     insert_point = app.files.find_index { |file| file =~ /^(?:\.\/)?app\// } || 0
 
+    # change to "swiss_db" for just swiss_db
     Dir.glob(File.join(lib_dir_path, "**/*.rb")).reverse.each do |file|
       app.files.insert(insert_point, file)
     end
 
+    # load their schemas folder
+    app.files += Dir.glob("schemas/*.rb")
+
     # puts "APP FILES: #{app.files.inspect}"
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swiss_db
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Jonathan Silverman
@@ -46,6 +46,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/motion-support/array.rb
+- lib/motion-support/inflections.rb
+- lib/motion-support/inflector.rb
+- lib/motion-support/methods.rb
+- lib/motion-support/string.rb
 - lib/swiss_db.rb
 - lib/swiss_db/cursor.rb
 - lib/swiss_db/data_store.java