rateyo-rails 2.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: acdb11643b88d00abd40e8e779b945a9de7a7f53
+  data.tar.gz: 29a0136a91f8874da97e042f62c3c76479e767c0
+SHA512:
+  metadata.gz: 0825f17078b7925cc29b7856dd25e93541dbc93a102f50a568792edac9398f3196573fbaf6629d7d5c93085165565b4612178df656b85385ef94aa9e72ed5ac1
+  data.tar.gz: 4436b40873d3951b3c612ddfc1213b3171a2ddf263fa891f4a26f8192b1859a692ff1280b63b0f842eeae9d08e18ca128542069f4b3a75cfe52cf19d21741af6

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 prashanth pamidi
+
+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

@@ -0,0 +1,47 @@
+# rateYo
+
+Rails asset pipeline integration for [rateYo](https://github.com/prrashi/rateYo)
+
+rateYo version `2.1.1`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rateyo-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rateyo-rails
+
+## Usage
+
+rateyo-rails contains both css and js for rateyo
+ 
+Include rateyo js in app/assets/javascripts/application.js
+  
+```javascript
+//= require jquery.rateyo
+```
+
+Include card css in app/assets/stylesheets/application.css
+
+```css
+/*
+ *= require jquery.rateyo
+ */
+```
+
+For information on how to use rateyo please visit [https://github.com/prrashi/rateYo](https://github.com/prrashi/rateYo)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new pull request

data/Rakefile

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

data/app/assets/javascripts/jquery.rateyo.js

@@ -0,0 +1,1062 @@
+/*****
+* rateYo - v2.1.1
+* http://prrashi.github.io/rateyo/
+* Copyright (c) 2014 Prashanth Pamidi; Licensed MIT
+*****/
+
+;(function ($) {
+  "use strict";
+
+  // The basic svg string required to generate stars
+  var BASICSTAR = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"+
+                  "<svg version=\"1.1\""+
+                        "xmlns=\"http://www.w3.org/2000/svg\""+
+                        "viewBox=\"0 12.705 512 486.59\""+
+                        "x=\"0px\" y=\"0px\""+
+                        "xml:space=\"preserve\">"+
+                    "<polygon "+
+                              "points=\"256.814,12.705 317.205,198.566"+
+                                      " 512.631,198.566 354.529,313.435 "+
+                                      "414.918,499.295 256.814,384.427 "+
+                                      "98.713,499.295 159.102,313.435 "+
+                                      "1,198.566 196.426,198.566 \"/>"+
+                  "</svg>";
+
+  // The Default values of different options available in the Plugin
+  var DEFAULTS = {
+
+    starWidth : "32px",
+    normalFill: "gray",
+    ratedFill : "#f39c12",
+    numStars  : 5,
+    maxValue  : 5,
+    precision : 1,
+    rating    : 0,
+    fullStar  : false,
+    halfStar  : false,
+    readOnly  : false,
+    spacing   : "0px",
+    multiColor: null,
+    onInit    : null,
+    onChange  : null,
+    onSet     : null
+  };
+
+  //Default colors for multi-color rating
+  var MULTICOLOR_OPTIONS = {
+
+    startColor: "#c0392b", //red
+    endColor  : "#f1c40f"  //yellow
+  };
+
+  function checkPrecision (value, minValue, maxValue) {
+
+    /* 
+     * This function removes the unnecessary precision, at Min and Max Values
+     */
+
+    // Its like comparing 0.0 with 0, which is true
+    if (value === minValue) {
+
+      value = minValue;
+    }
+    else if(value === maxValue) {
+
+      value = maxValue;
+    }
+
+    return value;
+  }
+
+  function checkBounds (value, minValue, maxValue) {
+
+    /*
+     * Check if the value is between min and max values, if not, throw an error
+     */
+
+    var isValid = value >= minValue && value <= maxValue;
+
+    if(!isValid){
+
+        throw Error("Invalid Rating, expected value between "+ minValue +
+                    " and " + maxValue);
+    }
+
+    return value;
+  }
+
+  function isDefined(value) {
+
+    // Better way to check if a variable is defined or not
+    return typeof value !== "undefined";
+  }
+
+  // Regex to match Colors in Hex Format like #FF00FF
+  var hexRegex = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+
+  var hexToRGB = function (hex) {
+
+    /*
+     * Extracts and returns the Red, Blue, Green Channel values,
+     * in the form of decimals
+     */
+
+    if (!hexRegex.test(hex)) {
+
+      return null;
+    }
+
+    var hexValues = hexRegex.exec(hex),
+	r = parseInt(hexValues[1], 16),
+	g = parseInt(hexValues[2], 16),
+	b = parseInt(hexValues[3], 16);
+
+    return {r:r, g:g, b:b};
+  };
+
+  function getChannelValue(startVal, endVal, percent) {
+
+    /*
+     * Returns a value between `startVal` and `endVal` based on the percent 
+     */
+
+    var newVal = (endVal - startVal)*(percent/100);
+ 
+    newVal = Math.round(startVal + newVal).toString(16);
+
+    if (newVal.length === 1) {
+
+	newVal = "0" + newVal;
+    }
+
+    return newVal;
+  }
+
+  function getColor (startColor, endColor, percent) {
+
+    /*
+     * Given the percentage( `percent` ) of `endColor` to be mixed
+     * with the `startColor`, returns the mixed color.
+     * Colors should be only in Hex Format
+     */
+
+    if (!startColor || !endColor) {
+
+      return null;
+    }
+
+    percent = isDefined(percent)? percent : 0;
+
+    startColor = hexToRGB(startColor);
+    endColor = hexToRGB(endColor);
+
+    var r = getChannelValue(startColor.r, endColor.r, percent),
+        b = getChannelValue(startColor.b, endColor.b, percent),
+        g = getChannelValue(startColor.g, endColor.g, percent);
+
+    return "#" + r + g + b;
+  }
+
+   function RateYo ($node, options) {
+
+   /*
+    * The Contructor, whose instances are used by plugin itself
+    */
+
+    // Storing the HTML element as a property, for future access
+    this.node = $node.get(0);
+
+    var that = this;
+
+    // Remove any stuff that is present inside the container, and add the plugin class 
+    $node.empty().addClass("jq-ry-container");
+
+    /*
+     * Basically the plugin displays the rating using two rows of stars lying one above
+     * the other, the row that is on the top represents the actual rating, and the one
+     * behind acts just like a background.
+     *
+     * `$groupWrapper`: is an element that wraps both the rows
+     * `$normalGroup`: is the container for row of stars thats behind and
+     *                 acts as background
+     * `$ratedGroup`: is the container for row of stars that display the actual rating.
+     *
+     * The rating is displayed by adjusting the width of `$ratedGroup`
+     */  	
+    var $groupWrapper = $("<div/>").addClass("jq-ry-group-wrapper")
+                                   .appendTo($node);
+
+    var $normalGroup = $("<div/>").addClass("jq-ry-normal-group")
+                                  .addClass("jq-ry-group")
+                                  .appendTo($groupWrapper);
+
+    var $ratedGroup = $("<div/>").addClass("jq-ry-rated-group")
+                                 .addClass("jq-ry-group")
+                                 .appendTo($groupWrapper);
+
+    /*
+     * Variable `step`: store the value of the rating for each star
+     *                  eg: if `maxValue` is 5 and `numStars` is 5, value of each star
+     *                      is 1.
+     * Variable `starWidth`: stores the decimal value of width of star in units of px
+     * Variable `percentOfStar`: stores the percentage of width each star takes w.r.t
+     *                           the container
+     * Variable `spacing`: stores the decimal value of the spacing between stars
+     *                     in the units of px
+     * Variable `percentOfSpacing`: stores the percentage of width of the spacing
+     *                              between stars w.r.t the container
+     */
+    var step, starWidth, percentOfStar, spacing,
+        percentOfSpacing, containerWidth, minValue = 0;
+
+    /*
+     * `currentRating` contains rating that is being displayed at the latest point of
+     * time.
+     *
+     * When ever you hover over the plugin UI, the rating value changes
+     * according to the place where you point the cursor, currentRating contains
+     * the current value of rating that is being shown in the UI
+     */
+    var currentRating = options.rating;
+
+    // A flag to store if the plugin is already being displayed in the UI
+    var isInitialized = false;
+
+    function showRating (ratingVal) {
+
+      /*
+       * The function is responsible for displaying the rating by changing
+       * the width of `$ratedGroup`
+       */
+
+      if (!isDefined(ratingVal)) {
+
+        ratingVal = options.rating;
+      }
+
+      // Storing the value that is being shown in `currentRating`.
+      currentRating = ratingVal;
+
+      var numStarsToShow = ratingVal/step;
+
+      // calculating the percentage of width of $ratedGroup with respect to its parent
+      var percent = numStarsToShow*percentOfStar;
+
+      if (numStarsToShow > 1) {
+
+        // adding the percentage of space that is taken by the gap the stars
+        percent += (Math.ceil(numStarsToShow) - 1)*percentOfSpacing;
+      }
+
+      setRatedFill(options.ratedFill);
+
+      $ratedGroup.css("width", percent + "%");
+    }
+
+    function setContainerWidth () {
+
+      /*
+       * Set the width of the `this.node` based on the width of each star and
+       * the space between them 
+       */
+
+      containerWidth = starWidth*options.numStars + spacing*(options.numStars - 1);
+
+      percentOfStar = (starWidth/containerWidth)*100;
+
+      percentOfSpacing = (spacing/containerWidth)*100;
+
+      $node.width(containerWidth);
+
+      showRating();
+    }
+
+    function setStarWidth (newWidth) {
+
+      /*
+       * Set the width and height of each SVG star, called whenever one changes the
+       * `starWidth` option
+       */
+
+      // The width and height of the star should be the same
+      var starHeight = options.starWidth = newWidth;
+
+      starWidth = window.parseFloat(options.starWidth.replace("px", ""));
+ 
+      $normalGroup.find("svg")
+                  .attr({width : options.starWidth,
+                         height: starHeight});
+
+      $ratedGroup.find("svg")
+                 .attr({width : options.starWidth,
+                        height: starHeight});
+
+      setContainerWidth();
+       
+      return $node;
+    }
+
+    function setSpacing (newSpacing) {
+
+      /*
+       * Set spacing between the SVG stars, called whenever one changes
+       * the `spacing` option
+       */
+      
+      options.spacing = newSpacing;
+
+      spacing = parseFloat(options.spacing.replace("px", ""));
+
+      $normalGroup.find("svg:not(:first-child)")
+                  .css({"margin-left": newSpacing});
+
+      $ratedGroup.find("svg:not(:first-child)")
+                 .css({"margin-left": newSpacing}); 
+
+      setContainerWidth();
+
+      return $node;
+    }
+
+    function setNormalFill (newFill) {
+
+      /*
+       * Set the background fill of the Stars, called whenever one changes the
+       * `normalFill` option
+       */
+
+      options.normalFill = newFill;
+
+      $normalGroup.find("svg").attr({fill: options.normalFill});
+
+      return $node;
+    }
+
+    /*
+     * Store the recent `ratedFill` option in a variable
+     * so that if multiColor is unset, we can use the perviously set `ratedFill`
+     * from this variable
+     */
+    var ratedFill = options.ratedFill;
+
+    function setRatedFill (newFill) {
+
+      /*
+       * Set ratedFill of the stars, called when one changes the `ratedFill` option
+       */
+
+      /*
+       * If `multiColor` option is set, `newFill` variable is dynamically set
+       * based on the rating, what ever set as parameter will be discarded
+       */
+      if (options.multiColor) {
+
+        var ratingDiff = currentRating - minValue,
+            percentCovered = (ratingDiff/options.maxValue)*100;
+
+        var colorOpts  = options.multiColor || {},
+            startColor = colorOpts.startColor || MULTICOLOR_OPTIONS.startColor,
+            endColor   = colorOpts.endColor || MULTICOLOR_OPTIONS.endColor;
+
+        newFill = getColor(startColor, endColor, percentCovered);
+      } else {
+
+        ratedFill = newFill;
+      }
+
+      options.ratedFill = newFill;
+
+      $ratedGroup.find("svg").attr({fill: options.ratedFill});
+
+      return $node;
+    }
+
+    function setMultiColor (colorOptions) {
+
+      /*
+       * called whenever one changes the `multiColor` option
+       */
+
+      options.multiColor = colorOptions;
+
+      // set the recently set `ratedFill` option, if multiColor Options are unset
+      setRatedFill(colorOptions ? colorOptions : ratedFill);
+    }
+
+    function setNumStars (newValue) {
+
+      /*
+       * Set the number of stars to use to display the rating, called whenever one
+       * changes the `numStars` option
+       */
+
+      options.numStars = newValue;
+
+      step = options.maxValue/options.numStars;
+
+      $normalGroup.empty();
+      $ratedGroup.empty();
+
+      for (var i=0; i<options.numStars; i++) {
+
+        $normalGroup.append($(BASICSTAR));
+        $ratedGroup.append($(BASICSTAR));
+      }
+
+      setStarWidth(options.starWidth);
+      setNormalFill(options.normalFill);
+      setSpacing(options.spacing);
+
+      showRating();
+
+      return $node;
+    }
+
+    function setMaxValue (newValue) {
+
+      /*
+       * set the Maximum Value of rating to be allowed, called whenever
+       * one changes the `maxValue` option
+       */
+
+      options.maxValue = newValue;
+
+      step = options.maxValue/options.numStars;
+
+      if (options.rating > newValue) {
+      
+        setRating(newValue); 
+      }
+
+      showRating();
+
+      return $node;
+    }
+
+    function setPrecision (newValue) {
+
+      /*
+       * Set the precision of the rating value, called if one changes the
+       * `precision` option
+       */
+
+      options.precision = newValue;
+
+      setRating(options.rating);
+
+      return $node;
+    }
+
+    function setHalfStar (newValue) {
+
+      /*
+       * This function will be called if one changes the `halfStar` option
+       */
+
+      options.halfStar = newValue;
+
+      return $node;
+    }
+
+    function setFullStar (newValue) {
+
+      /*
+       * This function will be called if one changes the `fullStar` option
+       */   
+
+      options.fullStar = newValue;
+
+      return $node;
+    }
+
+    function round (value) {
+
+      /*
+       * Rounds the value of rating if `halfStar` or `fullStar` options are chosen
+       */
+      
+      var remainder = value%step,
+          halfStep = step/2,
+          isHalfStar = options.halfStar,
+          isFullStar = options.fullStar;
+
+      if (!isFullStar && !isHalfStar) {
+      
+        return value;  
+      }
+
+      if (isFullStar || (isHalfStar && remainder > halfStep)) {
+      
+        value += step - remainder;
+      } else {
+      
+        value = value - remainder;
+        
+        if (remainder > 0) {
+          
+          value += halfStep;
+        }
+      }
+
+      return value;
+    }
+
+    function calculateRating (e) {
+
+      /*
+       * Calculates and returns the rating based on the position of cursor w.r.t the
+       * plugin container
+       */
+
+      var position = $normalGroup.offset(),
+          nodeStartX = position.left,
+          nodeEndX = nodeStartX + $normalGroup.width();
+
+      var maxValue = options.maxValue;
+
+      // The x-coordinate(position) of the mouse pointer w.r.t page
+      var pageX = e.pageX;
+
+      var calculatedRating = 0;
+
+      // If the mouse pointer is to the left of the container
+      if(pageX < nodeStartX) {
+
+        calculatedRating = minValue;
+      }else if (pageX > nodeEndX) { // If the mouse pointer is right of the container
+
+        calculatedRating = maxValue;
+      }else { // If the mouse pointer is inside the continer
+
+        /*
+         * The fraction of width covered by the pointer w.r.t to the total width
+         * of the container.
+         */
+        var calcPrcnt = ((pageX - nodeStartX)/(nodeEndX - nodeStartX));
+
+        if (spacing > 0) {
+
+	  /*
+           * If there is spacing between stars, take the percentage of width covered
+           * and subtract the percentage of width covered by stars and spacing, to find
+           * how many stars are covered, the number of stars covered is the rating
+           *
+           * TODO: I strongly feel that this logic can be improved!, Please help!
+           */
+          calcPrcnt *= 100;
+
+          var remPrcnt = calcPrcnt;
+
+          while (remPrcnt > 0) {
+            
+            if (remPrcnt > percentOfStar) {
+
+              calculatedRating += step;
+              remPrcnt -= (percentOfStar + percentOfSpacing);
+            } else {
+
+              calculatedRating += remPrcnt/percentOfStar*step;
+              remPrcnt = 0;
+            }  
+          }
+        } else {
+        
+          /*
+           * If there is not spacing between stars, the fraction of width covered per
+           * `maxValue` is the rating
+           */
+          calculatedRating = calcPrcnt * (options.maxValue);  
+        }
+
+        // Round the rating if `halfStar` or `fullStar` options are chosen
+        calculatedRating = round(calculatedRating);
+      }
+
+      return calculatedRating;
+    }
+
+    function setReadOnly (newValue) {
+
+      /*
+       * UnBinds mouse event handlers, called when whenever one changes the
+       * `readOnly` option
+       */
+
+      options.readOnly = newValue;
+
+      $node.attr("readonly", true);
+
+      unbindEvents();
+
+      if (!newValue) {
+
+        $node.removeAttr("readonly");
+
+        bindEvents();
+      }
+
+      return $node;
+    }
+
+    function setRating (newValue) {
+
+      /*
+       * Sets the rating of the Plugin, Called when option `rating` is changed
+       * or, when `rating` method is called
+       */
+
+      var rating = newValue;
+
+      var maxValue = options.maxValue;
+
+      if (typeof rating === "string") {
+
+        // If rating is given in percentage, maxValue should be 100
+        if (rating[rating.length - 1] === "%") {
+
+          rating = rating.substr(0, rating.length - 1);
+          maxValue = 100;
+
+          setMaxValue(maxValue);
+        }
+
+        rating = parseFloat(rating);
+      }
+
+      checkBounds(rating, minValue, maxValue);
+
+      rating = parseFloat(rating.toFixed(options.precision));
+
+      checkPrecision(parseFloat(rating), minValue, maxValue);
+
+      options.rating = rating;
+
+      showRating();
+
+      if (isInitialized) {
+
+        $node.trigger("rateyo.set", {rating: rating});
+      }
+
+      return $node;
+    }
+
+    function setOnInit (method) {
+
+      /*
+       * set what method to be called on Initialization
+       */
+
+      options.onInit = method;
+
+      return $node;
+    }
+
+    function setOnSet (method) {
+
+      /*
+       * set what method to be called when rating is set
+       */
+
+      options.onSet = method;
+
+      return $node;
+    }
+
+    function setOnChange (method) {
+
+      /*
+       * set what method to be called rating in the UI is changed
+       */
+
+      options.onChange = method;
+
+      return $node;
+    }
+
+    this.rating = function (newValue) {
+
+      /*
+       * rating getter/setter
+       */
+
+      if (!isDefined(newValue)) {
+
+        return options.rating;
+      }
+
+      setRating(newValue);
+
+      return $node;
+    };
+
+    this.destroy = function () {
+
+      /*
+       * Removes the Rating UI by clearing the content, and removing the custom classes
+       */
+
+      if (!options.readOnly) {
+
+        unbindEvents();
+      }
+
+      RateYo.prototype.collection = deleteInstance($node.get(0),
+                                                   this.collection);
+
+      $node.removeClass("jq-ry-container").children().remove();
+
+      return $node;
+    };
+
+    this.method = function (methodName) {
+
+      /*
+       * Method to call the methods of RateYo Instance
+       */
+
+      if (!methodName) {
+
+        throw Error("Method name not specified!");
+      }
+
+      if (!isDefined(this[methodName])) {
+
+        throw Error("Method " + methodName + " doesn't exist!");
+      }
+
+      var args = Array.prototype.slice.apply(arguments, []),
+          params = args.slice(1),
+          method = this[methodName];
+
+      return method.apply(this, params);
+    };
+
+    this.option = function (optionName, param) {
+
+      /*
+       * Method to get/set Options
+       */
+
+      if (!isDefined(optionName)) {
+
+        return options;
+      }
+
+      var method;
+
+      switch (optionName) {
+
+        case "starWidth":
+
+          method = setStarWidth;
+          break;
+        case "numStars":
+
+          method = setNumStars;
+          break;
+        case "normalFill":
+
+          method = setNormalFill;
+          break;
+        case "ratedFill":
+
+          method = setRatedFill;
+          break;
+        case "multiColor":
+
+          method = setMultiColor;
+          break;
+        case "maxValue":
+
+          method = setMaxValue;
+          break;
+        case "precision":
+
+          method = setPrecision;
+          break;
+        case "rating":
+
+          method = setRating;
+          break;
+        case "halfStar":
+
+          method = setHalfStar;
+          break;
+        case "fullStar":
+        
+          method = setFullStar;
+          break;
+        case "readOnly":
+
+          method = setReadOnly;
+          break;
+        case "spacing":
+        
+          method = setSpacing;
+          break;
+        case "onInit":
+          
+          method = setOnInit;
+          break;
+        case "onSet":
+
+          method = setOnSet;
+          break;
+        case "onChange":
+
+          method = setOnChange;
+          break;
+        default:
+
+          throw Error("No such option as " + optionName);
+      }
+
+      return isDefined(param) ? method(param) : options[optionName];
+    };
+
+    function onMouseEnter (e) {
+
+      /*
+       * If the Mouse Pointer is inside the container, calculate and show the rating
+       * in UI
+       */
+
+      var rating = calculateRating(e).toFixed(options.precision);
+
+      var maxValue = options.maxValue;
+
+      rating = checkPrecision(parseFloat(rating), minValue, maxValue);
+
+      showRating(rating);
+
+      $node.trigger("rateyo.change", {rating: rating});
+    }
+
+    function onMouseLeave () {
+
+      /*
+       * If mouse leaves, revert the rating in UI to previously set rating,
+       * when empty value is passed to showRating, it will take the previously set
+       * rating
+       */
+
+      showRating();
+
+      $node.trigger("rateyo.change", {rating: options.rating});
+    }
+
+    function onMouseClick (e) {
+
+      /*
+       * On clicking the mouse inside the container, calculate and set the rating
+       */
+
+      var resultantRating = calculateRating(e).toFixed(options.precision);
+      resultantRating = parseFloat(resultantRating);
+
+      that.rating(resultantRating);
+    }
+    
+    function onInit(e, data) {
+
+      if(options.onInit && typeof options.onInit === "function") {
+        
+        /* jshint validthis:true */
+        options.onInit.apply(this, [data.rating, that]);
+      }
+    }
+
+    function onChange (e, data) {
+
+      if(options.onChange && typeof options.onChange === "function") {
+
+        /* jshint validthis:true */
+        options.onChange.apply(this, [data.rating, that]);
+      }
+    }
+
+    function onSet (e, data) {
+
+      if(options.onSet && typeof options.onSet === "function") {
+
+        /* jshint validthis:true */
+        options.onSet.apply(this, [data.rating, that]);
+      }
+    }
+
+    function bindEvents () {
+
+      $node.on("mousemove", onMouseEnter)
+           .on("mouseenter", onMouseEnter)
+           .on("mouseleave", onMouseLeave)
+           .on("click", onMouseClick)
+           .on("rateyo.init", onInit)
+           .on("rateyo.change", onChange)
+           .on("rateyo.set", onSet);
+    }
+
+    function unbindEvents () {
+
+      $node.off("mousemove", onMouseEnter)
+           .off("mouseenter", onMouseEnter)
+           .off("mouseleave", onMouseLeave)
+           .off("click", onMouseClick)
+           .off("rateyo.init", onInit)
+           .off("rateyo.change", onChange)
+           .off("rateyo.set", onSet);
+    }
+
+    setNumStars(options.numStars);
+    setReadOnly(options.readOnly);
+
+    this.collection.push(this);
+    this.rating(options.rating, true);
+
+    isInitialized = true;
+    $node.trigger("rateyo.init", {rating: options.rating});
+  }
+
+  RateYo.prototype.collection = [];
+
+  function getInstance (node, collection) {
+
+    /* 
+     * Given a HTML element (node) and a collection of RateYo instances,
+     * this function will search through the collection and return the matched
+     * instance having the node
+     */
+
+    var instance;
+
+    $.each(collection, function () {
+
+      if(node === this.node){
+
+        instance = this;
+        return false;
+      }
+    });
+
+    return instance;
+  }
+
+  function deleteInstance (node, collection) {
+
+    /* 
+     * Given a HTML element (node) and a collection of RateYo instances,
+     * this function will search through the collection and delete the
+     * instance having the node, and return the modified collection
+     */
+
+    $.each(collection, function (index) {
+
+      if (node === this.node) {
+
+        var firstPart = collection.slice(0, index),
+            secondPart = collection.slice(index+1, collection.length);
+
+        collection = firstPart.concat(secondPart);
+
+        return false;
+      }
+    });
+
+    return collection;
+  }
+
+  function _rateYo (options) {
+
+    var rateYoInstances = RateYo.prototype.collection;
+
+    /* jshint validthis:true */
+    var $nodes = $(this);
+
+    if($nodes.length === 0) {
+
+      return $nodes;
+    }
+
+    var args = Array.prototype.slice.apply(arguments, []);
+
+    if (args.length === 0) {
+
+      //If args length is 0, Initialize the UI with default settings
+      options = args[0] = {};
+    }else if (args.length === 1 && typeof args[0] === "object") {
+
+      //If an Object is specified as first argument, it is considered as options
+      options = args[0];
+    }else if (args.length >= 1 && typeof args[0] === "string") {
+
+      /*
+       * if there is only one argument, and if its a string, it is supposed to be a
+       * method name, if more than one argument is specified, the remaining arguments
+       * except the first argument, will be passed as a params to the specified method
+       */
+
+      var methodName = args[0],
+          params = args.slice(1);
+
+      var result = [];
+
+      $.each($nodes, function (i, node) {
+
+        var existingInstance = getInstance(node, rateYoInstances);
+
+        if(!existingInstance) {
+
+          throw Error("Trying to set options before even initialization");
+        }
+
+        var method = existingInstance[methodName];
+
+        if (!method) {
+
+          throw Error("Method " + methodName + " does not exist!");
+        }
+
+        var returnVal = method.apply(existingInstance, params);
+
+        result.push(returnVal);
+      });
+
+      /*
+       * If the plugin in being called on only one jQuery Element, return only the
+       * first value, to support chaining.
+       */
+      result = result.length === 1? result[0]: result;
+
+      return result;
+    }else {
+
+      throw Error("Invalid Arguments");
+    }
+
+    /*
+     * if only options are passed, extend default options, and if the plugin is not
+     * initialized on a particular jQuery element, initalize RateYo on it
+     */
+    options = $.extend({}, DEFAULTS, options);
+
+    return $.each($nodes, function () {
+
+               var existingInstance = getInstance(this, rateYoInstances);
+
+               if (!existingInstance) {
+
+                 return new RateYo($(this), $.extend({}, options));
+               }
+           });
+  }
+
+  function rateYo () {
+
+    /* jshint validthis:true */
+    return _rateYo.apply(this, Array.prototype.slice.apply(arguments, []));
+  }
+
+  window.RateYo = RateYo;
+  $.fn.rateYo = rateYo;
+
+}(window.jQuery));

data/app/assets/stylesheets/jquery.rateyo.css

@@ -0,0 +1,37 @@
+.jq-ry-container {
+  position: relative;
+  padding: 0 5px;
+  line-height: 0;
+  display: block;
+  cursor: pointer;
+  -webkit-box-sizing: content-box;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+}
+.jq-ry-container[readonly="readonly"] {
+  cursor: default;
+}
+.jq-ry-container > .jq-ry-group-wrapper {
+  position: relative;
+  width: 100%;
+}
+.jq-ry-container > .jq-ry-group-wrapper > .jq-ry-group {
+  position: relative;
+  line-height: 0;
+  z-index: 10;
+  white-space: nowrap;
+}
+.jq-ry-container > .jq-ry-group-wrapper > .jq-ry-group > svg {
+  display: inline-block;
+}
+.jq-ry-container > .jq-ry-group-wrapper > .jq-ry-group.jq-ry-normal-group {
+  width: 100%;
+}
+.jq-ry-container > .jq-ry-group-wrapper > .jq-ry-group.jq-ry-rated-group {
+  width: 0;
+  z-index: 11;
+  position: absolute;
+  top: 0;
+  left: 0;
+  overflow: hidden;
+}

data/lib/card-rails.rb

@@ -0,0 +1 @@
+require "rateyo/rails"

data/lib/rateyo/rails.rb

@@ -0,0 +1,7 @@
+require "rateyo/rails/version"
+require "rateyo/rails/engine" if ::Rails.version >= '3.1'
+
+module Rateyo
+  module Rails
+  end
+end

data/lib/rateyo/rails/engine.rb

@@ -0,0 +1,6 @@
+module Rateyo
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/rateyo/rails/version.rb

@@ -0,0 +1,5 @@
+module Rateyo
+  module Rails
+    VERSION = '2.1.1'
+  end
+end

data/rateyo-rails.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rateyo/rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rateyo-rails"
+  spec.version       = Rateyo::Rails::VERSION
+  spec.authors       = ["Colin Soleim"]
+  spec.email         = ["colin@brandnewship.com"]
+  spec.summary       = %q{Rails asset pipeline integration for rateyo}
+  spec.description   = %q{rateYo is a simple and flexible jQuery star rating Plugin. This gem allows for its easy inclusion into the rails asset pipeline.}
+  spec.homepage      = "https://github.com/colinsoleim/rateyo-rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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"]
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: rateyo-rails
+version: !ruby/object:Gem::Version
+  version: 2.1.1
+platform: ruby
+authors:
+- Colin Soleim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-15 00:00:00.000000000 Z
+dependencies: []
+description: rateYo is a simple and flexible jQuery star rating Plugin. This gem allows
+  for its easy inclusion into the rails asset pipeline.
+email:
+- colin@brandnewship.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/jquery.rateyo.js
+- app/assets/stylesheets/jquery.rateyo.css
+- lib/card-rails.rb
+- lib/rateyo/rails.rb
+- lib/rateyo/rails/engine.rb
+- lib/rateyo/rails/version.rb
+- rateyo-rails.gemspec
+homepage: https://github.com/colinsoleim/rateyo-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Rails asset pipeline integration for rateyo
+test_files: []