adva 0.1.4 → 0.2.0

data/lib/action_controller/authenticate_anonymous.rb

@@ -1,69 +0,0 @@
-# Auto-registers and re-authenticates anonymous users based on a single token
-# that's stored in the session. This is for anonymous posting of blog comments,
-# editing wikipages etc. and allows to do such things as:
-#
-# * store user information in the user table (which keeps the model and db
-#   structure clean) and
-# * allow users to (e.g.) edit their comment based on this anonymous login.
-
-module ActionController
-  module AuthenticateAnonymous
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def authenticates_anonymous_user
-        return if authenticates_anonymous_user?
-        include InstanceMethods
-        prepend Module.new {
-          def current_user
-            @current_user ||= (super || login_or_register_anonymous)
-          end
-
-          def authenticated?
-            !!current_user and !current_user.anonymous?
-          end
-        }
-      end
-
-      def authenticates_anonymous_user?
-        included_modules.include? InstanceMethods
-      end
-    end
-
-    module InstanceMethods
-      def login_or_register_anonymous
-        anonymous = try_login_anonymous || User.anonymous
-        anonymous = register_or_update_anonymous anonymous if params[:user]
-        login_anonymous! anonymous if anonymous
-        anonymous
-      end
-
-      def try_login_anonymous
-        # try to authenticate if token is present
-        validate_token User, session[:anonymous_token] if session[:anonymous_token]
-      end
-
-      def register_or_update_anonymous(anonymous)
-        # if :name and :email params are passed either register a new Anonymous or update the existing one
-        anonymous.update params[:user].merge(request_info)
-        anonymous
-      end
-
-      def login_anonymous!(anonymous)
-        # set a new session token and expiration
-        token = anonymous.assign_token('anonymous', 3.hour.from_now)
-        anonymous.save
-        session[:anonymous_token] = "#{anonymous.id};#{token}"
-        cookies[:aid] = anonymous.id.to_s unless anonymous.new_record?
-      end
-
-      def request_info
-        { :ip      => request.env["REMOTE_ADDR"],
-          :agent   => request.env["HTTP_USER_AGENT"],
-          :referer => request.env["HTTP_REFERER"] }
-      end
-    end
-  end
-end

data/lib/action_controller/authenticate_user.rb

@@ -1,203 +0,0 @@
-module ActionController
-
-  # Module automatically mixed into the all controllers making the
-  # application of authentication easy. See
-  # Login::ControllerIntegration::ClassMethods for how to apply
-  # authentication.
-  module AuthenticateUser
-    def self.included(target)
-      target.extend(ClassMethods)
-      target.send(:include, InstanceMethods)
-      target.helper_method(:logged_in?, :authenticated?)
-    end
-
-    # Methods available as macro-style methods on any controller
-    module ClassMethods
-
-      # Sets up the controller so that authentication is required. If
-      # the user is not authenticated then they will be redirected to
-      # the login screen.
-      #
-      # The page requested will be saved so that once the login has
-      # occured they will be sent back to the page they first
-      # requested. If no page was requested (they went to the login
-      # page directly) then they will be directed to profiles/home
-      # after login which is a placeholder for the app to override.
-      #
-      # Options given are passed directly to the before_action method
-      # so feel free to provide :only and :except options.
-      def authentication_required
-        before_action :require_authentication
-      end
-
-      # Will remove authentication from certain actions. Options given
-      # are passed directly to skip_before_action so feel free to use
-      # :only and :except options.
-      #
-      # This method is useful in cases where you have locked down the
-      # entire application by putting authentication_required in your
-      # ApplicationController but then want to open an action back up
-      # in a specific controller.
-      def no_authentication_required
-        skip_before_action :require_authentication
-      end
-    end
-
-    # Methods callable from within actions
-    module InstanceMethods
-      def authenticate_user(credentials)
-        User.authenticate(credentials).tap do |user|
-          if user
-            # prevent session hijacking - unnecessary according to http://dev.rubyonrails.org/ticket/10108
-            # reset_session_except :return_location
-            session[:uid] = user.id
-            set_user_cookie!(user)
-          end
-        end
-      end
-
-      # Will retrieve the current_user. Will not force a login but
-      # simply load the current user if a person is logged in. If
-      # you need the user object loaded with extra options (such as
-      # eager loading) then create a private method called
-      # "user_find_options" on your controller that returns a hash
-      # of the find options you want.
-      #
-      # This method will also inform the models of the current user
-      # if the current user is logged in and the "User" class responds
-      # to the class method current_user=. This is a nice way to
-      # communciate the current user down to the model level for
-      # model-level security. This means you will want to call this
-      # method at least once before using the model-level security.
-      # Usually you will call it in a before filter. This method is
-      # called automatically when authentication_required is applied to
-      # an action.
-      def current_user
-        @current_user ||= begin
-          # Check for session[:uid] here? That would mean that for token auth the
-          # user always needs to be logged out (e.g. in UserController#create).
-          # Looks a bit more robust this way:
-          try_login
-          if session && session[:uid]
-            user = find_current_user
-            set_user_cookie!(user)
-            user
-          else
-            User.anonymous
-          end
-        end
-      end
-
-      def authenticated?
-        !current_user.anonymous?
-      end
-      alias :logged_in? :authenticated?
-
-      # killed this because it's just the wrong way to do it
-      #
-      # # Will store the current params so that we can return here on
-      # # successful login. If you want to redirect to the login yourself
-      # # (perhaps you are applying your own security instead of just
-      # # determining if the user is logged in) then you will want to
-      # # call this before issuing your redirect to the login screen.
-      # def store_return_location
-      #   session[:return_location] = params
-      # end
-
-      private
-
-        # Will actually test to see if the user is authorized
-        def require_authentication
-          # No matter what the app does a user can always login, forgot
-          # password and register. The controllers provided by this
-          # plugin alreaddy have these controllers/actions on an
-          # exception list but this prevents a mistake an overridden
-          # controller from preventing the normal login behavior.
-          %w(session password user).each do |c|
-  	        %w(new create).each do |a|
-              return if (controller_name == c) && (action_name == a)
-            end
-  	      end
-
-          # If we cannot get the current user store the requested page
-          # and send them to the login page.
-          if current_user.anonymous?
-            redirect_to login_url(:return_to => request.url) and false
-          end
-        end
-
-        def logout
-          reset_session
-          forget_me!
-        end
-
-        def forget_me!
-          cookies[:remember_me] = nil
-          cookies[:uid] = nil
-          cookies[:uname] = nil
-        end
-
-        def remember_me!
-          token = current_user.assign_token!('remember me')
-          cookies[:remember_me] = { :value => "#{current_user.id};#{token}", :expires => 10.years.from_now }
-        end
-
-        def set_user_cookie!(user = current_user)
-          unless user.anonymous?
-            cookies[:uid] = user.id.to_s
-            cookies[:uname] = user.name
-          end
-        end
-
-        # There are a few ways that a user can login without going through
-        # a login screen. These methods all rely on authenticating with
-        # the information given in the request. If any of these methods
-        # are successful then session[:uid] will be set with the current
-        # user id and current_user will return the current user
-        def try_login
-          if user = http_auth_login || validation_login || remember_me_login
-            session[:uid] = user.id
-          end
-        end
-
-        # Will attempt to authenticate with HTTP Auth. HTTP Auth will not
-        # be required. We are just checking if it is provided mainly for
-        # RESTful requests.
-        def http_auth_login
-          # FIXME: Implement
-        end
-
-        # Will use the URL param :token to see if we can do a token
-        # authentication.
-        def validation_login
-          validate_token User, params[:token]
-        end
-
-        # Will check for a :remember_me cookie for a token that will
-        # authenticate the user.
-        def remember_me_login
-          validate_token User, cookies[:remember_me]
-        end
-
-        # The tokens are stored in various places as id;token. This method
-        # will split that out and validate it. If everything is successful
-        # then the user object is returned. Otherwise nil is returned.
-        # The full token should be passed in.
-        def validate_token(klass, token, options = {})
-          return nil if token.blank?
-          return nil unless token =~ /\;/
-
-          uid, token = token.split ';'
-          if object = klass.find_by_id(uid)
-            return object if object.authenticate(token)
-          end
-          nil
-        end
-
-        def find_current_user
-          User.find_by_id(session[:uid])
-        end
-
-    end
-  end
-end

data/lib/core_ext.rb

@@ -1,7 +0,0 @@
-class Object
-  def in?(*array)
-    array = array.first if array.first.is_a?(Array)
-    array.include?(self)
-  end
-end
-

data/lib/extensible_forms.rb

@@ -1,284 +0,0 @@
-require 'action_view'
-require 'action_view/helpers'
-require 'action_view/helpers/form_helper'
-
-module ActionView
-  module Helpers
-    module FormHelper
-      prepend Module.new {
-        def fields_for(*args, &block)
-          name = singular_class_name(name) unless name.class.in?(String, Symbol)
-
-          options = args.last.is_a?(Hash) ? args.last : {}
-          options[:builder] ||= pick_form_builder(name)
-
-          super(name, *args, &block)
-        end
-      }
-
-      def field_set(object_name, name, content = nil, options = {}, &block)
-        options.delete(:object)
-        options[:name] ||= name
-        options[:id] ||= name
-        content ||= self.capture(&block) if block_given?
-        content_tag("fieldset", raw(content), options).html_safe
-      end
-
-      protected
-        def singular_class_name(name)
-          ActiveModel::Naming.singular(name)
-        end
-
-        def pick_form_builder(name)
-          name = "#{name.to_s.classify}FormBuilder"
-          name.constantize
-        rescue NameError
-          Object.const_set(name, Class.new(ActionView::Base.default_form_builder)) rescue ActionView::Base.default_form_builder
-        end
-    end
-  end
-end
-
-class ExtensibleFormBuilder < ActionView::Helpers::FormBuilder
-  class_attribute :callbacks
-  self.callbacks = { :before => {}, :after => {} }
-
-  class_attribute :tabs
-  self.tabs = []
-
-  class_attribute :options
-  self.options = { :labels => false, :wrap => false, :default_class_names => {} }
-
-  class << self
-    [:labels, :wrap].each do |option|
-      define_method(:"#{option}=") { |value| self.options[option] = value }
-    end
-
-    def default_class_names(type = nil)
-      if type
-        self.options[:default_class_names][type] ||= []
-      else
-        self.options[:default_class_names]
-      end
-    end
-
-    def before(object_name, method, string = nil, &block)
-      add_callback(:before, object_name, method, string || block)
-    end
-
-    def after(object_name, method, string = nil, &block)
-      add_callback(:after, object_name, method, string || block)
-    end
-
-    def tab(name, options = {}, &block)
-      self.tabs.reject! { |n, b| name == n }
-      self.tabs += [[name, block]]
-    end
-
-    protected
-
-      def add_callback(stage, object_name, method, callback)
-        method = method.to_sym
-        callbacks[stage][object_name] ||= { }
-        callbacks[stage][object_name][method] ||= []
-        callbacks[stage][object_name][method] << callback
-      end
-  end
-
-  helpers = field_helpers + %w(select date_select datetime_select time_select time_zone_select collection_select) -
-                            %w(hidden_field label fields_for apply_form_for_options!)
-
-  helpers.each do |method_name|
-    class_eval <<-src, __FILE__, __LINE__
-      def #{method_name}(*args, &block)
-        type = #{method_name.to_sym.inspect}
-
-        options = args.extract_options!
-        options = add_default_class_names(options, type)
-        # options = add_tabindex(options, type)
-
-        label, wrap, hint = options.delete(:label), options.delete(:wrap), options.delete(:hint)
-        name = args.first
-
-        with_callbacks(name) do
-          tag = super(*(args << options), &block)
-          # remember_tabindex(tag, options)
-          tag = hint(tag, hint) if hint
-          tag = labelize(type, tag, name, label) if label || self.options[:labels]
-          tag = wrap(tag) if wrap || self.options[:wrap]
-          tag
-        end
-      end
-    src
-  end
-
-  def field_set(*args, &block)
-    options = args.extract_options!
-    options = add_default_class_names(options, :field_set)
-
-    name    = args.first
-    name ||= :default_fields
-
-    @template.concat with_callbacks(name) {
-      legend = options.delete(:legend) || ''
-      legend = @template.content_tag('legend', legend) unless legend.blank?
-      @template.field_set(@object_name, name, nil, objectify_options(options)) do
-        legend.to_s + (block ? block.call.to_s : '')
-      end
-    }
-  end
-
-  def tabs
-    yield if block_given?
-    assign_ivars!
-    @template.content_tag(:div, :class => 'tabs') {
-      @template.content_tag(:ul) {
-        self.class.tabs.map { |name, block|
-          klass = self.class.tabs.first.first == name ? 'active' : nil
-          @template.content_tag 'li', @template.link_to(I18n.t(name, :scope => :'adva.titles'), "##{name}"), :class => klass
-        }.join.html_safe
-      } +
-      self.class.tabs.map { |name, block|
-        klass = self.class.tabs.first.first == name ? 'tab active' : 'tab'
-        @template.content_tag 'div', block.call(self), :id => "tab_#{name}", :class => klass
-      }.join.html_safe
-    }.html_safe
-  end
-
-  def tab(name, &block)
-    with_callbacks(:"tab_#{name}") {
-      self.class.tab(name, &block)
-    }
-  end
-
-  def buttons(name = :submit_buttons, &block)
-    @template.concat with_callbacks(name) {
-      @template.capture { @template.buttons(&block) }
-    }
-  end
-
-  def render(*args)
-    @template.send(:render, *args)
-  end
-
-  protected
-
-    def labelize(type, tag, method, label = nil)
-      label = case label
-      when String then label
-      when Symbol then I18n.t(label)
-      when TrueClass then
-        scope = [:activerecord, :attributes] + object.class.to_s.underscore.split('/')
-        string = I18n.t(method, :scope => scope)
-        string.is_a?(String) ? string : method.to_s.titleize
-      else nil
-      end
-
-      case type
-      when :check_box, :radio_button
-        tag + self.label(method, label, :class => 'inline light', :for => extract_id(tag), :id => "#{extract_id(tag)}_label")
-      else
-        self.label(method, label) + tag
-      end
-    end
-
-    def wrap(tag)
-      @template.content_tag(:p, tag)
-    end
-
-    def hint(tag, hint)
-      hint = I18n.t(hint) if hint.is_a?(Symbol)
-      tag + @template.content_tag(:span, hint, :class => 'hint', :for => extract_id(tag))
-    end
-
-    def add_default_class_names(options, type)
-      options[:class] = (Array(options[:class]) + self.class.default_class_names(type)).join(' ')
-      options.delete(:class) if options[:class].blank?
-      options
-    end
-
-    def tabindex_increment!
-      @tabindex_count ||= 0
-      @tabindex_count += 1
-    end
-
-    def set_tabindex_position(index = nil, position = nil)
-      position = case position
-      when :after  then tabindexes[index] + 1
-      when :before then tabindexes[index] - 1
-      when :same   then tabindexes[index]
-      else tabindex_increment!
-      end
-      position
-    end
-
-    def add_tabindex(options, type)
-      index = options[:tabindex]
-
-      if index.is_a?(Hash)
-        key = index.keys.first
-        options[:tabindex] = set_tabindex_position(index[key], key)
-      elsif index.is_a?(Symbol)
-        options[:tabindex] = set_tabindex_position(index, :same)
-      elsif index.blank?
-        options[:tabindex] = set_tabindex_position
-      end
-
-      options
-    end
-
-    def tabindexes
-      @tabindexes ||= {}
-    end
-
-    def remember_tabindex(tag, options)
-      id = extract_id(tag)
-      tabindexes[:"#{id}"] = options[:tabindex] unless id.blank?
-    end
-
-    def with_callbacks(method, &block)
-      result = ''
-      result += run_callbacks(:before, method) if method
-      result += yield.to_s
-      result += run_callbacks(:after, method) if method
-      result.html_safe
-    end
-
-    def run_callbacks(stage, method)
-      if callbacks = callbacks_for(stage, method.to_sym)
-        callbacks.inject('') do |result, callback|
-          result + case callback
-            when Proc
-              assign_ivars!
-              instance_eval(&callback)
-            else
-              callback
-          end.to_s
-        end
-      end || ''
-    end
-
-    def callbacks_for(stage, method)
-      object_name = @object_name.try(:to_sym)
-      self.callbacks[stage][object_name] and
-      self.callbacks[stage][object_name][method.to_sym]
-    end
-
-    def assign_ivars!
-      unless @ivars_assigned
-        @template.assigns.each { |key, value| instance_variable_set("@#{key}", value) }
-        vars = @template.controller.instance_variable_names
-        vars.each { |name| instance_variable_set(name, @template.controller.instance_variable_get(name)) }
-        @ivars_assigned = true
-      end
-    end
-
-    # yep, we gotta do this crap because there doesn't seem to be a sane way
-    # to hook into actionview's form_helper methods
-    def extract_id(tag)
-      tag =~ /id="([^"]+)"/
-      $1
-    end
-end
-
-ActionView::Base.default_form_builder = ExtensibleFormBuilder

data/lib/has_permalink.rb

@@ -1,33 +0,0 @@
-require "friendly_id"
-
-module HasPermalink
-  def self.included(base)
-    base.extend ClassMethods
-  end
-
-  module ClassMethods
-    def has_permalink column, options={}
-      extend FriendlyId
-
-      friendly_id column do |config|
-        config.use :slugged, :finders
-        if options[:scope]
-          config.use :scoped
-          config.scope = options[:scope]
-        end
-        config.slug_column = options[:url_attribute]
-      end
-
-      self.class_eval do
-        def should_generate_new_friendly_id?
-          permalink.blank?
-        end
-      end
-
-      define_method :"#{options[:url_attribute]}=" do |value|
-        value = value.parameterize if value
-        super value
-      end
-    end
-  end
-end

data/lib/login/helper_integration.rb

@@ -1,11 +0,0 @@
-module Login
-  # Automatically mixed into all views for utility functions.
-  module HelperIntegration
-
-    # Returns the current user at the view level. Everything said
-    # about the current_user method in the
-    # Login::ControllerIntegration::InstanceMethods module
-    # applies to this method as well.
-    def current_user; controller.current_user end
-  end
-end

data/lib/login/mail_config.rb

@@ -1,39 +0,0 @@
-module Login
-
-  # The purpose of this module is to provide an application some control
-  # over how the messages are sent without having to overwrite blocks
-  # of code. We do this through simple constants. The two constants
-  # currently are:
-  #
-  # SUBJECT_PREFIX::
-  #   Text that is before every message subject. By default this is not
-  #   used. You may want to put something like the website here.
-  # NOTIFICATIONS_FROM::
-  #   Who the message appears to be coming from. By default this is
-  #   postmaster@yourdomain.com
-  #
-  # If you want to access these same values in your own mailers just
-  # mix them into your mailers and the methods will be available.
-  module MailConfig
-    protected
-
-    # Will return subject prefix
-    def subject_prefix
-      return "[#{SUBJECT_PREFIX}] " if Object.const_defined?('SUBJECT_PREFIX')
-      ''
-    end
-
-    # Email message appear to come from. The constant takes priority
-    # but if no constant is defined then the email is extracted from
-    # the given param which can be any link that you want the email
-    # to appear to come from.
-    def system_email(extract_from)
-      return NOTIFICATIONS_FROM if Object.const_defined?('NOTIFICATIONS_FROM')
-      if host = URI.parse(extract_from).host
-        host = host.split '.'
-        host.shift if host.first =~ /www/i
-        "postmaster@#{host * '.'}"
-      end
-    end
-  end
-end

data/lib/rails_ext/action_controller/cacheable_flash.rb

@@ -1,30 +0,0 @@
-# http://github.com/pivotal/cacheable-flash
-
-require "json"
-
-module CacheableFlash
-  def self.included(base)
-    base.prepend_around_action :write_flash_to_cookie
-  end
-
-  def write_flash_to_cookie
-    yield self
-
-    cookie_flash = begin
-      JSON.parse(cookies["flash"] || "{}")
-    rescue JSON::ParserError
-      {}
-    end
-
-    flash.each do |key, value|
-      if cookie_flash[key.to_s].blank?
-        cookie_flash[key.to_s] = value
-      else
-        cookie_flash[key.to_s] << "<br/>#{value}" # TODO should be an array
-      end
-    end
-
-    cookies['flash'] = cookie_flash.to_json
-    flash.clear
-  end
-end