loyal_passport 0.0.1

data/lib/loyal_passport/controllers/custom_failure_app.rb

@@ -0,0 +1,238 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport::Controllers
+  class CustomFailureApp < ::Devise::FailureApp
+
+    def respond
+      if http_auth?
+        http_auth
+      elsif warden_options[:recall]
+        recall
+      else
+        redirect
+      end
+    end
+
+    def http_auth
+      self.status = 401
+      self.headers["WWW-Authenticate"] = %(Basic realm=#{Devise.http_authentication_realm.inspect}) if http_auth_header?
+      self.content_type = request.format.to_s
+      self.response_body = http_auth_body
+    end
+
+    def self.call(env)
+      @respond ||= action(:respond)
+      @respond.(env)
+    end
+
+    def recall
+      env["PATH_INFO"]  = attempted_url
+      flash.now[:alert] = i18n_message(:invalid)
+      self.response = recall_app(warden_options[:recall]).call(env)
+    end
+
+    def redirect
+      # store_location!
+      options = {}
+
+      _redirect_url = redirect_url
+
+      if (return_to = failures_url_return_to) && (return_to != _redirect_url)
+        options[:return_to] = return_to
+      end
+
+      if flash[:timedout] && flash[:alert]
+        flash.keep(:timedout)
+        flash.keep(:alert)
+      else
+        flash[:alert] = i18n_message
+      end
+
+      if options.any?
+        redirect_to "#{_redirect_url}?#{options.to_query}"
+      else
+        redirect_to _redirect_url
+      end
+    end
+
+    protected
+
+    def i18n_message(default = nil)
+      message = warden_message || default || :unauthenticated
+
+      if message.is_a?(Symbol)
+        I18n.t(:"#{scope}.#{message}", :resource_name => scope,
+               :scope => "devise.failure", :default => [message])
+      else
+        message.to_s
+      end
+    end
+
+    #### 登录失败后要跳转的页面 ##################
+    def redirect_url
+      if warden_message == :timeout
+        flash[:timedout] = true
+        attempted_url || scope_url
+      else
+        scope_url
+      end
+    end
+
+    ### 这里写得倒是很妙 #################
+    def context_router
+      send(Devise.available_router_name)
+    end
+
+    def scope_url options={}
+      opts  = {
+        # :host => ::LoyalPassport.config.host
+        :subdomain => ::LoyalPassport.config.subdomain
+      }.merge(
+        options
+      )
+
+      route = :"new_#{scope}_session_url"
+      opts[:format] = request_format unless skip_format?
+
+      config = Rails.application.config
+      opts[:script_name] = (config.relative_url_root if config.respond_to?(:relative_url_root))
+
+      context = context_router
+
+      if context.respond_to?(route)
+        context.send(route, opts)
+      elsif respond_to?(:root_url)
+        root_url(opts)
+      else
+        "/"
+      end
+    end
+
+#    def scope_path
+#      opts  = {}
+#      route = :"new_#{scope}_session_path"
+#      opts[:format] = request_format unless skip_format?
+#
+#      opts[:script_name] = (config.relative_url_root if config.respond_to?(:relative_url_root))
+#
+#      context = send(Devise.available_router_name)
+#
+#      if context.respond_to?(route)
+#        context.send(route, opts)
+#      elsif respond_to?(:root_path)
+#        root_path(opts)
+#      else
+#        "/"
+#      end
+#    end
+
+    def skip_format?
+      %w(html */*).include? request_format.to_s
+    end
+
+    # Choose whether we should respond in a http authentication fashion,
+    # including 401 and optional headers.
+    #
+    # This method allows the user to explicitly disable http authentication
+    # on ajax requests in case they want to redirect on failures instead of
+    # handling the errors on their own. This is useful in case your ajax API
+    # is the same as your public API and uses a format like JSON (so you
+    # cannot mark JSON as a navigational format).
+    def http_auth?
+      if request.xhr?
+        Devise.http_authenticatable_on_xhr
+      else
+        !(request_format && is_navigational_format?)
+      end
+    end
+
+    # It does not make sense to send authenticate headers in ajax requests
+    # or if the user disabled them.
+    def http_auth_header?
+      Devise.mappings[scope].to.http_authenticatable && !request.xhr?
+    end
+
+    def http_auth_body
+      return i18n_message unless request_format
+      method = "to_#{request_format}"
+
+      if method == "to_xml"
+        {
+          :error  => i18n_message,
+          :code   => :unauthorized,
+          :status => self.status,
+          :return_to => request.params[:return_to].to_s
+        }.to_xml(:root => "response")
+      elsif {}.respond_to?(method)
+        {
+          :response => {
+            :error  => i18n_message,
+            :code   => :unauthorized,
+            :status => self.status,
+            :return_to => request.params[:return_to].to_s
+          }
+        }.send(method)
+      else
+        i18n_message
+      end
+    end
+
+    def recall_app(app)
+      controller, action = app.split("#")
+      controller_name  = ActiveSupport::Inflector.camelize(controller)
+      controller_klass = ActiveSupport::Inflector.constantize("#{controller_name}Controller")
+      controller_klass.action(action)
+    end
+
+    def warden
+      env['warden']
+    end
+
+    ####### Warden::Manager.before_failure config ######################
+    def warden_options
+      (env['warden.options'] ||= {})
+    end
+
+    def warden_message
+      @message ||= warden.message || warden_options[:message]
+    end
+
+    def scope
+      @scope ||= warden_options[:scope] || Devise.default_scope
+    end
+
+    def attempted_url
+      warden_options[:attempted_url]
+    end
+
+    def attempted_path
+      warden_options[:attempted_path]
+    end
+
+    # Stores requested uri to redirect the user after signing in. We cannot use
+    # scoped session provided by warden here, since the user is not authenticated
+    # yet, but we still need to store the uri based on scope, so different scopes
+    # would never use the same uri to redirect.
+    def store_location!
+      session["#{scope}_#{:return_to}"] = attempted_url if request.get? && !http_auth?
+    end
+
+    def failures_url_return_to
+      #  get 请求 and 不是 http_auth
+      if request.get? && !http_auth?
+        attempted_url
+      else request.params[:return_to].present?
+        request.params[:return_to]
+      end
+    end
+
+    def is_navigational_format?
+      Devise.navigational_formats.include?(request_format)
+    end
+
+    def request_format
+      @request_format ||= request.format.try(:ref)
+    end
+
+  end
+end
+

data/lib/loyal_passport/controllers/devise_extends.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport::Controllers
+  ### devise 扩展 #####################################
+  module DeviseExtends
+    # 登录完成后跳转的页面
+    def after_sign_in_path_for(resource)
+      if params[:return_to].present?
+        params[:return_to]
+      else
+        loyal_passport_app.users_profile_root_url
+      end
+
+    end
+
+    #### 更新完
+    def after_update_path_for(resource)
+      if params[:return_to].present?
+        params[:return_to]
+      else
+        loyal_passport_app.users_profile_root_url
+      end
+
+    end
+  end
+end
+

data/lib/loyal_passport/controllers/passport_basic.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport::Controllers
+  # 通行证相关的逻辑，用于用户验证，登录，身份以及权限等
+  module PassportBasic
+    def self.included(base)
+      base.class_eval do
+        extend  ClassMethods
+
+        include SharedMethods
+
+        helper  SharedHelperMethods
+
+        include InstanceMethods
+
+        rescue_from ::CanCan::AccessDenied do |exception|
+          # :redirect_to, 'http://www.ruby800.com', :alert => 'Access Denied'
+          # :render, :text => 'Access Denied'
+          # redirect_to root_url, :alert => exception.message
+
+          call_params = ::LoyalPassport.config.resuce_cancan_access_denied_call
+          case call_params[0]
+          when :redirect_to
+            redirect_to call_params[1] || "/", call_params[2] || {}
+          else #### render and else
+            render call_params[1], call_params[2] || {}
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+
+    end
+
+    module SharedMethods
+      # FIXME: 需要更好的写法
+      def loyal_authenticate_admin!
+        authenticate_user!
+        authorize! :manage, :all
+      end
+
+      # 当前用户的ability
+      def current_user_ability
+        @current_user_ability ||= (current_user || User.new).ability
+      end
+
+    end
+
+    module SharedHelperMethods
+      def output_user_image_tag user, options={}
+        image_tag(user.avatar.url(options[:style] || :tiny))
+      end
+
+      # 渲染返回的隐藏域
+      def util_output_return_to_hidden_field_tag value=request.url
+        hidden_field_tag :return_to, params[:return_to] || value, :id => nil
+      end
+    end
+
+    module InstanceMethods
+
+    end
+  end
+end
+

data/lib/loyal_passport/controllers/users_basic.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport::Controllers
+  module UsersBasic
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        include ::LoyalPassport::Controllers::DeviseExtends
+
+        before_filter :init_loyal_passport_request
+
+        layout 'loyal_passport/application'
+
+      end
+    end
+
+    module InstanceMethods
+      def init_loyal_passport_request
+
+      end
+
+      protected
+
+      def devise_parameter_sanitizer
+        if resource_class == ::User
+          ::LoyalPassport::User::ParameterSanitizer.new(::User, :user, params)
+        else
+          super # Use the default one
+        end
+      end
+    end
+  end
+end
+

data/lib/loyal_passport/devise_helper.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport
+  module DeviseHelper
+    def devise_error_messages!
+      return "" if resource.errors.empty?
+      messages = resource.errors.full_messages.map { |msg| content_tag(:li, msg) }.join
+      sentence = I18n.t(
+        "loyal_passport.form.submit",
+        :count => resource.errors.count
+      )
+
+      html = <<-HTML
+    <div class="error-explanation">
+      <h2>#{sentence}</h2>
+      <ul>#{messages}</ul>
+    </div>
+      HTML
+
+      html.html_safe
+    end
+  end
+end

data/lib/loyal_passport/engine.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport
+  class Engine < ::Rails::Engine
+    isolate_namespace LoyalPassport
+
+    config.generators do |g|
+      g.test_framework :rspec, :view_specs => true
+    end
+
+  end
+end

data/lib/loyal_passport/user_parameter_sanitizer.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+class ::LoyalPassport::User::ParameterSanitizer < Devise::ParameterSanitizer
+  def sign_in
+    default_params.permit(*(
+      auth_keys + [
+        :password,
+        :remember_me,
+      ]
+    ))
+  end
+
+  def sign_up
+    default_params.permit(*(auth_keys + [
+      :nick_name, :permalink, :true_name, :captcha, :captcha_key,
+      :password, :password_confirmation, :avatar, :avatar_cache
+    ]))
+  end
+
+  def account_update
+    default_params.permit(*(auth_keys + [
+      :password, :password_confirmation, :current_password, :avatar, :avatar_cache
+    ]))
+  end
+
+end

data/lib/loyal_passport/utils/array_util.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport
+  class ArrayUtil
+    def self.extract_options!(arr)
+      if arr.last.is_a?(Hash)
+        arr.pop
+      else
+        {}
+      end
+    end
+
+    def self.init args
+      args.is_a?(Array) ? args : (args.nil? ? [] : [args])
+    end
+  end
+end

data/lib/loyal_passport/utils/data_util.rb

@@ -0,0 +1,181 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport
+  class DataUtil < ::Hash
+    def initialize(options={})
+      self.merge! options
+    end
+
+    def []=(name, value)
+      super(name.to_sym, value)
+    end
+
+    def to_ary
+    end
+
+    def [](name)
+      super(name.to_sym)
+    end
+
+    def deep_merge(other_hash)
+      self.deep_dup.deep_merge!(other_hash)
+    end
+
+    # 深层的合并
+    def deep_merge!(other_hash)
+      other_hash = self.class.new(other_hash) unless other_hash.is_a?(self.class)
+
+      other_hash.each_pair do |k,v|
+        tv = self[k]
+
+        unless v.is_a?(self.class)
+          v = self.class.new(v) if v.is_a?(Hash)
+        end
+
+        self[k] = tv.is_a?(self.class) && v.is_a?(self.class) ? tv.deep_merge(v) : v
+      end
+
+      self
+    end
+
+    def deep_dup
+      impl_deep_dup self
+    end
+
+    def method_missing method_name, *args, &block
+      # 如果方法是赋值, 则直接赋值
+      if method_name.to_s.end_with?('=')
+        self[method_name.to_s.chop!] = args.first
+      else
+        result = self[method_name.to_sym]
+
+        if result.is_a?(Hash) && !(result.is_a?(self.class))
+          self[method_name] = self.class.new(result)
+        elsif result.nil?
+          self[method_name] = self.class.new
+        else
+          result
+        end
+      end
+    end
+
+    def stringify_keys!
+      impl_stringify_keys! self
+    end
+
+    def symbolize_keys!
+      impl_symbolize_keys! self
+    end
+
+    #
+    # origin_hash_symbolize
+    # origin_hash_stringify
+    # origin_hash_symbolize! key全是 symbol的
+    # origin_hash_stringify! key全市 string 的
+    #
+    [:symbolize, :stringify].each do |method_name|
+      define_method "origin_hash_#{method_name}".to_sym do
+        self.deep_dup.send "origin_hash_#{method_name}!".to_sym
+      end
+
+      define_method "origin_hash_#{method_name}!".to_sym do
+        self.send "impl_origin_hash_#{method_name}".to_sym, self
+      end
+    end
+
+    #
+    # deep_stringify_keys
+    # deep_stringify_keys!
+    #
+    [:stringify, :symbolize].each do |method_name|
+      method_name_impl     = "impl_#{method_name}_keys".to_sym
+      method_name_new_soft = "deep_#{method_name}_keys".to_sym
+      method_name_new      = "deep_#{method_name}_keys!".to_sym
+
+      define_method method_name_new_soft do
+        self.deep_dup.send method_name_new
+      end
+
+      define_method method_name_new do
+        tmp = self.send method_name_impl, self
+
+        tmp.keys.each do |key|
+          tmp[key] = self.send method_name_impl, tmp[key]
+        end
+
+        tmp
+      end
+    end
+
+    private
+
+    def impl_deep_dup v
+      if v.is_a?(::Hash)
+        tv = v.dup
+
+        v.each do |key, value|
+          tv[key] = impl_deep_dup value
+        end
+
+        tv
+      elsif v.is_a?(::Array)
+        v.map do |_v|
+          impl_deep_dup _v
+        end
+      else
+        v
+      end
+    end
+
+    [:stringify, :symbolize].each do |method_name|
+      typify_method = {:symbolize => :to_sym, :stringify => :to_s}[method_name]
+      method_name_new = "impl_origin_hash_#{method_name}".to_sym
+      define_method method_name_new do |v|
+        if v.is_a?(::Hash)
+          tv = Hash.new
+
+          v.keys.each do |key|
+            tv[key.send(typify_method)] = self.send(method_name_new, v[key])
+          end
+
+          tv
+        elsif v.is_a?(::Array)
+          v.map do |_v|
+            self.send(method_name_new, _v)
+          end
+        else
+          v
+        end
+      end
+    end
+
+    [:stringify, :symbolize].each do |method_name|
+      typify_clazz = {:stringify => ::String, :symbolize => ::Hash}[method_name]
+      method_name_new = "impl_#{method_name}_keys".to_sym
+      typify_method = {:symbolize => :to_sym, :stringify => :to_s}[method_name]
+
+      define_method method_name_new do |v|
+        if v.is_a?(Hash)
+          v.keys.each do |key|
+            kv = v.delete key
+
+            unless key.is_a?(typify_clazz)
+              if(kv.is_a?(::Hash) && !(kv.is_a?(self.class)))
+                kv = self.class.new(kv)
+              end
+            end
+
+            v[key.send(typify_method)] = self.send method_name_new, kv
+          end
+        elsif v.is_a?(Array)
+          v = v.map do |_v|
+            self.send method_name_new, _v
+          end
+        end
+
+        v
+      end
+    end
+
+  end
+end
+

data/lib/loyal_passport/utils.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport
+  autoload :DataUtil, 'loyal_passport/utils/data_util'
+  autoload :ArrayUtil, 'loyal_passport/utils/array_util'
+end

data/lib/loyal_passport/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding : utf-8 -*-
+module LoyalPassport
+  VERSION = "0.0.1"
+end

data/lib/loyal_passport.rb

@@ -0,0 +1,30 @@
+# -*- encoding : utf-8 -*-
+require 'loyal_passport/utils'
+require "loyal_passport/engine"
+require "loyal_passport/config"
+require "loyal_passport/acts"
+
+require "loyal_passport/controllers/controller_extends"
+
+module LoyalPassport
+  module Controllers
+    autoload :DeviseExtends,      'loyal_passport/controllers/devise_extends'
+    autoload :PassportBasic,      'loyal_passport/controllers/passport_basic'
+    autoload :CustomFailureApp,   'loyal_passport/controllers/custom_failure_app'
+    autoload :UsersBasic,         'loyal_passport/controllers/users_basic'
+  end
+
+  autoload :DeviseHelper,         'loyal_passport/devise_helper'
+  autoload :UtilHelper,           'loyal_passport/util_helper'
+
+  module User
+    autoload :ParameterSanitizer, 'loyal_passport/user_parameter_sanitizer'
+  end
+end
+
+I18n.load_path += Dir[Pathname.new(__FILE__).join('..', '..', 'config', 'locales', '**', '*.{rb,yml}').to_s]
+
+if defined?(::ActionController::Base)
+  ::ActionController::Base.send :include, ::LoyalPassport::Controllers::PassportBasic
+end
+

data/lib/tasks/loyal_passport_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :loyal_passport do
+#   # Task goes here
+# end