action_query 0.1.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 169707c8efdb0a8cd829ee5cd1e7c1f681259228
-  data.tar.gz: a1176eae268e54fdefd2077c97e1122d3576f6e7
+  metadata.gz: 96917fcf22ad5aa27ddcbf7f87e6883b3c6bd23b
+  data.tar.gz: fe95850d9a5896d34f3b9bc87be8f226d1a83067
 SHA512:
-  metadata.gz: 44e385ce0fe32db644ceab187f8e16e0dc671a34f4afd084e8ebb36c2859437c3d83fcaa14a63283ab2bcdef24246de401d60f15da9175c3cf86ca03e360fb17
-  data.tar.gz: dc16eff32feea054ae6fb419e7fb9ad4284c7733c2571b1df1bdfaef963ddb1c313a9758d3e179be3da3e6c8cacaff1b1e9f53616d5887cb57ba1f93dddf60af
+  metadata.gz: 6f13ad6bb35ea05f661e16ea6349c221b65db8e94a82e416e1950b76fc709daeab929b369de1119e6c517b3f968b3ad351f13e3be69f4103b36f8e71851221ae
+  data.tar.gz: b95f69ee1117ee95fdf546cc53c1a282d50d13fec2bd466bd97df77f395913b995482957fa50c635ac533f9d657fe89b8396574049473067ac41506d2462185e

data/.ruby-gemset

@@ -0,0 +1 @@
+action_query

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.4.0

data/lib/action_query/route.rb

@@ -0,0 +1,49 @@
+module ActionQuery
+  module Route
+    def self.result
+      controllers = HashWithIndifferentAccess.new
+      ::Rails.application.routes.routes.each do |route|
+        next unless route.defaults[:controller]
+        names = route.defaults[:controller].split('/')
+        obj = controllers
+        names.each_with_index do |name,index|
+          obj[name.classify()] ||= HashWithIndifferentAccess.new
+          obj = obj[name.classify()]
+        end
+        obj[route.defaults[:action]] ||= []
+        path = {
+          parts: route.parts.map(&:to_s),
+          path: route.path.spec.to_s,
+          verb: route.verb,
+          requirements: route.required_parts.map(&:to_s),
+          method: route.defaults[:action]
+        }
+        obj[route.defaults[:action]] << path
+      end
+      controllers
+    end
+
+    def self.to_coffee
+      result.map{|k,v| self.write_class("#{k}",v)}.flatten.join
+    end
+
+
+    def self.write_class(key,val)
+      classes = []
+      res  = "class ActionQuery.#{key} extends ActionQuery.$Base\n"
+      res += "  @methods("
+      arr = []
+      val.each do |k,v|
+        if v.is_a? Array
+          arr << "#{k}: [{#{v.map{|path| path.map{|l,m| "#{l}: #{m.inspect}"}.join(',')}.join('},{')}}]"
+        else
+          classes << write_class("#{key}.#{k}",v)
+        end
+      end
+      res += arr.join(',')
+      res += "  )\n"
+      [res] | classes
+    end
+
+  end
+end

data/lib/action_query/version.rb

@@ -1,3 +1,3 @@
 module ActionQuery
-  VERSION = "0.1.0"
+  VERSION = "0.5.0"
 end

data/lib/action_query.rb

@@ -1,5 +1,9 @@
 require "action_query/version"
+require "action_query/route"
 
 module ActionQuery
-  # Your code goes here...
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
 end

data/lib/assets/javascripts/action_query/base.coffee

@@ -0,0 +1,13 @@
+# //= require_tree ./extensions
+# //= require action_query/class_methods
+# //= require action_query/private_methods
+@ActionQuery ?= {}
+class ActionQuery.$Base extends Module
+  @extend(ActionQuery.$ClassMethods)
+  @include(ActionQuery.$PrivateMethods)
+  $save: ->
+    # Only trigger save after last action completed (can't create until new is done)
+    # (can't update until create or update is done)
+    @$promise.then @__save__.bind(@)
+  $destroy: ->
+    @$promise.then @__destroy__.bind(@)

data/lib/assets/javascripts/action_query/class_methods.coffee

@@ -0,0 +1,36 @@
+@ActionQuery ?= {}
+class @ActionQuery.$ClassMethods
+  methods: (args) ->
+    @_createMethod(name,details) for name,details of args
+  _createMethod: (name,details) ->
+    @::__routes__ ||= []
+    @::__routes__.merge(details)
+    @[name] = (params) ->
+      params = {id: params} if !isNaN(params)
+      params ||= {}
+      params.format ||= 'json'
+      paths = []
+      for route in details
+        continue unless route.requirements.subtract(Object.keys(params)).length == 0
+        path = route.path
+        for key,val of params
+          path = path.replace(":#{key}",val)
+        path = path.replace /\(.*\)/, (match) ->
+          return '' if match.indexOf(':') >= 0
+          return match[1..-2]
+        paths.push(weight: route.requirements.length, path: path, verb: route.verb)
+      weight = paths.pluck('weight').max()
+      path = (paths.filter (path) -> path.weight == weight).first()
+      @_sendRequest(path,params)
+
+  _sendRequest: (details,params) ->
+    data = {}
+    data[@name.underscore()] = params
+    newRec = new @
+    newRec.$promise = $.ajax(
+      url: details.path
+      method: details.verb
+      data: data
+    )
+    .then newRec.__processResponse__.bind(newRec)
+    return newRec

data/lib/assets/javascripts/action_query/classes.coffee.erb

@@ -0,0 +1,2 @@
+# //= require action_query/base
+<%= ActionQuery::Route.to_coffee %>

data/lib/assets/javascripts/action_query/extensions/array.coffee

@@ -0,0 +1,46 @@
+unless Array::includes
+  Array::includes = (el) -> @indexOf(el) >= 0
+unless Array::filter
+  Array::filter = (fn) ->
+    arr = []
+    (arr.push(el) if fn(el)) for el in @
+unless Array::intersection
+  Array::intersection = (arr) ->
+    @filter((el) -> arr.includes(el))
+unless Array::intersects
+  Array::intersects = (arr) ->
+    @intersection(arr).length > 0
+unless Array::subtract
+  Array::subtract = (arr) ->
+    @filter((el) -> !arr.includes(el))
+unless Array::pluck
+  Array::pluck = (keys...) ->
+    keys = keys.flatten()
+    arr = []
+    for el in @
+      arr.push(keys.map (key) -> el[key])
+    return if keys.length == 1 then arr.flatten() else arr
+unless Array::flatten
+  Array::flatten = ->
+    arr = []
+    for l in @
+      if Array.isArray(l)
+        for i in l.flatten()
+          arr.push i
+      else
+        arr.push l
+    arr
+unless Array::min
+  Array::min        = -> return Math.min.apply(null,@)
+  Array::max        = -> return Math.max.apply(null,@)
+unless Array::first
+  Array::first      = -> @[0]
+  Array::last       = -> @[@length - 1]
+unless Array::dup
+  Array::dup        = -> return @slice(0)
+  Array::empty      = -> @length == 0
+  Array::present    = -> @length != 0
+unless Array::merge
+  Array::merge = (arr) ->
+    @push(el) for el in arr
+    @

data/lib/assets/javascripts/action_query/extensions/inflection.js

@@ -0,0 +1,637 @@
+/*
+Copyright (c) 2007-2015 Ryan Schuft (ryan.schuft@gmail.com)
+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.
+*/
+
+/*
+  This code is based in part on the work done in Ruby to support
+  infection as part of Ruby on Rails in the ActiveSupport's Inflector
+  and Inflections classes.  It was initally ported to Javascript by
+  Ryan Schuft (ryan.schuft@gmail.com) in 2007.
+  The code is available at http://code.google.com/p/inflection-js/
+  The basic usage is:
+    1. Include this script on your web page.
+    2. Call functions on any String object in Javascript
+  Currently implemented functions:
+    String.pluralize(plural) == String
+      renders a singular English language noun into its plural form
+      normal results can be overridden by passing in an alternative
+    String.singularize(singular) == String
+      renders a plural English language noun into its singular form
+      normal results can be overridden by passing in an alterative
+    String.camelize(lowFirstLetter) == String
+      renders a lower case underscored word into camel case
+      the first letter of the result will be upper case unless you pass true
+      also translates "/" into "::" (underscore does the opposite)
+    String.underscore() == String
+      renders a camel cased word into words seperated by underscores
+      also translates "::" back into "/" (camelize does the opposite)
+    String.humanize(lowFirstLetter) == String
+      renders a lower case and underscored word into human readable form
+      defaults to making the first letter capitalized unless you pass true
+    String.capitalize() == String
+      renders all characters to lower case and then makes the first upper
+    String.dasherize() == String
+      renders all underbars and spaces as dashes
+    String.titleize() == String
+      renders words into title casing (as for book titles)
+    String.demodulize() == String
+      renders class names that are prepended by modules into just the class
+    String.tableize() == String
+      renders camel cased singular words into their underscored plural form
+    String.classify() == String
+      renders an underscored plural word into its camel cased singular form
+    String.foreign_key(dropIdUbar) == String
+      renders a class name (camel cased singular noun) into a foreign key
+      defaults to seperating the class from the id with an underbar unless
+      you pass true
+    String.ordinalize() == String
+      renders all numbers found in the string into their sequence like "22nd"
+*/
+
+/*
+  This sets up a container for some constants in its own namespace
+  We use the window (if available) to enable dynamic loading of this script
+  Window won't necessarily exist for non-browsers.
+*/
+if (typeof window !== "undefined" && !window.InflectionJS)
+{
+    window.InflectionJS = null;
+}
+
+/*
+  This sets up some constants for later use
+  This should use the window namespace variable if available
+*/
+InflectionJS =
+{
+    /*
+      This is a list of nouns that use the same form for both singular and plural.
+      This list should remain entirely in lower case to correctly match Strings.
+    */
+    uncountable_words: [
+        'equipment', 'information', 'rice', 'money', 'species', 'series',
+        'fish', 'sheep', 'moose', 'deer', 'news'
+    ],
+
+    /*
+      These rules translate from the singular form of a noun to its plural form.
+    */
+    plural_rules: [
+        [new RegExp('(m)an$', 'gi'),                 '$1en'],
+        [new RegExp('(pe)rson$', 'gi'),              '$1ople'],
+        [new RegExp('(child)$', 'gi'),               '$1ren'],
+        [new RegExp('^(ox)$', 'gi'),                 '$1en'],
+        [new RegExp('(ax|test)is$', 'gi'),           '$1es'],
+        [new RegExp('(octop|vir)us$', 'gi'),         '$1i'],
+        [new RegExp('(alias|status)$', 'gi'),        '$1es'],
+        [new RegExp('(bu)s$', 'gi'),                 '$1ses'],
+        [new RegExp('(buffal|tomat|potat)o$', 'gi'), '$1oes'],
+        [new RegExp('([ti])um$', 'gi'),              '$1a'],
+        [new RegExp('sis$', 'gi'),                   'ses'],
+        [new RegExp('(?:([^f])fe|([lr])f)$', 'gi'),  '$1$2ves'],
+        [new RegExp('(hive)$', 'gi'),                '$1s'],
+        [new RegExp('([^aeiouy]|qu)y$', 'gi'),       '$1ies'],
+        [new RegExp('(x|ch|ss|sh)$', 'gi'),          '$1es'],
+        [new RegExp('(matr|vert|ind)ix|ex$', 'gi'),  '$1ices'],
+        [new RegExp('([m|l])ouse$', 'gi'),           '$1ice'],
+        [new RegExp('(quiz)$', 'gi'),                '$1zes'],
+        [new RegExp('s$', 'gi'),                     's'],
+        [new RegExp('$', 'gi'),                      's']
+    ],
+
+    /*
+      These rules translate from the plural form of a noun to its singular form.
+    */
+    singular_rules: [
+        [new RegExp('(m)en$', 'gi'),                                                       '$1an'],
+        [new RegExp('(pe)ople$', 'gi'),                                                    '$1rson'],
+        [new RegExp('(child)ren$', 'gi'),                                                  '$1'],
+        [new RegExp('([ti])a$', 'gi'),                                                     '$1um'],
+        [new RegExp('((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$','gi'), '$1$2sis'],
+        [new RegExp('(hive)s$', 'gi'),                                                     '$1'],
+        [new RegExp('(tive)s$', 'gi'),                                                     '$1'],
+        [new RegExp('(curve)s$', 'gi'),                                                    '$1'],
+        [new RegExp('([lr])ves$', 'gi'),                                                   '$1f'],
+        [new RegExp('([^fo])ves$', 'gi'),                                                  '$1fe'],
+        [new RegExp('([^aeiouy]|qu)ies$', 'gi'),                                           '$1y'],
+        [new RegExp('(s)eries$', 'gi'),                                                    '$1eries'],
+        [new RegExp('(m)ovies$', 'gi'),                                                    '$1ovie'],
+        [new RegExp('(x|ch|ss|sh)es$', 'gi'),                                              '$1'],
+        [new RegExp('([m|l])ice$', 'gi'),                                                  '$1ouse'],
+        [new RegExp('(bus)es$', 'gi'),                                                     '$1'],
+        [new RegExp('(o)es$', 'gi'),                                                       '$1'],
+        [new RegExp('(shoe)s$', 'gi'),                                                     '$1'],
+        [new RegExp('(cris|ax|test)es$', 'gi'),                                            '$1is'],
+        [new RegExp('(octop|vir)i$', 'gi'),                                                '$1us'],
+        [new RegExp('(alias|status)es$', 'gi'),                                            '$1'],
+        [new RegExp('^(ox)en', 'gi'),                                                      '$1'],
+        [new RegExp('(vert|ind)ices$', 'gi'),                                              '$1ex'],
+        [new RegExp('(matr)ices$', 'gi'),                                                  '$1ix'],
+        [new RegExp('(quiz)zes$', 'gi'),                                                   '$1'],
+        [new RegExp('s$', 'gi'),                                                           '']
+    ],
+
+    /*
+      This is a list of words that should not be capitalized for title case
+    */
+    non_titlecased_words: [
+        'and', 'or', 'nor', 'a', 'an', 'the', 'so', 'but', 'to', 'of', 'at',
+        'by', 'from', 'into', 'on', 'onto', 'off', 'out', 'in', 'over',
+        'with', 'for'
+    ],
+
+    /*
+      These are regular expressions used for converting between String formats
+    */
+    id_suffix: new RegExp('(_ids|_id)$', 'g'),
+    underbar: new RegExp('_', 'g'),
+    space_or_underbar: new RegExp('[\ _]', 'g'),
+    uppercase: new RegExp('([A-Z])', 'g'),
+    underbar_prefix: new RegExp('^_'),
+
+    /*
+      This is a helper method that applies rules based replacement to a String
+      Signature:
+        InflectionJS.apply_rules(str, rules, skip, override) == String
+      Arguments:
+        str - String - String to modify and return based on the passed rules
+        rules - Array: [RegExp, String] - Regexp to match paired with String to use for replacement
+        skip - Array: [String] - Strings to skip if they match
+        override - String (optional) - String to return as though this method succeeded (used to conform to APIs)
+      Returns:
+        String - passed String modified by passed rules
+      Examples:
+        InflectionJS.apply_rules("cows", InflectionJs.singular_rules) === 'cow'
+    */
+    apply_rules: function(str, rules, skip, override)
+    {
+        if (override)
+        {
+            str = override;
+        }
+        else
+        {
+            var ignore = (skip.indexOf(str.toLowerCase()) > -1);
+            if (!ignore)
+            {
+                for (var x = 0; x < rules.length; x++)
+                {
+                    if (str.match(rules[x][0]))
+                    {
+                        str = str.replace(rules[x][0], rules[x][1]);
+                        break;
+                    }
+                }
+            }
+        }
+        return '' + str;
+    }
+};
+
+/*
+  This lets us detect if an Array contains a given element
+  Signature:
+    Array.indexOf(item, fromIndex, compareFunc) == Integer
+  Arguments:
+    item - Object - object to locate in the Array
+    fromIndex - Integer (optional) - starts checking from this position in the Array
+    compareFunc - Function (optional) - function used to compare Array item vs passed item
+  Returns:
+    Integer - index position in the Array of the passed item
+  Examples:
+    ['hi','there'].indexOf("guys") === -1
+    ['hi','there'].indexOf("hi") === 0
+*/
+if (!Array.prototype.indexOf)
+{
+    Array.prototype.indexOf = function(item, fromIndex, compareFunc)
+    {
+        if (!fromIndex)
+        {
+            fromIndex = -1;
+        }
+        var index = -1;
+        for (var i = fromIndex; i < this.length; i++)
+        {
+            if (this[i] === item || compareFunc && compareFunc(this[i], item))
+            {
+                index = i;
+                break;
+            }
+        }
+        return index;
+    };
+}
+
+/*
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if (!String.prototype._uncountable_words)
+{
+    String.prototype._uncountable_words = InflectionJS.uncountable_words;
+}
+
+/*
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if (!String.prototype._plural_rules)
+{
+    String.prototype._plural_rules = InflectionJS.plural_rules;
+}
+
+/*
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if (!String.prototype._singular_rules)
+{
+    String.prototype._singular_rules = InflectionJS.singular_rules;
+}
+
+/*
+  You can override this list for all Strings or just one depending on if you
+  set the new values on prototype or on a given String instance.
+*/
+if (!String.prototype._non_titlecased_words)
+{
+    String.prototype._non_titlecased_words = InflectionJS.non_titlecased_words;
+}
+
+/*
+  This function adds plurilization support to every String object
+    Signature:
+      String.pluralize(plural) == String
+    Arguments:
+      plural - String (optional) - overrides normal output with said String
+    Returns:
+      String - singular English language nouns are returned in plural form
+    Examples:
+      "person".pluralize() == "people"
+      "octopus".pluralize() == "octopi"
+      "Hat".pluralize() == "Hats"
+      "person".pluralize("guys") == "guys"
+*/
+if (!String.prototype.pluralize)
+{
+    String.prototype.pluralize = function(plural)
+    {
+        return InflectionJS.apply_rules(
+            this,
+            this._plural_rules,
+            this._uncountable_words,
+            plural
+        );
+    };
+}
+
+/*
+  This function adds singularization support to every String object
+    Signature:
+      String.singularize(singular) == String
+    Arguments:
+      singular - String (optional) - overrides normal output with said String
+    Returns:
+      String - plural English language nouns are returned in singular form
+    Examples:
+      "people".singularize() == "person"
+      "octopi".singularize() == "octopus"
+      "Hats".singularize() == "Hat"
+      "guys".singularize("person") == "person"
+*/
+if (!String.prototype.singularize)
+{
+    String.prototype.singularize = function(singular)
+    {
+        return InflectionJS.apply_rules(
+            this,
+            this._singular_rules,
+            this._uncountable_words,
+            singular
+        );
+    };
+}
+
+/*
+  This function adds camelization support to every String object
+    Signature:
+      String.camelize(lowFirstLetter) == String
+    Arguments:
+      lowFirstLetter - boolean (optional) - default is to capitalize the first
+        letter of the results... passing true will lowercase it
+    Returns:
+      String - lower case underscored words will be returned in camel case
+        additionally '/' is translated to '::'
+    Examples:
+      "message_properties".camelize() == "MessageProperties"
+      "message_properties".camelize(true) == "messageProperties"
+*/
+if (!String.prototype.camelize)
+{
+     String.prototype.camelize = function(lowFirstLetter)
+     {
+        var str = this.toLowerCase();
+        var str_path = str.split('/');
+        for (var i = 0; i < str_path.length; i++)
+        {
+            var str_arr = str_path[i].split('_');
+            var initX = ((lowFirstLetter && i + 1 === str_path.length) ? (1) : (0));
+            for (var x = initX; x < str_arr.length; x++)
+            {
+                str_arr[x] = str_arr[x].charAt(0).toUpperCase() + str_arr[x].substring(1);
+            }
+            str_path[i] = str_arr.join('');
+        }
+        str = str_path.join('::');
+        return '' + str;
+    };
+}
+
+/*
+  This function adds underscore support to every String object
+    Signature:
+      String.underscore() == String
+    Arguments:
+      N/A
+    Returns:
+      String - camel cased words are returned as lower cased and underscored
+        additionally '::' is translated to '/'
+    Examples:
+      "MessageProperties".camelize() == "message_properties"
+      "messageProperties".underscore() == "message_properties"
+*/
+if (!String.prototype.underscore)
+{
+     String.prototype.underscore = function()
+     {
+        var str = this;
+        var str_path = str.split('::');
+        for (var i = 0; i < str_path.length; i++)
+        {
+            str_path[i] = str_path[i].replace(InflectionJS.uppercase, '_$1');
+            str_path[i] = str_path[i].replace(InflectionJS.underbar_prefix, '');
+        }
+        str = str_path.join('/').toLowerCase();
+        return '' + str;
+    };
+}
+
+/*
+  This function adds humanize support to every String object
+    Signature:
+      String.humanize(lowFirstLetter) == String
+    Arguments:
+      lowFirstLetter - boolean (optional) - default is to capitalize the first
+        letter of the results... passing true will lowercase it
+    Returns:
+      String - lower case underscored words will be returned in humanized form
+    Examples:
+      "message_properties".humanize() == "Message properties"
+      "message_properties".humanize(true) == "message properties"
+*/
+if (!String.prototype.humanize)
+{
+    String.prototype.humanize = function(lowFirstLetter)
+    {
+        var str = this.toLowerCase();
+        str = str.replace(InflectionJS.id_suffix, '');
+        str = str.replace(InflectionJS.underbar, ' ');
+        if (!lowFirstLetter)
+        {
+            str = str.capitalize();
+        }
+        return '' + str;
+    };
+}
+
+/*
+  This function adds capitalization support to every String object
+    Signature:
+      String.capitalize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - all characters will be lower case and the first will be upper
+    Examples:
+      "message_properties".capitalize() == "Message_properties"
+      "message properties".capitalize() == "Message properties"
+*/
+if (!String.prototype.capitalize)
+{
+    String.prototype.capitalize = function()
+    {
+        var str = this.toLowerCase();
+        str = str.substring(0, 1).toUpperCase() + str.substring(1);
+        return '' + str;
+    };
+}
+
+/*
+  This function adds dasherization support to every String object
+    Signature:
+      String.dasherize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - replaces all spaces or underbars with dashes
+    Examples:
+      "message_properties".capitalize() == "message-properties"
+      "Message Properties".capitalize() == "Message-Properties"
+*/
+if (!String.prototype.dasherize)
+{
+    String.prototype.dasherize = function()
+    {
+        var str = this;
+        str = str.replace(InflectionJS.space_or_underbar, '-');
+        return '' + str;
+    };
+}
+
+/*
+  This function adds titleize support to every String object
+    Signature:
+      String.titleize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - capitalizes words as you would for a book title
+    Examples:
+      "message_properties".titleize() == "Message Properties"
+      "message properties to keep".titleize() == "Message Properties to Keep"
+*/
+if (!String.prototype.titleize)
+{
+    String.prototype.titleize = function()
+    {
+        var str = this.toLowerCase();
+        str = str.replace(InflectionJS.underbar, ' ');
+        var str_arr = str.split(' ');
+        for (var x = 0; x < str_arr.length; x++)
+        {
+            var d = str_arr[x].split('-');
+            for (var i = 0; i < d.length; i++)
+            {
+                if (this._non_titlecased_words.indexOf(d[i].toLowerCase()) < 0)
+                {
+                    d[i] = d[i].capitalize();
+                }
+            }
+            str_arr[x] = d.join('-');
+        }
+        str = str_arr.join(' ');
+        str = str.substring(0, 1).toUpperCase() + str.substring(1);
+        return '' + str;
+    };
+}
+
+/*
+  This function adds demodulize support to every String object
+    Signature:
+      String.demodulize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - removes module names leaving only class names (Ruby style)
+    Examples:
+      "Message::Bus::Properties".demodulize() == "Properties"
+*/
+if (!String.prototype.demodulize)
+{
+    String.prototype.demodulize = function()
+    {
+        var str = this;
+        var str_arr = str.split('::');
+        str = str_arr[str_arr.length - 1];
+        return '' + str;
+    };
+}
+
+/*
+  This function adds tableize support to every String object
+    Signature:
+      String.tableize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - renders camel cased words into their underscored plural form
+    Examples:
+      "MessageBusProperty".tableize() == "message_bus_properties"
+*/
+if (!String.prototype.tableize)
+{
+    String.prototype.tableize = function()
+    {
+        var str = this;
+        str = str.underscore().pluralize();
+        return '' + str;
+    };
+}
+
+/*
+  This function adds classification support to every String object
+    Signature:
+      String.classify() == String
+    Arguments:
+      N/A
+    Returns:
+      String - underscored plural nouns become the camel cased singular form
+    Examples:
+      "message_bus_properties".classify() == "MessageBusProperty"
+*/
+if (!String.prototype.classify)
+{
+    String.prototype.classify = function()
+    {
+        var str = this;
+        str = str.camelize().singularize();
+        return '' + str;
+    };
+}
+
+/*
+  This function adds foreign key support to every String object
+    Signature:
+      String.foreign_key(dropIdUbar) == String
+    Arguments:
+      dropIdUbar - boolean (optional) - default is to seperate id with an
+        underbar at the end of the class name, you can pass true to skip it
+    Returns:
+      String - camel cased singular class names become underscored with id
+    Examples:
+      "MessageBusProperty".foreign_key() == "message_bus_property_id"
+      "MessageBusProperty".foreign_key(true) == "message_bus_propertyid"
+*/
+if (!String.prototype.foreign_key)
+{
+    String.prototype.foreign_key = function(dropIdUbar)
+    {
+        var str = this;
+        str = str.demodulize().underscore() + ((dropIdUbar) ? ('') : ('_')) + 'id';
+        return '' + str;
+    };
+}
+
+/*
+  This function adds ordinalize support to every String object
+    Signature:
+      String.ordinalize() == String
+    Arguments:
+      N/A
+    Returns:
+      String - renders all found numbers their sequence like "22nd"
+    Examples:
+      "the 1 pitch".ordinalize() == "the 1st pitch"
+*/
+if (!String.prototype.ordinalize)
+{
+    String.prototype.ordinalize = function()
+    {
+        var str = this;
+        var str_arr = str.split(' ');
+        for (var x = 0; x < str_arr.length; x++)
+        {
+            var i = parseInt(str_arr[x], 10);
+            if (!isNaN(i))
+            {
+                var ltd = str_arr[x].substring(str_arr[x].length - 2);
+                var ld = str_arr[x].substring(str_arr[x].length - 1);
+                var suf = "th";
+                if (ltd != "11" && ltd != "12" && ltd != "13")
+                {
+                    if (ld === "1")
+                    {
+                        suf = "st";
+                    }
+                    else if (ld === "2")
+                    {
+                        suf = "nd";
+                    }
+                    else if (ld === "3")
+                    {
+                        suf = "rd";
+                    }
+                }
+                str_arr[x] += suf;
+            }
+        }
+        str = str_arr.join(' ');
+        return '' + str;
+    };
+}

data/lib/assets/javascripts/action_query/extensions/module.coffee

@@ -0,0 +1,20 @@
+moduleKeywords = ['extended', 'included']
+@Modules = {}
+class @Module
+  @extend: (obj) ->
+    obj = obj.prototype || obj
+    for key, value of obj when key not in moduleKeywords
+      @[key] = value
+
+    obj.extended?.apply(@)
+    this
+
+  @include: (obj) ->
+    obj = obj.prototype || obj
+    for key, value of obj when key not in moduleKeywords
+      # Assign properties to the prototype
+      @::[key] = value
+
+    obj.included?.apply(@)
+    this
+  @new: (args...) -> new @(args...)

data/lib/assets/javascripts/action_query/private_methods.coffee

@@ -0,0 +1,57 @@
+@ActionQuery ?= {}
+class ActionQuery.$PrivateMethods
+  __processResponse__: (response) ->
+    for key,val of response
+      @[key] = val
+      @["$#{key}Was"] = val
+  format: 'json'
+  __destroy__: ->
+    route = @__selectRoute__('destroy')
+    return @$promise unless route
+    return @$promise if @$destroyed
+    for key in Object.keys @
+      continue unless key.match(/^\$.*Was$/)
+      @[key] = null
+    @$destroyed = true
+    @id = null
+    @$promise = $.ajax(
+      url: route.path
+      method: route.verb
+    )
+  __save__: ->
+    method = if @id then 'update' else 'create'
+    route = @__selectRoute__(method)
+    data = @__sanitizeParams__()
+    # Make sure there is a route
+    return @$promise unless route
+    # Make sure on update that keys are more than just format
+    return @$promise if method == 'update' && Object.keys(data[@constructor.name.underscore()]).length <= 1
+
+    @$destroyed = false
+    @$promise = $.ajax(
+      url: route.path
+      method: route.verb
+      data: data
+    )
+    .then @__processResponse__.bind(@)
+  __selectRoute__: (method) ->
+    routes = []
+    for route in @__routes__.filter((route) -> route.method == method)
+      continue unless route.requirements.subtract(Object.keys(@)).length == 0
+      path = route.path
+      for key,val of @
+        path = path.replace(":#{key}",val)
+      path = path.replace /\(.*\)/, (match) ->
+        return '' if match.indexOf(':') >= 0
+        return match[1..-2]
+      routes.push(weight: route.requirements.length, path: path, verb: route.verb)
+    weight = routes.pluck('weight').max()
+    (routes.filter (route) -> route.weight == weight).first()
+  __sanitizeParams__: ->
+    data = {}
+    data[@constructor.name.underscore()] = {}
+    for key,val of @
+      continue if key[0] in ['$','_'] || key == 'constructor'
+      continue if @[key] == @["$#{key}Was"]
+      data[@constructor.name.underscore()][key] = val
+    data

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: action_query
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Chris Moody
@@ -74,6 +74,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -83,7 +85,15 @@ files:
 - bin/console
 - bin/setup
 - lib/action_query.rb
+- lib/action_query/route.rb
 - lib/action_query/version.rb
+- lib/assets/javascripts/action_query/base.coffee
+- lib/assets/javascripts/action_query/class_methods.coffee
+- lib/assets/javascripts/action_query/classes.coffee.erb
+- lib/assets/javascripts/action_query/extensions/array.coffee
+- lib/assets/javascripts/action_query/extensions/inflection.js
+- lib/assets/javascripts/action_query/extensions/module.coffee
+- lib/assets/javascripts/action_query/private_methods.coffee
 homepage: https://github.com/cmoodyEIT/action_query
 licenses:
 - MIT