oxymoron 1.0.0

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

@@ -0,0 +1,11 @@
+(function() {
+  <%= render_oxymoron_assets "config.js.erb"%>
+  <%= render_oxymoron_assets "services.js.erb"%>
+  <%= render_oxymoron_assets "directives.js.erb"%>
+  <%= render_oxymoron_assets "notifier.js.erb"%>
+
+  angular.module('oxymoron', ['ngNotify', 'ui.router', 'ngResource', 'oxymoron.directives', 'oxymoron.services', 'oxymoron.config', 'oxymoron.notifier'])
+
+}).call(this);
+
+<%= render_oxymoron_assets "routes.js.erb"%>

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

@@ -0,0 +1,66 @@
+(function () {
+  var Routes = function () {
+    var self = this,
+        routes = <%= @routes.to_json %>;
+
+    self.defaultParams = {}
+
+    var serialize = function(obj, prefix) {
+      var str = [];
+      for(var p in obj) {
+        if (obj.hasOwnProperty(p)) {
+          var k = prefix ? prefix + "[" + p + "]" : p, v = obj[p];
+          str.push(typeof v == "object" ?
+            serialize(v, k) :
+            encodeURIComponent(k) + "=" + encodeURIComponent(v));
+        }
+      }
+      return str.join("&");
+    }
+
+    var omit = function (hash, key) {
+      var hash = angular.copy(hash);
+      delete hash[key]
+      return hash
+    }
+
+
+    angular.forEach(routes, function (val, key) {
+      var result = '';
+
+      var gsub = function(params) {
+        if (params.format) {
+          result += '.' + params.format
+        }
+
+        var params = omit(params, 'format');
+        angular.forEach(params, function (v, k) {
+          var subst = ':' + k;
+          if (result.search(subst) != -1) {
+            result = result.replace(subst, v);
+            params = omit(params, k);
+          }
+        })
+        
+        if (Object.keys(params).length)
+          result += '?'+serialize(params)
+
+        return result;
+      }
+
+      self[key+'_path'] = function (params) {
+        var params = angular.extend(angular.copy(val.defaults), params || {});
+        result = val.path;
+        var defaultParams = angular.copy(self.defaultParams);
+        return gsub(angular.extend(defaultParams, params));
+      }
+
+      self[key+'_url'] = function (params) {
+        return window.location.origin + self[key+'_path'](params)
+      }
+    })
+  }
+
+  window.Routes = new Routes();
+
+}).call(this)

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

@@ -0,0 +1,6 @@
+<%= render_oxymoron_assets "services/interceptor.js"%>
+<%= render_oxymoron_assets "services/resources.js.erb"%>
+<%= render_oxymoron_assets "services/sign.js"%>
+<%= render_oxymoron_assets "services/validate.js"%>
+
+angular.module("oxymoron.services", ["oxymoron.services.interceptor", "oxymoron.services.resources", "oxymoron.services.sign", "oxymoron.services.validate"])

data/app/assets/javascripts/oxymoron/services/interceptor.js

@@ -0,0 +1,20 @@
+angular.module("oxymoron.services.interceptor", [])
+  .factory('httpInterceptor', ['$q', '$rootScope', '$log', function ($q, $rootScope, $log) {
+    return {
+      request: function (config) {
+        $rootScope.$broadcast('loading:progress');
+        return config || $q.when(config);
+      },
+      response: function (response) {
+        $rootScope.$broadcast('loading:finish', response);
+        return response || $q.when(response);
+      },
+      responseError: function (response) {
+        $rootScope.$broadcast('loading:error', response);
+        return $q.reject(response);
+      }
+    };
+  }])
+  .config(['$httpProvider', function ($httpProvider) {
+    $httpProvider.interceptors.push('httpInterceptor');
+  }])

data/app/assets/javascripts/oxymoron/services/resources.js.erb

@@ -0,0 +1,12 @@
+angular.module("oxymoron.services.resources", [])
+  .factory('resourceDecorator', [function () {
+    return function(resource) {
+      return resource;
+    };
+  }])
+
+  <% @resources.each do |key, value| %>
+    .factory('<%= key %>', ['$resource', 'resourceDecorator', function ($resource, resourceDecorator) {
+      return resourceDecorator($resource('<%= value[:url] %>.json', <%= value[:default_params].to_json%>, <%= value[:actions].to_json %>));
+    }])
+  <% end %>

data/app/assets/javascripts/oxymoron/services/sign.js

@@ -0,0 +1,25 @@
+angular.module("oxymoron.services.sign", [])
+  .service('Sign', ['$http', function ($http) {
+    var Sign = this;
+
+    Sign.out = function () {
+      $http.delete(Routes.destroy_user_session_path())
+        .success(function () {
+          window.location = "/";
+        })
+    }
+
+    Sign.in = function (form) {
+      $http.post(Routes.user_session_path(), {user: form})
+        .success(function () {
+          window.location.reload();
+        })
+    }
+
+    Sign.up = function (form) {
+      $http.post(Routes.user_registration_path(), {user: form})
+        .success(function () {
+          window.location.reload();
+        })
+    }
+  }])

data/app/assets/javascripts/oxymoron/services/validate.js

@@ -0,0 +1,41 @@
+angular.module("oxymoron.services.validate", [])
+  .factory('Validate', [function(){
+    return function (form, errors){
+      try {
+        var $form = angular.element(document.querySelector('[name="'+form+'"]')).scope()[form];
+      } catch(e) {
+        var $form = {};
+      }
+
+      angular
+        .element(document.querySelectorAll('.rails-errors')).remove();
+
+      angular.forEach($form, function(ctrl, name) {
+        if (name.indexOf('$') != 0) {
+          angular.forEach(ctrl.$error, function(value, name) {
+            ctrl.$setValidity(name, null);
+          });
+        }
+      });
+
+
+      angular.forEach(errors, function(errors_array, key) {
+        var form_key = form+'['+key+']';
+        try {
+          if ($form[form_key]) {
+            $form[form_key].$setTouched();
+            $form[form_key].$setDirty();
+            $form[form_key].$setValidity('server', false);
+          }
+          
+          angular
+            .element(document.querySelector('[name="'+form_key+'"]'))
+            .parent()
+            .append('<div class="rails-errors" ng-messages="'+form_key+'.$error"><div ng-message="server">'+errors_array[0]+'</div></div>')
+        } catch(e) {
+          console.log(e)
+          console.warn('Element with name ' + form_key + ' not found for validation.')
+        }
+      });
+    };
+  }])

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

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

data/app/helpers/form_helper.rb

@@ -0,0 +1,35 @@
+module FormHelper
+  def form_for(record, options = {}, &block)
+    raise ArgumentError, "Missing block" unless block_given?
+    options[:html] ||= {}
+    html_options = options[:html].with_indifferent_access
+
+    case record
+    when String, Symbol
+      object_name = record
+      object      = nil
+    else
+      object      = record.is_a?(Array) ? record.last : record
+      raise ArgumentError, "First argument in form cannot contain nil or be empty" unless object
+      object_name = options[:as] || model_name_from_record_or_class(object).param_key
+      apply_form_for_options!(record, object, options)
+    end
+
+    html_options[:data]   = options.delete(:data)   if options.has_key?(:data)
+    html_options[:remote] = options.delete(:remote) if options.has_key?(:remote)
+    html_options[:method] = options.delete(:method) if options.has_key?(:method)
+    html_options[:enforce_utf8] = options.delete(:enforce_utf8) if options.has_key?(:enforce_utf8)
+    html_options[:authenticity_token] = options.delete(:authenticity_token)
+
+    builder = instantiate_builder(object_name, object, options)
+    output  = capture(builder, &block)
+    html_options[:multipart] ||= builder.multipart?
+    prefix = html_options["ng-submit-prefix"] || 'ctrl'
+    html_options["ng-submit"] ||= "formQuery = #{prefix}.save({form_name: '#{object_name}', id: #{prefix}.#{object_name}.id, #{object_name}: #{prefix}.#{object_name}}); $event.preventDefault();"
+
+    html_options[:name] ||= object_name
+
+    html_options = html_options_for_form(options[:url] || {}, html_options)
+    form_tag_with_body(html_options, output)
+  end
+end

data/app/helpers/oxymoron_form_builder.rb

@@ -0,0 +1,81 @@
+class OxymoronFormBuilder < ActionView::Helpers::FormBuilder
+  (field_helpers - [:label, :check_box, :radio_button, :fields_for, :hidden_field, :file_field]).each do |selector|
+    class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      def #{selector}(method, options = {})  # def text_field(method, options = {})
+        options['ng-model'] = compute_ng_model(method, options)
+        @template.send(                      #   @template.send(
+          #{selector.inspect},               #     "text_field",
+          @object_name,                      #     @object_name,
+          method,                            #     method,
+          objectify_options(options))        #     objectify_options(options))
+      end                                    # end
+    RUBY_EVAL
+  end
+
+  def radio_button method, tag_value, options = {}
+    options['ng-model'] = compute_ng_model(method, options)
+    super
+  end
+
+  def check_box method, options = {}, checked_value = "1", unchecked_value = "0"
+    options['ng-model'] = compute_ng_model(method, options)
+    super
+  end
+
+  def select method, choices = nil, options = {}, html_options = {}, &block
+    html_options['ng-model'] = compute_ng_model(method, html_options)
+    super
+  end
+
+  def file_field method, options = {}
+    options = options.with_indifferent_access
+    options = options.merge({
+      "ng-model" => compute_ng_model(method, options),
+      "onchange" => options["onchange"] || "angular.element(this).scope().#{compute_ng_model(method, options)} = this.files[0]; angular.element(this).scope().$apply();"
+    })
+    super
+  end
+
+  def ng_select method, options = {}
+    options = options.with_indifferent_access
+    options = options.merge({
+      "name" => "#{@object_name}[#{method}]",
+      "ng-model" => compute_ng_model(method, options),
+      "ng-options" => options["ng-options"] || "#{method}.#{options[:value_method]} as #{method}.#{options[:title_method]} for #{method} in #{options[:collection]}"
+    })
+
+    content_tag(:select, nil, options)
+  end
+
+  def ng_select2 method, options = {}
+    options = options.with_indifferent_access
+    options = options.merge({
+      "name" => "#{@object_name}[#{method}]",
+      "ng-model" => compute_ng_model(method, options),
+      "s2-options" => options["s2-options"] || "#{method}.#{options[:value_method]} as #{method}.#{options[:title_method]} for #{method} in #{options[:collection]}"
+    })
+
+    content_tag(:select2, nil, options)
+  end
+
+
+
+  protected
+    def ng_model method = nil
+      object_name = @object_name.to_s.gsub(/\[([\w]+)\]/, "['\\1']")
+      object_name.gsub!(/'(#{@options[:child_index]})'/, "\\1") if @options[:child_index]
+      prefix = @options[:prefix] || 'ctrl' rescue "ctrl"
+
+      if method
+        "#{prefix}.#{object_name}['#{method}']".html_safe
+      else
+        "#{prefix}.#{object_name}".html_safe
+      end
+    end
+
+    def compute_ng_model method, options
+      options = options.with_indifferent_access
+      options['ng-model'] || ng_model(options[:field] || (options[:multiple] ? "#{method}_ids" : method))
+    end
+
+end

data/lib/oxymoron.rb

@@ -0,0 +1,123 @@
+if defined?(::Rails)
+  require "oxymoron/engine"
+end
+
+module Oxymoron
+  class Oxymoron
+
+    def initialize
+      Rails.application.reload_routes!
+      @routes, @states, @resources = {}, {}, {}
+      
+      @app_routes = Rails.application.routes.routes.select{|route| route.name.present? && route.constraints[:request_method]}
+      @app_routes_by_controller = @app_routes.select{|route| ['new', 'edit', 'show', 'index'].exclude?(route.defaults[:action])}.group_by{|route| route.defaults[:controller]}.delete_if {|k,v| k.nil?}
+      
+      @app_routes.each do |route|
+        set_routes route
+        set_states route
+        set_resources route
+      end
+    end
+
+    def set_routes route
+      @routes[route.name] = {
+        defaults: (route.defaults[:params] || {}),
+        path: route.path.spec.to_s.gsub('(.:format)', '')
+      }
+
+      return @routes
+    end
+
+    def set_states route
+      if route.constraints[:request_method].match("GET")
+        path = route.path.spec.to_s.gsub('(.:format)', '')
+        url_matcher = "'#{path}'"
+
+        route.path.required_names.each do |required_name|
+          if requirement = route.requirements[required_name.to_sym]
+            if requirement.is_a? Regexp
+              requirement = requirement.to_s[7..-2]
+            end
+            url_matcher = path.gsub(':'+required_name, "{#{required_name}:(?:#{requirement})}")
+            url_matcher = "$urlMatcherFactoryProvider.compile(\"#{url_matcher}\")"
+          end
+        end
+
+        @states[route.name] = {
+          url: url_matcher,
+          templateUrl: path,
+          cache: route.defaults[:cache] === false ? false : true
+        }
+        
+        if route.defaults[:controller]
+          @states[route.name][:controller] = "#{route.defaults[:controller].camelize.gsub('::', '')}Ctrl as ctrl"
+          @states[route.name][:action] = route.defaults[:action]
+        end
+      end
+
+      return @states
+    end
+
+    def set_resources route
+      if route.defaults[:action] == 'show'
+        path = route.path.spec.to_s.gsub('(.:format)', '')
+        @resources[route.name.camelize] = {
+          url: path,
+          default_params: Hash[route.path.required_names.map{|name| [name, '@'+name]}]
+        }
+
+        for_hash = {
+          'new'     => {method: 'GET', url: "#{path}/new.json" },
+          'edit'    => {method: 'GET', url: "#{path}/edit.json"},
+          'update'  => {method: 'PUT'},
+          'create'  => {method: 'POST'},
+          'destroy' => {method: 'DELETE'}
+        }
+
+        if route_by_controller = @app_routes_by_controller[route.defaults[:controller]]
+          @app_routes_by_controller[route.defaults[:controller]].each do |route|
+
+            base_path = path.gsub(/:(\w)+/, '').gsub(/\(.*$/, '').gsub('//', '/')
+            current_route_path = route.path.spec.to_s.gsub(/:(\w)+/, '').gsub(/\(.*$/, '').gsub('//', '/')
+
+            if (current_route_path.start_with?(base_path))
+              for_hash[route.defaults[:action]] ||= {
+                url: route.path.spec.to_s.gsub('(.:format)', '.json'),
+                isArray: route.defaults[:is_array],
+                method: /GET|POST|PUT|PATCH|DELETE/.match(route.constraints[:request_method].to_s).to_s
+              }
+            end
+            
+          end
+        end
+        
+        @resources[route.name.camelize][:actions] = for_hash
+      end
+
+      return @resources
+    end
+
+    def generate file
+      template = ERB.new File.new(File.expand_path("../../app/assets/javascripts/oxymoron/#{file}", __FILE__)).read, nil, "%"
+
+      if Rails.env.production?
+        return Uglifier.new.compile(template.result(binding))
+      else
+        return template.result(binding)
+      end
+    end
+
+    def render_oxymoron_assets asset_name
+      html = File.open("#{Gem.loaded_specs['oxymoron'].full_gem_path}/app/assets/javascripts/oxymoron/#{asset_name}").read
+      template = ERB.new(html, nil, "%")
+      template.result(binding)
+    end
+
+    class << self
+      def generate file
+        Oxymoron.new.generate file
+      end
+    end
+  end
+
+end

data/lib/oxymoron/concern.rb

@@ -0,0 +1,21 @@
+module Oxymoron
+  module Concern
+    extend ActiveSupport::Concern
+
+    included do
+      before_filter :set_xsrf_token_cookie
+    end
+
+    def set_xsrf_token_cookie
+      cookies['XSRF-TOKEN'] = form_authenticity_token if protect_against_forgery?
+    end
+
+    def verified_request?
+      if respond_to?(:valid_authenticity_token?, true)
+        super || valid_authenticity_token?(session, request.headers['X-XSRF-TOKEN'])
+      else
+        super || form_authenticity_token == request.headers['X-XSRF-TOKEN']
+      end
+    end
+  end
+end