RubyGems - rangular - Versions diffs - 0.1.0.alpha - Mend

rangular 0.1.0.alpha

Files changed (11) hide show

checksums.yaml +7 -0
data/.gitignore +1 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +278 -0
data/Rakefile +1 -0
data/lib/rangular.rb +8 -0
data/lib/rangular/version.rb +5 -0
data/rangular.gemspec +26 -0
data/vendor/assets/javascripts/rangular.js +294 -0
metadata +83 -0

checksums.yaml ADDED

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c08df91fade02fcbcfab98cea5b4fafc0f778653
+  data.tar.gz: 9e086a1a49172a35db85bab0e89489c18f789d81
+SHA512:
+  metadata.gz: 4921c32475e03b40213397152356ce6e789a6bcba69cc03c5b10f1152cf442c4caf7e0b3cbbd54f7014c7d705ed441bbcf56c5d03f358ed738d5af098e30463c
+  data.tar.gz: d009a0523603404b9283c7b631fb44c2b9ea7b5c0976309c127f4490452d10c5348ae9e9f8296314d0fbb7830f2fb7395866d1799ef52d2e9a92eee3277f9447

data/.gitignore ADDED

	@@ -0,0 +1 @@
1	+ **.swp

data/Gemfile ADDED

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in rangular.gemspec
+gemspec

data/LICENSE.txt ADDED

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

data/README.md ADDED

@@ -0,0 +1,278 @@
+About
+-----
+Rangular is a script that allows AJAX calls to be made without writing Javascript. (OK, maybe one line)
+It is based on the Angular framework and designed to be plugged into Rails web apps.
+However, it can be modified to work with any RESTful framework.
+Rangular works by telling Angular how to talk to Rails and creates convenience methods and variables for RESTful server communication.
+The variables and methods are available directly from HTML with no configuration required. (OK, maybe one line)
+When I first started using Angular, I was amazed.
+It only took 10 minutes to learn enough Angular to allow me to do some amazing, dynamic things with little or no Javascript.
+However, I found the next step up, where things get really useful, to be extremely difficult.
+It was my intention in creating this tool to shelter new Angular users from some of the more daunting aspects of the framework while allowing them to continue doing even more amazing things within that "first 10 minute" window.
+I do however assume a solid understanding of Rails development.
+It is my hope that this tool can be useful for anybody wanting to add an AJAX kick to an application all the way up to people wanting to create simple one page apps.
+Quick Start
+-----------
+Javascript:
+    angular.module("yourApp", ['rangular'])
+HTML:
+    <body ng-app="yourApp">
+      <div ra-controller="notes">
+        <ul>
+          <li ng-repeat="note in notes.index">
+            {{ note.name }}
+            -
+            {{ note.content }}
+          </li>
+        </ul>
+      </div>
+    </body>
+AJAX!
+Example App
+-----------
+Here is a working example that incorporates all of the features it can without having to write any JS.
+As it stand's it's a complete and functional product that incorporates full CRUD in one page.
+### [notejax](http://notejax.herokuapp.com/)
+Usage
+-----
+Let's assume we have a Rails Controller called Notes and it's all set up to respond to and return JSON.
+You'll also need to make sure that rangular and any other necessary scripts are available from the asset pipeline.
+First, you need to define your Angular application, or at least include the rangular module in it.
+Add the `ng-app` directive to any surrounding html element.
+Usually like `<body ng-app="yourApp">`.
+Now create a Javascript or Coffeescript file and add the following line.
+    angular.module("yourApp", ['rangular']);
+Next, create an HTML element that will contain everything Notes related and add the `ra-controller` directive to it.
+    <div ra-controller="notes">
+      This is all the notes.
+    </div>
+When you reload your page, if everything is wired up properly, you should now have access to all your RESTful methods.
+Some data has already been retrieved for you, namely the index and a new Note to be used in a form.
+You can see the index data by dropping this into your html inside of the `ra-controller` element:
+    {{ notes.index }}
+You can display all of your notes with the `ng-repeat` directive.
+    <ul>
+      <li ng-repeat="note in notes.index">
+        {{ note.name }}
+        -
+        {{ note.content }}
+      </li>
+    </ul>
+There are more methods and variables that allow full access to the Rails REST methods.
+But that really is all you need to get started.
+You can use `ng-click` to change visibility variables.
+And you can use `ng-show` and `ng-hide` to `toggle` the visibility of elements.
+Remember that you can pass variables from Rails to Javascript, but not the other way around (not easily anyway).
+So `<div ra-controller="<%= controller_name %>">` should work.
+But `<%= link_to {{ note.name }}, {{ note }} %>` will not.
+Core Concepts
+-------------
+Calling `ra-controller` creates an object with the same name as the controller.
+The controller name is assumed to be a Rails controller and all restful connections are automatically created.
+So `<div ra-controller="contacts">` will create a `contacts` object available to the view.
+Any elements inside of the element that called ra-controller will have access to that object.
+Calling `ra-controller` also calls the server's index and new actions so that data is immediately available.
+Data returned from the server is stored in restfully named variables.
+Server calls are made via restfully named functions.
+Rangular functions should be run only as needed and not displayed like model data.
+Attempting to display functions as model data will create an infinite loop of server calls.
+That's a very bad thing.
+* Good:
+  `<button ng-click="contacts.callIndex()">`
+* Bad:
+  `{{ contacts.callIndex() }}`
+Show and edit actions are both called by providing Rangular with an id via `setId(id)`.
+Show and edit data are cleared with the `clearId()` function.
+Each restful action has a corresponding loading variable to change what is displayed as your data is loading.
+And for the more adventurous, each function calls a broadcaster that you can set up listeners for upon success or failure.
+Each function allows for success and failure functions to be passed in as well.
+Options
+-------
+These options can be used with the rangular controller declaration:
+* `ra-query`
+  Used to pass extra params to the server.
+  Pass in params with the JS object syntax.
+  example: `<div ra-controller="notes" ra-query="{page:4, limit:10}">`
+* `ra-show`
+  Used to render a single element by default instead of an index.
+  example: `<div ra-controller="notes" ra-show="42">`
+Functions
+---------
+All functions are called like `controller_name.callIndex` where controller_name is the name of your controller.
+`callIndex([query], [success_function, [failure_function]])`
+  * automatically called when `ra-controller="controller_name"` is called
+  * ignores `query.id` and any id set by `setId()`
+  * sets variable `indexLoading` while waiting for server
+  * broadcasts "controller_name.index ready" when finished successfully
+  * broadcasts "controller_name.index error" when finished with errors
+  * calls success_function when finished successfully
+  * calls failure_function when finished with errors
+`callShow([query], [success_function, [failure_function]])`
+  * automatically called when id is set
+  * sets variable `showLoading` while waiting for server
+  * broadcasts "controller_name.show ready" when finished successfully
+  * broadcasts "controller_name.show error" when finished with errors
+  * calls success_function when finished successfully
+  * calls failure_function when finished with errors
+`callNew([query], [success_function, [failure_function]])`
+  * automatically called when `ra-controller="controller_name"` is called
+  * sets variable `newLoading` while waiting for server
+  * broadcasts "controller_name.new ready" when finished successfully
+  * broadcasts "controller_name.new error" when finished with errors
+  * calls success_function when finished successfully
+  * calls failure_function when finished with errors
+`callCreate([query], [success_function, [failure_function]])`
+  * sets variable `createLoading` while waiting for server
+  * broadcasts "controller_name.create success" when finished successfully
+  * broadcasts "controller_name.create failure" when finished with errors
+  * calls success_function when finished successfully
+  * calls failure_function when finished with errors
+  * calls index and new upon success
+`callEdit([query], [success_function, [failure_function]])`
+  * automatically called when id is set
+  * sets variable `editLoading` while waiting for server
+  * broadcasts "controller_name.edit ready" when finished successfully
+  * broadcasts "controller_name.edit error" when finished with errors
+  * calls success_function when finished successfully
+  * calls failure_function when finished with errors
+`callUpdate([query], [success_function, [failure_function]])`
+  * sets variable `updateLoading` while waiting for server
+  * broadcasts "controller_name.update success" when finished successfully
+  * broadcasts "controller_name.update failure" when finished with errors
+  * calls success_function when finished successfully
+  * calls failure_function when finished with errors
+  * calls index and new upon success
+`callDelete(id, [query])`
+  * sets variable `deleteLoading` while waiting for server
+  * broadcasts "controller_name.delete success" when finished successfully
+  * broadcasts "controller_name.delete failure" when finished with errors
+  * calls index and new upon success
+`setId(id)`
+  * sets variable `id`
+  * makes id available from any function
+`clearId()`
+  * clears variable `id`
+Variables
+---------
+All variables are called like `controller_name.index` where controller_name is the name of your controller.
+The restful variables are index, show, edit, and new.
+These variables contain the JSON that was returned from the server during a successful call.
+The error variables are createError and updateError.
+These variables contain error data that was returned from rails.
+The errors come in the form of a hash where the keys are field names and the values are arrays of errors.
+Example:
+    "createError":{"name":    ["can't be blank","is too short (minimum is 5 characters)"],
+                   "content": ["is too short (minimum is 20 characters)"],
+                   "user":    ["can't be blank"]}
+Other variables are query and id.
+These probably shouldn't be changed directly as it can interfere with the internal workings of Rangular.
+The query can be set as an option and the id can be changed with the `setId(id)` and `clearId()` functions.
+Also, queries can be passed in to any of the restful call functions.
+Callbacks and Broadcasters
+--------------------------
+#### Callbacks
+Callbacks may be buggy, have unforseen concequences, and summon unknowable horrors from the darkest pits.
+Proceed with caution or use broadcasters.
+Callbacks (success and failure functions) should be declared as variables in JS.
+I don't believe it's even possible to pass a function through HTML using Angular.
+And even if you can, that's a very bad practice.
+If you want to hide a form after a successfull server call, it would look something like this:
+    var shutNew = function() {
+      $scope.showNewNotes = false;
+    }
+Then in HTML:
+    <form ng-show="showNewNotes">
+      <button ng-click="notes.callCreate(shutNew)">
+    </form>
+Rangular uses scope without the dollar sign internally.
+So if you want to access rangular variables from inside your own JS:
+    if(scope.notes.id) {
+      do.something.awesome;
+    }
+#### Broadcasters
+Rangular uses `$broadcast` instead of `$emit` as broadcast sends messages down the scope stack to all the children.
+Whereas emit sends messages up the scope stack to all the ancestors.
+It was my goal in creating Rangular to allow controllers to be used multiple times during a page and to allow multiple controllers in a page.
+As that's the case, I didn't want broadcasters to interfere with any other controllers.
+In your JS:
+    $scope.$on('notes.show ready', function() {
+      do.something.awesome;
+    });
+Planned Features and Bug Fixes
+----------------------------
+  * implement callbacks in callDelete() function

data/Rakefile ADDED

	@@ -0,0 +1 @@
1	+ require "bundler/gem_tasks"

data/lib/rangular.rb ADDED

@@ -0,0 +1,8 @@
+require "rangular/version"
+module Rangular
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/rangular/version.rb ADDED

@@ -0,0 +1,5 @@
+module Rangular
+  module Rails
+    VERSION = "0.1.0.alpha"
+  end
+end

data/rangular.gemspec ADDED

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rangular/version'
+Gem::Specification.new do |spec|
+  spec.name          = "rangular"
+  spec.version       = Rangular::Rails::VERSION
+  spec.authors       = ["Lee Nathan"]
+  spec.email         = ["leetheguy@gmail.com"]
+  spec.description   = %q{put AJAX data updates in your HTML without writing JS}
+  spec.summary       = %q{
+                          Rangular empowers skilled Rails developers to add AJAX to their sites quickly and easily.
+                          Rangular uses the power of the Angular framework to allow AJAX calls to be made to a Rails server without writing Javascript.
+                         }
+  spec.homepage      = "https://github.com/leetheguy/rangular"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/vendor/assets/javascripts/rangular.js ADDED

@@ -0,0 +1,294 @@
+var railsRoutesSet, rangular;
+rangular = angular.module('rangular', ["ngResource"]);
+railsRoutesSet = {
+  index: {
+    method: "GET",
+    isArray: true
+  },
+  show: {
+    method: "GET"
+  },
+  "new": {
+    method: "GET",
+    params: {
+      verb: "new"
+    }
+  },
+  create: {
+    method: "POST"
+  },
+  edit: {
+    method: "GET",
+    params: {
+      verb: "edit"
+    }
+  },
+  update: {
+    method: "PUT"
+  },
+  destroy: {
+    method: "DELETE"
+  },
+  info: {
+    method: "GET",
+    params: {
+      verb: "info"
+    }
+  }
+};
+rangular.config([
+  "$httpProvider", function($httpProvider) {
+    $httpProvider.defaults.headers.common['X-CSRF-Token'] = $('meta[name=csrf-token]').attr('content');
+    $httpProvider.defaults.headers.common["X-Requested-With"] = 'XMLHttpRequest';
+  }
+]);
+rangular.factory("railsResource", [
+  "$resource", function($resource) {
+    return $resource("/:controller/:id/:verb", {
+      id: '@id'
+    }, railsRoutesSet);
+  }
+]);
+rangular.directive('raController', [
+  "railsResource", function(railsResource) {
+    return function(scope, element, attrs) {
+      var callShowAndEdit, rctrl;
+      rctrl = attrs.raController;
+      scope[rctrl] = {};
+      scope[rctrl].query = attrs.raQuery === void 0 ? {} : eval('(' + attrs.raQuery + ')');
+      scope[rctrl].query.controller = rctrl;
+      // [query], [success, [failure]]
+      processArgs = function() {
+        rargs = ({query:null, success:null, failure:null});
+        args = arguments[0]
+        if (args[0]  !== undefined) {
+          if (Object.prototype.toString.call(args[0]) == "[object Function]") {
+            rargs.success = args[0];
+          } else {
+            rargs.query = args[0];
+          }
+          if (args[1]  !== undefined) {
+            if (Object.prototype.toString.call(args[1]) == "[object Function]") {
+              if (!!rargs.success) {
+                rargs.failure = args[1];
+              } else {
+                rargs.success = args[1];
+              }
+            }
+            if (args[2]  !== undefined) {
+              if (Object.prototype.toString.call(args[2]) == "[object Function]") {
+                if (!!!rargs.failure) {
+                  rargs.failure = args[2];
+                }
+              }
+            }
+          }
+        }
+        return rargs;
+      };
+      scope[rctrl].callIndex = function() {
+        scope.indexRargs = processArgs(arguments);
+        scope[rctrl].indexLoading = true;
+        if (scope.indexRargs.query == null) {
+          scope.indexRargs.query = scope[rctrl].query;
+        }
+        scope.indexRargs.query.id = null;
+        scope[rctrl].index = railsResource.index(scope.indexRargs.query, function() {
+          scope.$broadcast(rctrl + '.index ready');
+          if(scope.indexRargs.success) {
+            scope.indexRargs.success();
+          }
+          scope.indexRargs = null;
+          scope[rctrl].indexLoading = false;
+        }, function() {
+          scope.$broadcast(rctrl + '.index error');
+          if(scope.indexRargs.failure) {
+            scope.indexRargs.failure();
+          }
+          scope.indexRargs = null;
+          scope[rctrl].indexLoading = false;
+        });
+      };
+      callShowAndEdit = function() {
+        rargs = processArgs(arguments);
+        if (rargs.query == null) {
+          rargs.query = scope[rctrl].query;
+        }
+        scope[rctrl].callShow(rargs.query);
+        scope[rctrl].callEdit(rargs.query);
+      };
+      scope[rctrl].callShow = function() {
+        scope.showRargs = processArgs(arguments);
+        if (scope.showRargs.query == null) {
+          scope.showRargs.query = scope[rctrl].query;
+        }
+        if (!!scope[rctrl].id) {
+          scope.showRargs.query.id = scope[rctrl].id;
+          scope[rctrl].show = railsResource.show(scope.showRargs.query, function() {
+            scope[rctrl].showLoading = false;
+            scope.$broadcast(rctrl + '.show ready');
+          }, function() {
+            scope[rctrl].showLoading = false;
+          });
+          scope.showRargs = null;
+          scope[rctrl].showLoading = true;
+        } else {
+          scope[rctrl].show = null;
+          scope.$broadcast(rctrl + '.show error');
+          scope.showRargs = null;
+          scope[rctrl].showLoading = false;
+        }
+      };
+      scope[rctrl].callNew = function() {
+        scope.newRargs = processArgs(arguments);
+        scope[rctrl].newLoading = true;
+        if (scope.newRargs.query == null) {
+          scope.newRargs.query = scope[rctrl].query;
+        }
+        if (!!!scope.newRargs.query.controller) {
+          scope.newRargs.query.controller = rctrl;
+        }
+        scope[rctrl]["new"] = railsResource["new"](scope.newRargs.query, function() {
+          scope[rctrl].createError = null;
+          scope.$broadcast(rctrl + '.new ready');
+          scope.newRargs = null;
+          scope[rctrl].newLoading = false;
+        }, function() {
+          scope.$broadcast(rctrl + '.new error');
+          scope.newRargs = null;
+          scope[rctrl].newLoading = false;
+        });
+      };
+      scope[rctrl].callEdit = function() {
+        scope.editRargs = processArgs(arguments);
+        if (scope.editRargs.query == null) {
+          scope.editRargs.query = scope[rctrl].query;
+        }
+        if (!!!scope.editRargs.query.controller) {
+          scope.editRargs.query.controller = rctrl;
+        }
+        if (!!scope[rctrl].id) {
+          scope[rctrl].editLoading = true;
+          scope.editRargs.query.id = scope[rctrl].id;
+          scope[rctrl].edit = railsResource.edit(scope.editRargs.query, function() {
+            scope[rctrl].updateError = null;
+            scope[rctrl].editLoading = false;
+            scope.$broadcast(rctrl + '.edit ready');
+          }, function() {
+            scope.$broadcast(rctrl + '.edit error');
+          });
+          scope.editRargs = null;
+        } else {
+          scope[rctrl].editLoading = false;
+          scope[rctrl].edit = null;
+          scope.editRargs = null;
+        }
+      };
+      scope[rctrl].callCreate = function() {
+        scope.createRargs = processArgs(arguments);
+        scope[rctrl].createLoading = true;
+        if (scope.createRargs.query == null) {
+          scope.createRargs.query = scope[rctrl].query;
+        }
+        scope[rctrl]["new"].$create(scope.createRargs.query, function() {
+          scope[rctrl].callNew();
+          scope[rctrl].callIndex();
+          scope[rctrl].createError = null;
+          scope.$broadcast(rctrl + '.create success');
+          scope.createRargs = null;
+          scope[rctrl].createLoading = false;
+        }, function(object) {
+          if (object.data) {
+            scope[rctrl].createError = object.data;
+          }
+          scope.$broadcast(rctrl + '.create failure');
+          scope.createRargs = null;
+          scope[rctrl].createLoading = false;
+        });
+      };
+      scope[rctrl].callUpdate = function() {
+        scope.updateRargs = processArgs(arguments);
+        scope[rctrl].updateLoading = true;
+        if (scope.updateRargs.query == null) {
+          scope.updateRargs.query = scope[rctrl].query;
+        }
+        scope[rctrl]["edit"].$update(scope.updateRargs.query, function() {
+          scope[rctrl].updateError = null;
+          scope[rctrl].callIndex();
+          scope.$broadcast(rctrl + '.update success');
+          scope.updateRargs = null;
+          scope[rctrl].updateLoading = false;
+        }, function(object) {
+          if (object.data) {
+            scope[rctrl].updateError = object.data;
+          }
+          scope.$broadcast(rctrl + '.update failure');
+          scope.updateRargs = null;
+          scope[rctrl].updateLoading = false;
+        });
+      };
+      scope[rctrl].callDelete = function(id, query) {
+        scope[rctrl].deleteLoading = true;
+        if (query == null) {
+          query = scope[rctrl].query;
+        }
+        if (!query.id) {
+          query.id = id;
+        }
+        railsResource["delete"](query, function() {
+          scope[rctrl].callIndex();
+          scope.$broadcast(rctrl + '.delete success');
+          scope.updateRargs = null;
+          scope[rctrl].deleteLoading = false;
+        }, function() {
+          scope.$broadcast(rctrl + '.delete failure');
+          scope[rctrl].deleteLoading = false;
+        });
+      };
+      scope[rctrl].clearId = function() {
+        scope[rctrl].id = null;
+        callShowAndEdit();
+      };
+      scope[rctrl].setId = function(id) {
+        if (id == null) {
+          id = attrs.raShow;
+        }
+        scope[rctrl].id = id;
+        callShowAndEdit();
+      };
+      scope[rctrl].callNew();
+      if (!!!attrs.raShow) {
+        scope[rctrl].callIndex();
+        scope[rctrl].clearId();
+      } else {
+        scope[rctrl].setId();
+      }
+    };
+  }
+]);

metadata ADDED

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: rangular
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha
+platform: ruby
+authors:
+- Lee Nathan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: put AJAX data updates in your HTML without writing JS
+email:
+- leetheguy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rangular.rb
+- lib/rangular/version.rb
+- rangular.gemspec
+- vendor/assets/javascripts/rangular.js
+homepage: https://github.com/leetheguy/rangular
+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: 1.3.1
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.0
+signing_key:
+specification_version: 4
+summary: Rangular empowers skilled Rails developers to add AJAX to their sites quickly
+  and easily. Rangular uses the power of the Angular framework to allow AJAX calls
+  to be made to a Rails server without writing Javascript.
+test_files: []