radialIndicator-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b79637f1ddc06f863aa739c48f9a2fbdfe3120d2
+  data.tar.gz: 4706224b09ab5a933605e6340df247a6f9bc3b1f
+SHA512:
+  metadata.gz: a3643c7abf2f7e59017347392687eed4d05ad288588a474b28d6203ebf74058cb302780b85f82b72be38a31e231abb91af96ea8b9ae6df4c05d3c354971db64d
+  data.tar.gz: 5b31f66ff9cea5fb09db9ecfafd76904153c2bcafd0a07c8422822a41bb1908bf9fa793fae162f369108d390d1571d1ed03ce9e242e2b0612ddf68ff575a7b10

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "radialIndicator/rails"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/radialIndicator/rails.rb

@@ -0,0 +1,8 @@
+require "radialIndicator/rails/version"
+
+module RadialIndicator
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/radialIndicator/rails/version.rb

@@ -0,0 +1,5 @@
+module RadialIndicator
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/vendor/assets/javascripts/angular.radialIndicator.js

@@ -0,0 +1,49 @@
+/*
+    radialIndicator.js v 1.2.1
+    Author: Sudhanshu Yadav
+    Copyright (c) 2015 Sudhanshu Yadav - ignitersworld.com , released under the MIT license.
+    Demo on: ignitersworld.com/lab/radialIndicator.html
+*/
+
+/* Angular hook for radialIndicator */
+;
+(function (angular) {
+    angular.module('radialIndicator', []).directive('radialIndicator', ['radialIndicatorInstance',
+
+    function (radialIndicatorInstance) {
+            return {
+                restrict: 'A',
+                link: function (scope, element, attrs) {
+                    var element = element,
+                        id = attrs.radialIndicatorId,
+                        options = scope.$eval(attrs.radialIndicator),
+                        model = attrs.radialIndicatorModel;
+
+                    var indInstance = radialIndicator(element, options);
+
+                    //store indicator instance on radialIndicatorConfig so can get through dependency injection
+                    if (id) radialIndicatorInstance[id] = indInstance;
+
+                    //watch for modal change
+                    scope.$watch(model, function (newValue) {
+                        indInstance.value(newValue);
+                    });
+
+                    //delete the idnicator instance when scope dies
+                    scope.$on('$destroy', function () {
+                        if (id) delete radialIndicatorInstance[id];
+                    });
+
+                }
+            }
+    }])
+    //a factory to store radial indicators instances which can be injected to controllers or directive to get any indicators instance
+    .factory('radialIndicatorInstance', function () {
+        if (!window.radialIndicator) throw "Please include radialIndicator.js";
+
+        var radialIndicatorInstance = {};
+
+        return radialIndicatorInstance;
+
+    });
+}(angular));

data/vendor/assets/javascripts/radialIndicator.js

@@ -0,0 +1,422 @@
+/*
+    radialIndicator.js v 1.2.1
+    Author: Sudhanshu Yadav
+    Copyright (c) 2015 Sudhanshu Yadav - ignitersworld.com , released under the MIT license.
+    Demo on: ignitersworld.com/lab/radialIndicator.html
+*/
+
+;(function($, window, document) {
+    "use strict";
+    //circumfence and quart value to start bar from top
+    var circ = Math.PI * 2,
+        quart = Math.PI / 2;
+
+
+    //function to smooth canvas drawing for ratina devices 
+
+    //method to manage device pixel ratio in ratina devices
+    var smoothCanvas = (function() {
+        var ctx = document.createElement("canvas").getContext("2d"),
+            dpr = window.devicePixelRatio || 1,
+            bsr = ctx.webkitBackingStorePixelRatio ||
+                ctx.mozBackingStorePixelRatio ||
+                ctx.msBackingStorePixelRatio ||
+                ctx.oBackingStorePixelRatio ||
+                ctx.backingStorePixelRatio || 1,
+
+            ratio = dpr / bsr; //PIXEL RATIO
+
+        return function(w, h, canvasElm) {
+            var can = canvasElm || document.createElement("canvas");
+            can.width = w * ratio;
+            can.height = h * ratio;
+            can.style.width = w + "px";
+            can.style.height = h + "px";
+            can.getContext("2d").setTransform(ratio, 0, 0, ratio, 0, 0);
+            return can;
+        }
+    }());
+
+    //function to convert hex to rgb
+    function hexToRgb(hex) {
+        // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+        var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+        hex = hex.replace(shorthandRegex, function(m, r, g, b) {
+            return r + r + g + g + b + b;
+        });
+
+        var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)] : null;
+    }
+
+    function getPropVal(curShift, perShift, bottomRange, topRange) {
+        return Math.round(bottomRange + ((topRange - bottomRange) * curShift / perShift));
+    }
+
+
+    //function to get current color in case of 
+    function getCurrentColor(curPer, bottomVal, topVal, bottomColor, topColor) {
+        var rgbAryTop = topColor.indexOf('#') != -1 ? hexToRgb(topColor) : topColor.match(/\d+/g),
+            rgbAryBottom = bottomColor.indexOf('#') != -1 ? hexToRgb(bottomColor) : bottomColor.match(/\d+/g),
+            perShift = topVal - bottomVal,
+            curShift = curPer - bottomVal;
+
+        if (!rgbAryTop || !rgbAryBottom) return null;
+
+        return 'rgb(' + getPropVal(curShift, perShift, rgbAryBottom[0], rgbAryTop[0]) + ',' + getPropVal(curShift, perShift, rgbAryBottom[1], rgbAryTop[1]) + ',' + getPropVal(curShift, perShift, rgbAryBottom[2], rgbAryTop[2]) + ')';
+    }
+
+    //to merge object
+    function merge() {
+        var arg = arguments,
+            target = arg[0];
+        for (var i = 1, ln = arg.length; i < ln; i++) {
+            var obj = arg[i];
+            for (var k in obj) {
+                if (obj.hasOwnProperty(k)) {
+                    target[k] = obj[k];
+                }
+            }
+        }
+        return target;
+    }
+
+    //function to apply formatting on number depending on parameter
+    function formatter(pattern) {
+        return function(num) {
+            if (!pattern) return num.toString();
+            num = num || 0
+            var numRev = num.toString().split('').reverse(),
+                output = pattern.split("").reverse(),
+                i = 0,
+                lastHashReplaced = 0;
+
+            //changes hash with numbers
+            for (var ln = output.length; i < ln; i++) {
+                if (!numRev.length) break;
+                if (output[i] == "#") {
+                    lastHashReplaced = i;
+                    output[i] = numRev.shift();
+                }
+            }
+
+            //add overflowing numbers before prefix
+            output.splice(lastHashReplaced + 1, output.lastIndexOf('#') - lastHashReplaced, numRev.reverse().join(""));
+
+            return output.reverse().join('');
+        }
+    }
+
+
+    //circle bar class
+    function Indicator(container, indOption) {
+        var self = this;
+
+        indOption = indOption || {};
+        indOption = merge({}, radialIndicator.defaults, indOption);
+
+        this.indOption = indOption;
+
+        //create a queryselector if a selector string is passed in container
+        if (typeof container == "string")
+            container = document.querySelector(container);
+
+        //get the first element if container is a node list
+        if (container.length)
+            container = container[0];
+
+        this.container = container;
+
+        //create a canvas element
+        var canElm = document.createElement("canvas");
+        container.appendChild(canElm);
+
+        this.canElm = canElm; // dom object where drawing will happen
+
+        this.ctx = canElm.getContext('2d'); //get 2d canvas context
+
+        //add intial value 
+        this.current_value = indOption.initValue || indOption.minValue || 0;
+
+
+        //handeling user interaction
+        var startListener = function(e) {
+            if (!indOption.interaction) return;
+
+            var touchMove = e.type == "touchstart" ? "touchmove" : "mousemove",
+                touchEnd = e.type == "touchstart" ? "touchend" : "mouseup",
+                position = canElm.getBoundingClientRect(),
+                cy = position.top + canElm.offsetHeight / 2,
+                cx = position.left + canElm.offsetWidth / 2;
+
+            var moveListener = function(e) {
+                e.preventDefault();
+
+                //get the cordinates
+                var mx = e.clientX || e.touches[0].clientX,
+                    my = e.clientY || e.touches[0].clientY,
+                    radian = (circ + quart + Math.atan2((my - cy), (mx - cx))) % (circ + 0.0175),
+                    radius = (indOption.radius - 1 + indOption.barWidth / 2),
+                    circum = circ * radius,
+                    precision = indOption.precision != null ? indOption.precision : 0,
+                    precisionNo = Math.pow(10, precision),
+                    val = Math.round(precisionNo * radian * radius * (indOption.maxValue - indOption.minValue) / circum) / precisionNo;
+
+                self.value(val);
+            };
+
+            var endListener = function() {
+                document.removeEventListener(touchMove, moveListener, false);
+                document.removeEventListener(touchEnd, endListener, false);
+            };
+
+            document.addEventListener(touchMove, moveListener, false);
+            document.addEventListener(touchEnd, endListener, false);
+        };
+
+        canElm.addEventListener('touchstart', startListener, false);
+        canElm.addEventListener('mousedown', startListener, false);
+
+
+        canElm.addEventListener("mousewheel", MouseWheelHandler, false);
+        canElm.addEventListener("DOMMouseScroll", MouseWheelHandler, false);
+
+        function MouseWheelHandler(e) {
+            if (!indOption.interaction) return;
+            e.preventDefault();
+
+            // cross-browser wheel delta
+            var delta = -(Math.max(-1, Math.min(1, (e.wheelDelta || -e.detail)))),
+                precision = indOption.precision != null ? indOption.precision : 0,
+                precisionNo = Math.pow(10, precision),
+                diff = indOption.maxValue - indOption.minValue,
+                val = self.current_value + Math.round(precisionNo * delta * diff / Math.min(diff, 100)) / precisionNo;
+
+            self.value(val);
+
+            return false;
+        }
+    }
+
+
+    Indicator.prototype = {
+        constructor: radialIndicator,
+        _init: function() {
+            var indOption = this.indOption,
+                canElm = this.canElm,
+                ctx = this.ctx,
+                dim = (indOption.radius + indOption.barWidth) * 2; //elm width and height
+
+            //create a formatter function
+            this.formatter = typeof indOption.format == "function" ? indOption.format : formatter(indOption.format);
+
+            //maximum text length;
+            this.maxLength = indOption.percentage ? 4 : this.formatter(indOption.maxValue).length;
+
+            //smooth the canvas elm for ratina display
+            smoothCanvas(dim, dim, canElm);
+
+            //draw background bar
+            this._drawBarBg();
+
+            //put the initial value if defined
+            this.value(this.current_value);
+
+            return this;
+        },
+        //draw background bar
+        _drawBarBg: function() {
+            var indOption = this.indOption,
+                ctx = this.ctx,
+                dim = (indOption.radius + indOption.barWidth) * 2, //elm width and height
+                center = dim / 2; //center point in both x and y axis
+
+            //draw nackground circle
+            ctx.strokeStyle = indOption.barBgColor; //background circle color
+            ctx.lineWidth = indOption.barWidth;
+            if (indOption.barBgColor != "transparent") {
+                ctx.beginPath();
+                ctx.arc(center, center, indOption.radius - 1 + indOption.barWidth / 2, 0, 2 * Math.PI);
+                ctx.stroke();
+            }
+        },
+        //update the value of indicator without animation
+        value: function(val) {
+            //return the val if val is not provided
+            if (val === undefined || isNaN(val)) {
+                return this.current_value;
+            }
+
+            val = parseFloat(val);
+
+            var ctx = this.ctx,
+                indOption = this.indOption,
+                curColor = indOption.barColor,
+                dim = (indOption.radius + indOption.barWidth) * 2,
+                minVal = indOption.minValue,
+                maxVal = indOption.maxValue,
+                center = dim / 2;
+
+            //limit the val in range of minumum and maximum value
+            val = val < minVal ? minVal : val > maxVal ? maxVal : val;
+
+            var precision = indOption.precision != null ? indOption.precision : 0,
+                precisionNo = Math.pow(10, precision),
+                perVal = Math.round(((val - minVal) * precisionNo / (maxVal - minVal)) * 100) / precisionNo, //percentage value tp two decimal precision
+                dispVal = indOption.percentage ? perVal + '%' : this.formatter(val); //formatted value
+
+            //save val on object
+            this.current_value = val;
+
+
+            //draw the bg circle
+            ctx.clearRect(0, 0, dim, dim);
+            this._drawBarBg();
+
+            //get current color if color range is set
+            if (typeof curColor == "object") {
+                var range = Object.keys(curColor);
+
+                for (var i = 1, ln = range.length; i < ln; i++) {
+                    var bottomVal = range[i - 1],
+                        topVal = range[i],
+                        bottomColor = curColor[bottomVal],
+                        topColor = curColor[topVal],
+                        newColor = val == bottomVal ? bottomColor : val == topVal ? topColor : val > bottomVal && val < topVal ? indOption.interpolate ? getCurrentColor(val, bottomVal, topVal, bottomColor, topColor) : topColor : false;
+
+                    if (newColor != false) {
+                        curColor = newColor;
+                        break;
+                    }
+                }
+            }
+
+            //draw th circle value
+            ctx.strokeStyle = curColor;
+
+            //add linecap if value setted on options
+            if (indOption.roundCorner) ctx.lineCap = "round";
+
+            ctx.beginPath();
+            ctx.arc(center, center, indOption.radius - 1 + indOption.barWidth / 2, -(quart), ((circ) * perVal / 100) - quart, false);
+            ctx.stroke();
+
+            //add percentage text
+            if (indOption.displayNumber) {
+                var cFont = ctx.font.split(' '),
+                    weight = indOption.fontWeight,
+                    fontSize = indOption.fontSize || (dim / (this.maxLength - (Math.floor(this.maxLength * 1.4 / 4) - 1)));
+
+                cFont = indOption.fontFamily || cFont[cFont.length - 1];
+
+                ctx.fillStyle = indOption.fontColor || curColor;
+                ctx.font = weight + " " + fontSize + "px " + cFont;
+                ctx.textAlign = "center";
+                ctx.textBaseline = 'middle';
+                ctx.fillText(dispVal, center, center);
+            }
+
+            //call onChange callback
+            indOption.onChange.call(this.container,val);
+
+            return this;
+        },
+        //animate progressbar to the value
+        animate: function(val) {
+            var indOption = this.indOption,
+                counter = this.current_value || indOption.minValue,
+                self = this,
+                minVal = indOption.minValue,
+                maxVal = indOption.maxValue,
+                frameNum = indOption.frameNum || (indOption.percentage ? 100 : 500),
+                precision = indOption.precision != null ? indOption.precision : Math.ceil(Math.log(maxVal - minVal / frameNum)),
+                precisionNo = Math.pow(10, precision),
+                incBy = Math.round((maxVal - minVal) * precisionNo / frameNum) / precisionNo; //increment by .2% on every tick and 1% if showing as percentage
+
+            //limit the val in range of minumum and maximum value
+            val = val < minVal ? minVal : val > maxVal ? maxVal : val;
+
+            var back = val < counter;
+
+            //clear interval function if already started
+            if (this.intvFunc) clearInterval(this.intvFunc);
+
+            this.intvFunc = setInterval(function() {
+
+                if ((!back && counter >= val) || (back && counter <= val)) {
+                    if (self.current_value == counter) {
+                        clearInterval(self.intvFunc);
+                        if (indOption.onAnimationComplete) indOption.onAnimationComplete(self.current_value);
+                        return;
+                    } else {
+                        counter = val;
+                    }
+                }
+
+                self.value(counter); //dispaly the value
+
+                if (counter != val) {
+                    counter = counter + (back ? -incBy : incBy);
+                }; //increment or decrement till counter does not reach  to value
+            }, indOption.frameTime);
+
+            return this;
+        },
+        //method to update options
+        option: function(key, val) {
+            if (val === undefined) return this.option[key];
+
+            if (['radius', 'barWidth', 'barBgColor', 'format', 'maxValue', 'percentage'].indexOf(key) != -1) {
+                this.indOption[key] = val;
+                this._init().value(this.current_value);
+            }
+            this.indOption[key] = val;
+        }
+
+    };
+
+    /** Initializer function **/
+    function radialIndicator(container, options) {
+        var progObj = new Indicator(container, options);
+        progObj._init();
+        return progObj;
+    }
+
+    //radial indicator defaults
+    radialIndicator.defaults = {
+        radius: 50, //inner radius of indicator
+        barWidth: 5, //bar width
+        barBgColor: '#eeeeee', //unfilled bar color
+        barColor: '#99CC33', //filled bar color , can be a range also having different colors on different value like {0 : "#ccc", 50 : '#333', 100: '#000'}
+        format: null, //format indicator numbers, can be a # formator ex (##,###.##) or a function
+        frameTime: 10, //miliseconds to move from one frame to another
+        frameNum: null, //Defines numbers of frame in indicator, defaults to 100 when showing percentage and 500 for other values
+        fontColor: null, //font color
+        fontFamily: null, //defines font family
+        fontWeight: 'bold', //defines font weight
+        fontSize: null, //define the font size of indicator number
+        interpolate: true, //interpolate color between ranges
+        percentage: false, //show percentage of value
+        precision: null, //default value for precision depend on difference between min and max divided by number of frames
+        displayNumber: true, //display indicator number
+        roundCorner: false, //have round corner in filled bar
+        minValue: 0, //minimum value
+        maxValue: 100, //maximum value
+        initValue: 0, //define initial value of indicator,
+        interaction: false, //if true it allows to change radial indicator value using mouse or touch interaction
+        onChange: function() {}
+    };
+
+    window.radialIndicator = radialIndicator;
+
+    //add as a jquery plugin
+    if ($) {
+        $.fn.radialIndicator = function(options) {
+            return this.each(function() {
+                var newPCObj = radialIndicator(this, options);
+                $.data(this, 'radialIndicator', newPCObj);
+            });
+        };
+    }
+
+}(window.jQuery, window, document, void 0));

data/vendor/assets/javascripts/radialIndicator.min.js

@@ -0,0 +1,7 @@
+/*
+    radialIndicator.js v 1.2.1
+    Author: Sudhanshu Yadav
+    Copyright (c) 2015 Sudhanshu Yadav - ignitersworld.com , released under the MIT license.
+    Demo on: ignitersworld.com/lab/radialIndicator.html
+*/
+!function(t,e,n){"use strict";function i(t){var e=/^#?([a-f\d])([a-f\d])([a-f\d])$/i;t=t.replace(e,function(t,e,n,i){return e+e+n+n+i+i});var n=/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(t);return n?[parseInt(n[1],16),parseInt(n[2],16),parseInt(n[3],16)]:null}function r(t,e,n,i){return Math.round(n+(i-n)*t/e)}function a(t,e,n,a,o){var u=-1!=o.indexOf("#")?i(o):o.match(/\d+/g),l=-1!=a.indexOf("#")?i(a):a.match(/\d+/g),s=n-e,c=t-e;return u&&l?"rgb("+r(c,s,l[0],u[0])+","+r(c,s,l[1],u[1])+","+r(c,s,l[2],u[2])+")":null}function o(){for(var t=arguments,e=t[0],n=1,i=t.length;i>n;n++){var r=t[n];for(var a in r)r.hasOwnProperty(a)&&(e[a]=r[a])}return e}function u(t){return function(e){if(!t)return e.toString();e=e||0;for(var n=e.toString().split("").reverse(),i=t.split("").reverse(),r=0,a=0,o=i.length;o>r&&n.length;r++)"#"==i[r]&&(a=r,i[r]=n.shift());return i.splice(a+1,i.lastIndexOf("#")-a,n.reverse().join("")),i.reverse().join("")}}function l(t,e){function i(t){if(e.interaction){t.preventDefault();var n=-Math.max(-1,Math.min(1,t.wheelDelta||-t.detail)),i=null!=e.precision?e.precision:0,a=Math.pow(10,i),o=e.maxValue-e.minValue,u=r.current_value+Math.round(a*n*o/Math.min(o,100))/a;return r.value(u),!1}}var r=this;e=e||{},e=o({},s.defaults,e),this.indOption=e,"string"==typeof t&&(t=n.querySelector(t)),t.length&&(t=t[0]),this.container=t;var a=n.createElement("canvas");t.appendChild(a),this.canElm=a,this.ctx=a.getContext("2d"),this.current_value=e.initValue||e.minValue||0;var u=function(t){if(e.interaction){var i="touchstart"==t.type?"touchmove":"mousemove",o="touchstart"==t.type?"touchend":"mouseup",u=a.getBoundingClientRect(),l=u.top+a.offsetHeight/2,s=u.left+a.offsetWidth/2,d=function(t){t.preventDefault();var n=t.clientX||t.touches[0].clientX,i=t.clientY||t.touches[0].clientY,a=(c+h+Math.atan2(i-l,n-s))%(c+.0175),o=e.radius-1+e.barWidth/2,u=c*o,d=null!=e.precision?e.precision:0,f=Math.pow(10,d),v=Math.round(f*a*o*(e.maxValue-e.minValue)/u)/f;r.value(v)},f=function(){n.removeEventListener(i,d,!1),n.removeEventListener(o,f,!1)};n.addEventListener(i,d,!1),n.addEventListener(o,f,!1)}};a.addEventListener("touchstart",u,!1),a.addEventListener("mousedown",u,!1),a.addEventListener("mousewheel",i,!1),a.addEventListener("DOMMouseScroll",i,!1)}function s(t,e){var n=new l(t,e);return n._init(),n}var c=2*Math.PI,h=Math.PI/2,d=function(){var t=n.createElement("canvas").getContext("2d"),i=e.devicePixelRatio||1,r=t.webkitBackingStorePixelRatio||t.mozBackingStorePixelRatio||t.msBackingStorePixelRatio||t.oBackingStorePixelRatio||t.backingStorePixelRatio||1,a=i/r;return function(t,e,i){var r=i||n.createElement("canvas");return r.width=t*a,r.height=e*a,r.style.width=t+"px",r.style.height=e+"px",r.getContext("2d").setTransform(a,0,0,a,0,0),r}}();l.prototype={constructor:s,_init:function(){var t=this.indOption,e=this.canElm,n=(this.ctx,2*(t.radius+t.barWidth));return this.formatter="function"==typeof t.format?t.format:u(t.format),this.maxLength=t.percentage?4:this.formatter(t.maxValue).length,d(n,n,e),this._drawBarBg(),this.value(this.current_value),this},_drawBarBg:function(){var t=this.indOption,e=this.ctx,n=2*(t.radius+t.barWidth),i=n/2;e.strokeStyle=t.barBgColor,e.lineWidth=t.barWidth,"transparent"!=t.barBgColor&&(e.beginPath(),e.arc(i,i,t.radius-1+t.barWidth/2,0,2*Math.PI),e.stroke())},value:function(t){if(void 0===t||isNaN(t))return this.current_value;t=parseFloat(t);var e=this.ctx,n=this.indOption,i=n.barColor,r=2*(n.radius+n.barWidth),o=n.minValue,u=n.maxValue,l=r/2;t=o>t?o:t>u?u:t;var s=null!=n.precision?n.precision:0,d=Math.pow(10,s),f=Math.round((t-o)*d/(u-o)*100)/d,v=n.percentage?f+"%":this.formatter(t);if(this.current_value=t,e.clearRect(0,0,r,r),this._drawBarBg(),"object"==typeof i)for(var m=Object.keys(i),p=1,g=m.length;g>p;p++){var x=m[p-1],b=m[p],C=i[x],M=i[b],w=t==x?C:t==b?M:t>x&&b>t?n.interpolate?a(t,x,b,C,M):M:!1;if(0!=w){i=w;break}}if(e.strokeStyle=i,n.roundCorner&&(e.lineCap="round"),e.beginPath(),e.arc(l,l,n.radius-1+n.barWidth/2,-h,c*f/100-h,!1),e.stroke(),n.displayNumber){var y=e.font.split(" "),B=n.fontWeight,V=n.fontSize||r/(this.maxLength-(Math.floor(1.4*this.maxLength/4)-1));y=n.fontFamily||y[y.length-1],e.fillStyle=n.fontColor||i,e.font=B+" "+V+"px "+y,e.textAlign="center",e.textBaseline="middle",e.fillText(v,l,l)}return n.onChange.call(this.container,t),this},animate:function(t){var e=this.indOption,n=this.current_value||e.minValue,i=this,r=e.minValue,a=e.maxValue,o=e.frameNum||(e.percentage?100:500),u=null!=e.precision?e.precision:Math.ceil(Math.log(a-r/o)),l=Math.pow(10,u),s=Math.round((a-r)*l/o)/l;t=r>t?r:t>a?a:t;var c=n>t;return this.intvFunc&&clearInterval(this.intvFunc),this.intvFunc=setInterval(function(){if(!c&&n>=t||c&&t>=n){if(i.current_value==n)return clearInterval(i.intvFunc),void(e.onAnimationComplete&&e.onAnimationComplete(i.current_value));n=t}i.value(n),n!=t&&(n+=c?-s:s)},e.frameTime),this},option:function(t,e){return void 0===e?this.option[t]:(-1!=["radius","barWidth","barBgColor","format","maxValue","percentage"].indexOf(t)&&(this.indOption[t]=e,this._init().value(this.current_value)),void(this.indOption[t]=e))}},s.defaults={radius:50,barWidth:5,barBgColor:"#eeeeee",barColor:"#99CC33",format:null,frameTime:10,frameNum:null,fontColor:null,fontFamily:null,fontWeight:"bold",fontSize:null,interpolate:!0,percentage:!1,precision:null,displayNumber:!0,roundCorner:!1,minValue:0,maxValue:100,initValue:0,interaction:!1,onChange:function(){}},e.radialIndicator=s,t&&(t.fn.radialIndicator=function(e){return this.each(function(){var n=s(this,e);t.data(this,"radialIndicator",n)})})}(window.jQuery,window,document,void 0);

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: radialIndicator-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- xiajian
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 's-yadav''s radialIndicator Rails assets 打包, 是一款轻量级的图形指示器。 '
+email:
+- jhqy2011@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup
+- lib/radialIndicator/rails.rb
+- lib/radialIndicator/rails/version.rb
+- vendor/assets/javascripts/angular.radialIndicator.js
+- vendor/assets/javascripts/radialIndicator.js
+- vendor/assets/javascripts/radialIndicator.min.js
+homepage: https://github.com/xiajian/radialIndicator-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: This is a rails assets gem that packaged s-yadav's radialIndicator(圆形图形指示器)
+test_files: []