oxymoron 1.0.0

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Oxymoron'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/oxymoron/config.js.erb

@@ -0,0 +1,5 @@
+<%= render_oxymoron_assets "config/http.js"%>
+<%= render_oxymoron_assets "config/states.js.erb"%>
+<%= render_oxymoron_assets "config/debug.js.erb"%>
+
+angular.module("oxymoron.config", ['oxymoron.config.http', 'oxymoron.config.states', 'oxymoron.config.debug'])

data/app/assets/javascripts/oxymoron/config/debug.js.erb

@@ -0,0 +1,4 @@
+angular.module("oxymoron.config.debug", [])
+.config(['$compileProvider', function ($compileProvider) {
+  $compileProvider.debugInfoEnabled(<%= Rails.env.development? %>);
+}]);

data/app/assets/javascripts/oxymoron/config/http.js

@@ -0,0 +1,8 @@
+angular.module("oxymoron.config.http", [])
+  .config(['$httpProvider', '$locationProvider', '$stateProvider', function($httpProvider, $locationProvider, $stateProvider) {
+    /*
+     *  Set token for AngularJS ajax methods
+    */
+    $httpProvider.defaults.headers.common['X-Requested-With'] = 'AngularXMLHttpRequest';
+    $httpProvider.defaults.paramSerializer = '$httpParamSerializerJQLike';
+  }])

data/app/assets/javascripts/oxymoron/config/states.js.erb

@@ -0,0 +1,89 @@
+angular.module("oxymoron.config.states", [])
+  .config(['$locationProvider', '$stateProvider', '$urlRouterProvider', function ($locationProvider, $stateProvider, $urlRouterProvider) {
+    /*
+     *  Enable HTML5 History API
+    */
+    $locationProvider.html5Mode(true).hashPrefix('!');
+
+    /*
+     *  $stateProvider Rails
+    */
+    $urlRouterProvider.rule(function($injector, $location) {
+      var path = $location.path();
+      var hasTrailingSlash = path[path.length-1] === '/';
+
+      //for later access in tempalteUrl callback
+      $stateProvider.oxymoron_location = $location;
+
+      if(hasTrailingSlash) {
+        var newPath = path.substr(0, path.length - 1); 
+        return newPath; 
+      }
+    });
+
+    var resolve = function (action, $stateParams) {
+      return function (actionNames, callback) {
+        try {
+          var actionNames = angular.isArray(actionNames) ? actionNames : [actionNames];
+          
+          if (actionNames.indexOf(action)!=-1) {
+            callback($stateParams);
+          }
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    }
+
+    $stateProvider.rails = function () {
+      $stateProvider
+      <% @states.each do |key, value| %>
+        .state('<%= key %>_path', {
+          url: <%= value[:url] %>,
+          templateUrl: function(params) {
+            params['ng-view']='';
+            <% unless value[:cache] %>
+              params['v']=(new Date()).getTime();
+            <% end %>
+
+
+            if ($stateProvider.oxymoron_location) {
+              var query = _.omit($stateProvider.oxymoron_location.search(), _.keys(params));
+              params = angular.extend(query, params); 
+            }
+
+            return Routes['<%= key %>_path'](params);
+          },
+          reloadOnSearch: true,
+          controller: '<%= value[:controller]%>',
+          resolve: {
+            action: ['$stateParams', function ($stateParams) {
+              return resolve('<%= value[:action]%>', $stateParams)
+            }]
+          }
+        })
+      <% end %>
+      return $stateProvider;
+    }
+  }])
+
+  .config(['$provide',
+    function($provide) {
+      $provide.decorator('$state', ['$delegate', function($delegate) {
+        var state = $delegate;
+        state.baseGo = state.go;
+
+        var go = function(to, params, options) {
+          if (state.defaultParams) {
+            var defaultParams = angular.copy(state.defaultParams);
+            params = angular.extend(defaultParams, params);
+          }
+
+          state.baseGo(to, params, options);
+        };
+        state.go = go;
+
+        return $delegate;
+      }]);
+    }
+  ])

data/app/assets/javascripts/oxymoron/directives.js.erb

@@ -0,0 +1,6 @@
+<%= render_oxymoron_assets "directives/content_for.js"%>
+<%= render_oxymoron_assets "directives/fileupload.js"%>
+<%= render_oxymoron_assets "directives/checklist_model.js"%>
+<%= render_oxymoron_assets "directives/click_outside.js"%>
+
+angular.module("oxymoron.directives", ['oxymoron.directives.fileupload', 'oxymoron.directives.contentFor', 'oxymoron.directives.checklistModel', 'oxymoron.directives.clickOutside'])

data/app/assets/javascripts/oxymoron/directives/checklist_model.js

@@ -0,0 +1,141 @@
+angular.module("oxymoron.directives.checklistModel", [])
+  .directive('checklistModel', ['$parse', '$compile', function($parse, $compile) {
+    // contains
+    function contains(arr, item, comparator) {
+      if (angular.isArray(arr)) {
+        for (var i = arr.length; i--;) {
+          if (comparator(arr[i], item)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    // add
+    function add(arr, item, comparator) {
+      arr = angular.isArray(arr) ? arr : [];
+        if(!contains(arr, item, comparator)) {
+            arr.push(item);
+        }
+      return arr;
+    }  
+
+    // remove
+    function remove(arr, item, comparator) {
+      if (angular.isArray(arr)) {
+        for (var i = arr.length; i--;) {
+          if (comparator(arr[i], item)) {
+            arr.splice(i, 1);
+            break;
+          }
+        }
+      }
+      return arr;
+    }
+
+    // http://stackoverflow.com/a/19228302/1458162
+    function postLinkFn(scope, elem, attrs) {
+       // exclude recursion, but still keep the model
+      var checklistModel = attrs.checklistModel;
+      attrs.$set("checklistModel", null);
+      // compile with `ng-model` pointing to `checked`
+      $compile(elem)(scope);
+      attrs.$set("checklistModel", checklistModel);
+
+      // getter / setter for original model
+      var getter = $parse(checklistModel);
+      var setter = getter.assign;
+      var checklistChange = $parse(attrs.checklistChange);
+      var checklistBeforeChange = $parse(attrs.checklistBeforeChange);
+
+      // value added to list
+      var value = attrs.checklistValue ? $parse(attrs.checklistValue)(scope.$parent) : attrs.value;
+
+
+      var comparator = angular.equals;
+
+      if (attrs.hasOwnProperty('checklistComparator')){
+        if (attrs.checklistComparator[0] == '.') {
+          var comparatorExpression = attrs.checklistComparator.substring(1);
+          comparator = function (a, b) {
+            return a[comparatorExpression] === b[comparatorExpression];
+          };
+          
+        } else {
+          comparator = $parse(attrs.checklistComparator)(scope.$parent);
+        }
+      }
+
+      // watch UI checked change
+      scope.$watch(attrs.ngModel, function(newValue, oldValue) {
+        if (newValue === oldValue) { 
+          return;
+        } 
+
+        if (checklistBeforeChange && (checklistBeforeChange(scope) === false)) {
+          scope[attrs.ngModel] = contains(getter(scope.$parent), value, comparator);
+          return;
+        }
+
+        setValueInChecklistModel(value, newValue);
+
+        if (checklistChange) {
+          checklistChange(scope);
+        }
+      });
+
+      function setValueInChecklistModel(value, checked) {
+        var current = getter(scope.$parent);
+        if (angular.isFunction(setter)) {
+          if (checked === true) {
+            setter(scope.$parent, add(current, value, comparator));
+          } else {
+            setter(scope.$parent, remove(current, value, comparator));
+          }
+        }
+        
+      }
+
+      // declare one function to be used for both $watch functions
+      function setChecked(newArr, oldArr) {
+        if (checklistBeforeChange && (checklistBeforeChange(scope) === false)) {
+          setValueInChecklistModel(value, scope[attrs.ngModel]);
+          return;
+        }
+        scope[attrs.ngModel] = contains(newArr, value, comparator);
+      }
+
+      // watch original model change
+      // use the faster $watchCollection method if it's available
+      if (angular.isFunction(scope.$parent.$watchCollection)) {
+          scope.$parent.$watchCollection(checklistModel, setChecked);
+      } else {
+          scope.$parent.$watch(checklistModel, setChecked, true);
+      }
+    }
+
+    return {
+      restrict: 'A',
+      priority: 1000,
+      terminal: true,
+      scope: true,
+      compile: function(tElement, tAttrs) {
+        if ((tElement[0].tagName !== 'INPUT' || tAttrs.type !== 'checkbox') && (tElement[0].tagName !== 'MD-CHECKBOX') && (!tAttrs.btnCheckbox)) {
+          throw 'checklist-model should be applied to `input[type="checkbox"]` or `md-checkbox`.';
+        }
+
+        if (!tAttrs.checklistValue && !tAttrs.value) {
+          throw 'You should provide `value` or `checklist-value`.';
+        }
+
+        // by default ngModel is 'checked', so we set it if not specified
+        if (!tAttrs.ngModel) {
+          // local scope var storing individual checkbox model
+          tAttrs.$set("ngModel", "checked");
+        }
+
+        return postLinkFn;
+      }
+    };
+  }]);

data/app/assets/javascripts/oxymoron/directives/click_outside.js

@@ -0,0 +1,25 @@
+angular.module("oxymoron.directives.clickOutside", [])
+  .directive('clickOutside', ['$document', function ($document) {
+    return {
+      restrict: 'A',
+      scope: {
+        clickOutside: '&',
+        clickOutsideIf: '='
+      },
+      link: function (scope, el, attr) {
+        var handler = function (e) {
+          if (scope.clickOutsideIf && el !== e.target && !el[0].contains(e.target) && document.body.contains(e.target)) {
+            scope.$apply(function () {
+                scope.$eval(scope.clickOutside);
+            });
+          }
+        }
+
+        $document.bind('click', handler);
+
+        scope.$on('$destroy', function () {
+          $document.unbind('click', handler)
+        })
+      }
+    }
+  }])

data/app/assets/javascripts/oxymoron/directives/content_for.js

@@ -0,0 +1,24 @@
+angular.module("oxymoron.directives.contentFor", [])
+  .directive("contentFor", [
+    "$compile", function($compile) {
+      return {
+        compile: function(el, attrs, transclude) {
+          var template = el.html();
+
+          return {
+            pre: function(scope, iElement, iAttrs, controller) {
+              var DOMElements = angular.element(document.querySelectorAll('[ng-yield="'+iAttrs.contentFor+'"]'));
+              if (DOMElements.attr("only-text") == "true") {
+                template = el.text().replace(/(?:\r\n|\r|\n)/g, ' ');
+              }
+              DOMElements.html((DOMElements.attr("prefix") || "") + template + (DOMElements.attr("postfix") || ""))
+              $compile(DOMElements)(scope);
+
+              
+              return iElement.remove();
+            }
+          };
+        }
+      };
+    }
+  ])

data/app/assets/javascripts/oxymoron/directives/fileupload.js

@@ -0,0 +1,68 @@
+angular.module("oxymoron.directives.fileupload", [])
+  .directive('fileupload', ['$http', '$timeout', '$cookies', function ($http, $timeout, $cookies) {
+    return {
+      scope: {
+        fileupload: "=",
+        ngModel: "=",
+        hash: "=",
+        percentCompleted: "="
+      },
+      restrict: 'A',
+      link: function($scope, element, attrs) {
+        $scope.percentCompleted = undefined;
+
+        element.bind('change', function(){
+          var fd = new FormData();
+
+          angular.forEach(element[0].files, function (file) {
+            fd.append("attachments[]", file);
+          })
+
+          var xhr = new XMLHttpRequest;
+
+          xhr.upload.onprogress = function(e) {
+              // Event listener for when the file is uploading
+              $scope.$apply(function() {
+                  var percentCompleted;
+                  if (e.lengthComputable) {
+                      $scope.percentCompleted = Math.round(e.loaded / e.total * 100);
+                  }
+              });
+          };
+
+          xhr.onload = function() {
+              var res = JSON.parse(this.responseText)
+
+              $scope.$apply(function() {
+                if (!$scope.hash) {
+                  if (attrs.multiple) {
+                    $scope.ngModel = $scope.ngModel || [];
+                    angular.forEach(res, function (attachment) {
+                      $scope.ngModel.push(attachment);
+                    });
+                  } else {
+                    $scope.ngModel = res[0];
+                  }
+                } else {
+                  $scope.ngModel = $scope.ngModel || {};
+                  angular.forEach(res, function(value, key) {
+                    $scope.ngModel[key] = $scope.ngModel[key] || [];
+                    angular.forEach(value, function (attachment) {
+                      $scope.ngModel[key].push(attachment);
+                    });
+                  });
+                }
+
+                $scope.percentCompleted = undefined;
+              });
+          };
+
+
+          xhr.open('POST', $scope.fileupload);
+          xhr.setRequestHeader('X-XSRF-Token', $cookies.get('XSRF-TOKEN'));
+          xhr.send(fd);
+          element[0].value = '';
+        })
+      }
+    }
+  }])

data/app/assets/javascripts/oxymoron/notifier.js.erb

@@ -0,0 +1,39 @@
+angular.module("oxymoron.notifier", [])
+  .run(['$rootScope', 'ngNotify', 'Validate', '$state', '$http', '$location', function ($rootScope, ngNotify, Validate, $state, $http, $location) {
+    ngNotify.config({
+        theme: 'pure',
+        position: 'top',
+        duration: 2000,
+        type: 'info'
+    });
+
+    $rootScope.$on('loading:finish', function (h, res) {
+      callback('success', res)
+    })
+
+    $rootScope.$on('loading:error', function (h, res, p) {
+      callback('error', res)
+    })
+
+    function callback (type, res) {
+      if (res.data && angular.isObject(res.data)) {
+        if (res.data.msg) {
+          ngNotify.set(res.data.msg, type);
+        }
+
+        if (res.data.errors) {
+          Validate(res.data.form_name || res.config.data.form_name, res.data.errors)
+        }
+
+        if (res.data.redirect_to_url) {
+          $location.url(res.data.redirect_to_url);
+        } else if (res.data.redirect_to) {
+          $state.go(res.data.redirect_to, res.data.redirect_options || {});
+        }
+
+        if (res.data.reload) {
+          window.location.reload();
+        }
+      }
+    }
+  }])