ninsho 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ninsho.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Abraham Kuri Vargas
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+#Ninsho
+
+Ninsho is easy flexible authentication solution when using providers
+
+* Is a complete MVC solution based on Rails Engines;
+* Works with most providers out there, Github, Facebook, Twitter, Linkedin
+
+
+## Getting started
+
+Ninsho 0.0.1 works with rails 3.1 onwards. You can add it to your Gemfile with:
+
+```ruby
+gem 'ninsho'
+```
+
+Then run the bundle command to install it.
+
+After you install Ninsho and add it to your Gemfile, you need to run the generator:
+
+```console
+rails g ninsho:install
+```
+
+The generator will install in initializer which describes all the Ninsho's configuration options, so we recommend you take a look at it. When you are done you are ready to start the ninsho process, first you need to generate an authentications model or so:
+
+```console
+rails g ninsho MODEL
+```
+
+Before yout start generating, we are assuming you have a model to relate to, in most cases a 'User' class, just for you to be aware and that it has an email attribute.
+
+Replace MODEL by the class name used for the app authentications, it is commonly 'Authentication'. This will create a model(if one does not exists), and add the belongs_to_ninsho method (it's commented don't worry). 
+
+Next you'll probably want to run the migrations "rake db:migrate", as the generator will create a migration file (open it modify if you need). This generator also configures your config/routes.rb file to point to the Ninsho Controller.
+
+### Stop right here!
+
+Once you have the 'User' model and the 'Authentication' model, you just have to relate them:
+
+\> app/models/user.rb
+
+```ruby
+has_many :authentications
+```
+
+\> app/models/authentication.rb
+
+```ruby
+belongs_to_ninsho :user
+```
+
+### Controller and helpers
+
+Ninsho will create some helpers to use inside your controllers and views.
+
+```ruby
+before_filter :authenticate_user!
+```
+
+To check if the user is signed in
+
+```ruby
+user_signed_in?
+```
+
+```ruby
+current_user
+```
+
+After user is signed in or signed out it will be redirected to the root_path, but you can always change this by overwriting the `redirect_on_sign_in_path` or `redirect_on_sign_out_path`
+
+Notice if you relate the ninsho model with for example a member model, then the helpers you should use are:
+
+
+```ruby
+before_filter :authenticate_member!
+```
+
+To check if the user is signed in
+
+```ruby
+member_signed_in?
+```
+
+```ruby
+current_member
+```
+
+### Configuring views
+
+Since Ninsho is a Rails Engine it provides a simple view for handling the session, it is very basic so you might want to change them. In this case you can run the generator and it will copy all views to your app:
+
+```console
+rails g ninsho:views
+```
+
+### Omniauth
+
+Ninsho plays good with many providers (some test would not hurt), such as github, facebook, twitter, linkedin, and to configure them you just need to add the omniauth-provider gem to your Gemfile like so:
+
+```ruby
+gem 'omniauth-facebook'
+```
+
+And after that if you want ninsho to respond to that, you just need to add the provider in `config/initializers/ninsho.rb`:
+
+```ruby
+config.omniauth :facebook, "APP_ID", "APP_SECRET", :scope => 'email'
+```
+
+### I18n
+
+You can overwrite the ninsho locale and customize the flash messages:
+
+```yaml
+en:
+  ninsho:
+    sessions:
+      signed_in: "Signed in successfully"
+      signed_out: "Signed out successfully"
+```
+
+### Changelog
+
+* Current gem version 0.0.1
+
+### Devs
+
+* Abraham Kuri (https://github.com/kurenn)
+
+### Future
+
+* Add more flexibility to handle authentications and save multiple to fields
+* Add tests
+* Support for Mongoid
+* Add handy helpers
+* Add aouth token for Facebook friends
+* Add more documentation on code
+
+## Credits
+Icalia Labs - weare@icalialabs.com
+
+[Follow us](http://twitter.com/icalialabs "Follow us")
+
+
+[Like us on Facebook](https://www.facebook.com/icalialab "Like us on Facebook")
+
+
+### License
+
+MIT License. Copyright 2012-2013 IcaliaLabs. http://icalialabs.com

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/controllers/ninsho/sessions_controller.rb

@@ -0,0 +1,23 @@
+class Ninsho::SessionsController < NinshoController
+
+  def new
+    @providers = Ninsho.providers
+  end
+
+  def create
+    resource = build_resource_from_omniauth
+    if resource.authenticated?
+      sign_in resource.send(Ninsho.parent_resource_name.to_s.downcase).id
+      flash_message(:notice, :signed_in)
+      redirect_on_sign_in_path
+    else
+      redirect_to_root
+    end
+  end
+
+  def destroy
+    sign_out 
+    flash_message(:notice, :signed_out)
+    redirect_on_sign_out_path
+  end
+end

data/app/controllers/ninsho_controller.rb

@@ -0,0 +1,45 @@
+class NinshoController < Ninsho.parent_controller.constantize
+
+  helpers = %w(resource resource_name resource_class resource_params)
+  hide_action *helpers
+  helper_method *helpers
+
+  def flash_message(key, action) 
+    message = I18n.t("ninsho.sessions.#{action}")
+    flash[key] = message if message.present?
+  end
+
+  # Gets the actual resource stored in the instance variable
+  def resource
+    instance_variable_get(:"@#{resource_name}")
+  end
+
+  def resource_params
+    env['omniauth.auth']
+  end
+
+  # Proxy to ninsho map name
+  def resource_name
+    Ninsho.resource_name #authentication
+  end
+
+  def resource_class
+    Ninsho.resource_class 
+  end
+
+  # Sets the resource creating an instance variable
+  def resource=(new_resource)
+    instance_variable_set(:"@#{resource_name}", new_resource)
+  end
+
+  # Parent resource
+  def parent_resource
+    resource_class.reflect_on_all_associations(:belongs_to).first.name.to_s
+  end
+
+  # Build a ninsho resource.
+  # Assignment bypasses attribute protection when :unsafe option is passed
+  def build_resource_from_omniauth 
+      self.resource = resource_class.from_omniauth(resource_params)
+  end
+end

data/app/helpers/ninsho_helper.rb

@@ -0,0 +1,74 @@
+module NinshoHelper
+
+  RESOURCE_NAME = Ninsho.resource_name.singularize
+  PARENT_RESOURCE_NAME = Ninsho.parent_resource_name.to_s.downcase
+
+  def store_location
+    session[:return_to] = request.fullpath
+  end
+
+  def clear_return_to
+    session[:return_to] = nil 
+  end
+
+  def redirect_back_or(default)
+    redirect_to(session[:return_to] || default )
+    clear_return_to 
+  end
+
+  def after_sign_in_path_for
+    redirect_back_or redirect_to_root
+  end
+
+  def sign_out
+    session["#{PARENT_RESOURCE_NAME}_id".to_sym] = nil 
+  end
+
+  def sign_in_and_redirect(parent_id, path=nil)
+    session["#{PARENT_RESOURCE_NAME}_id".to_sym] = parent_id
+    redirect_to path
+  end
+
+  def sign_in(parent_id)
+    session["#{PARENT_RESOURCE_NAME}_id".to_sym] = parent_id
+  end
+
+  class_eval <<-METHODS, __FILE__, __LINE__ + 1
+    def current_#{PARENT_RESOURCE_NAME}
+      @current_#{PARENT_RESOURCE_NAME} ||= #{Ninsho.parent_resource_name}.find(session[:#{PARENT_RESOURCE_NAME}_id]) if session[:#{PARENT_RESOURCE_NAME}_id] 
+    end
+
+    def #{PARENT_RESOURCE_NAME}_signed_in?
+      current_#{PARENT_RESOURCE_NAME}.present? 
+    end
+
+    def authenticate_#{PARENT_RESOURCE_NAME}!
+      deny_access unless #{PARENT_RESOURCE_NAME}_signed_in?
+    end
+
+    METHODS
+
+    define_method "link_#{RESOURCE_NAME}_with" do |provider|
+      link_to "Connect with #{provider.to_s.capitalize}", "auth/#{provider.to_s}"
+    end
+
+
+    # Method used by sessions controller to sign out a user. 
+    # You can overwrite it in your ApplicationController
+    #
+    # By default it is the root_path.
+    def redirect_on_sign_out_path
+      redirect_to_root
+    end
+
+    def redirect_on_sign_in_path
+      redirect_to_root
+    end
+    def redirect_to_root
+      redirect_to respond_to?(:root_path) ? root_path : "/"
+    end
+
+    def deny_access
+      redirect_to_root
+    end
+end

data/app/views/ninsho/sessions/new.html.erb

@@ -0,0 +1,3 @@
+<%- @providers.each do |provider| %>
+  <%= link_to provider.to_s, "auth/#{provider.to_s}" %>
+<%- end%>

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  ninsho:
+    sessions:
+      signed_in: "Signed in successfully"
+      signed_out: "Signed out successfully"

data/lib/generators/active_record/ninsho_generator.rb

@@ -0,0 +1,51 @@
+require 'rails/generators/active_record'
+require 'generators/ninsho/orm_helpers'
+
+module ActiveRecord
+  module Generators
+    class NinshoGenerator < ActiveRecord::Generators::Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      include Ninsho::Generators::OrmHelpers
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_ninsho_migration
+        if (behavior == :invoke && model_exists?) || (behavior == :revoke && migration_exists?(table_name))
+          migration_template "existing_migration.rb", "db/migrate/add_ninsho_to_#{table_name}"
+        else
+          migration_template "migration.rb", "db/migrate/ninsho_create_#{table_name}"
+        end
+      end
+
+      def generate_model
+        invoke "active_record:model", [name], :migration => false unless model_exists? && behavior == :invoke
+      end
+
+     def inject_ninsho_content
+      content = <<CONTENT
+  attr_accessible :provider, :uid
+  # belongs_to_ninsho :user
+CONTENT
+
+      class_path = if namespaced?
+        class_name.to_s.split("::")
+      else
+        [class_name]
+      end
+
+      indent_depth = class_path.size - 1
+      content = content.split("\n").map { |line| "  " * indent_depth + line } .join("\n") << "\n"
+      inject_into_class(model_path, class_path.last, content) if model_exists?
+     end
+
+       def migration_data
+<<RUBY
+      ## Database authentications 
+      t.integer :user_id
+      t.string :provider
+      t.string :uid
+RUBY
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/existing_migration.rb

@@ -0,0 +1,22 @@
+class AddNinshoTo<%= table_name.camelize %> < ActiveRecord::Migration
+  def self.up
+    change_table(:<%= table_name %>) do |t|
+      <%= migration_data -%>
+
+      <% attributes.each do |attribute| -%>
+        t.<%= attribute.type %> :<%= attribute.name %>
+      <% end -%>
+
+      # Uncomment below if timestamps were not included in your original model.
+      # t.timestamps
+    end
+
+    add_index :<%= table_name %>, :user_id
+  end
+
+  def self.down
+    # By default, we don't want to make any assumption about how to roll back a migration when your
+    # model already existed. Please edit below which fields you would like to remove in this migration.
+    raise ActiveRecord::IrreversibleMigration
+  end
+end

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,14 @@
+class NinshoCreate<%= table_name.camelize %> < ActiveRecord::Migration
+  def change
+    create_table(:<%= table_name %>) do |t|
+      <%= migration_data -%>
+
+      <% attributes.each do |attribute| -%>
+        t.<%= attribute.type %> :<%= attribute.name %>
+      <% end -%>
+
+      t.timestamps
+    end
+    add_index :<%= table_name %>, :user_id
+  end
+end

data/lib/generators/ninsho/install_generator.rb

@@ -0,0 +1,20 @@
+require 'securerandom'
+
+module Ninsho
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a Ninsho initializer to your application."
+      class_option :orm
+
+      def copy_initializer
+        template 'ninsho.rb', "config/initializers/ninsho.rb"
+      end
+
+      def display_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/ninsho/ninsho_generator.rb

@@ -0,0 +1,23 @@
+module Ninsho
+  module Generators
+    class NinshoGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::ResourceHelpers
+
+      namespace "ninsho"
+      desc "Creates a model with the given name with ninsho" <<
+           "includes migration files, and routes config"
+
+     hook_for :orm
+
+     class_option :routes, :desc => "Generate routes", :type => :boolean, :default => true
+
+     def add_ninsho_routes
+       ninsho_routes = "ninsho_on :#{plural_name}"
+       ninsho_routes << %Q(, :class_name => "#{class_name}") if class_name.include?("::")
+       ninsho_routes << %Q(, :skip => :all) unless options.routes?
+       route ninsho_routes
+     end
+
+    end
+  end
+end

data/lib/generators/ninsho/orm_helpers.rb

@@ -0,0 +1,22 @@
+module Ninsho
+  module Generators
+    module OrmHelpers
+
+      def model_exists?
+        File.exists?(File.join(destination_root, model_path))
+      end
+
+      def migration_exists?(table_name)
+        Dir.glob("#{File.join(destination_root, migration_path)}/[0-9]*_*.rb").grep(/\d+_add_ninsho_to_#{table_name}.rb$/).first
+      end
+
+      def migration_path
+        @migration_path ||= File.join("db", "migrate")
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+    end
+  end
+end

data/lib/generators/ninsho/views_generator.rb

@@ -0,0 +1,50 @@
+module Ninsho 
+  module Generators
+    # Include this module in your generator to generate Ninsho views.
+    # `copy_views` is the main method and by default copies all views
+    # with forms.
+    module ViewPathTemplates #:nodoc:
+      extend ActiveSupport::Concern
+
+      included do
+        argument :scope, :required => false, :default => nil,
+                         :desc => "The scope to copy views to"
+
+        public_task :copy_views
+      end
+
+      def copy_views
+        view_directory :sessions
+      end
+
+      protected
+
+      def view_directory(name, _target_path = nil)
+        directory name.to_s, _target_path || "#{target_path}/#{name}" do |content|
+          content
+        end
+      end
+
+      def target_path
+        @target_path ||= "app/views/ninsho"
+      end
+    end
+
+
+    class DefaultGenerator < Rails::Generators::Base #:nodoc:
+      include ViewPathTemplates
+      source_root File.expand_path("../../../../app/views/ninsho", __FILE__)
+      desc "Copies default Ninsho views to your application."
+    end
+
+    class ViewsGenerator < Rails::Generators::Base
+      desc "Copies Ninsho views to your application."
+
+      argument :scope, :required => false, :default => nil,
+                       :desc => "The scope to copy views to"
+
+      invoke DefaultGenerator 
+    end
+  end
+end
+

data/lib/generators/templates/README

@@ -0,0 +1,10 @@
+===============================================================================
+
+Hey you, thanks for installing Ninsho, here are some tips: 
+
+  1. You can copy Ninsho views (for customization) to your app by running:
+
+       rails g ninsho:views
+
+===============================================================================
+

data/lib/generators/templates/ninsho.rb

@@ -0,0 +1,12 @@
+# This hook is use to setup the configuration for creating models through
+# rails generators
+Ninsho.setup do |config|
+  
+  # ==> ORM Configuration
+  # Load and configure the ORM. Supports :active_record
+  require 'ninsho/orm/active_record'
+
+
+  #Omniauth Providers
+  #config.omniauth :facebook, "APP_ID", "APP_SECRET", :scope => 'email'
+end

data/lib/ninsho/authentication.rb

@@ -0,0 +1,38 @@
+module Ninsho
+  class Authentication
+    PARENT_RESOURCE_NAME = Ninsho.parent_resource_name.to_s.downcase
+
+     def initialize(omniauth = nil)
+      @omniauth = omniauth
+      @provider = omniauth['provider'] 
+      @uid = omniauth['uid']
+      @email = omniauth['info']['email']
+     end
+
+     def authenticated?
+       user.present?
+     end
+
+     def from_oauth
+       Ninsho.resource_class.find_by_provider_and_uid(@provider, @uid) 
+     end
+
+     def from_user
+       user = Ninsho.parent_resource_name.send :find_by_email, @email
+       if user
+         user.send("#{Ninsho.resource_name.pluralize}").build(provider: @provider, uid: @uid)
+         user.send(:save)
+         user
+       else
+         user = Ninsho.parent_resource_name.send :new, { email: @email }
+         user.send("#{Ninsho.resource_name.pluralize}").build(provider: @provider, uid: @uid)
+         user.send(:save)
+         user
+       end
+     end
+
+     def user
+       from_oauth.try(Ninsho.parent_resource_name.to_s.downcase.to_sym) || from_user
+     end
+  end
+end

data/lib/ninsho/controllers/helpers.rb

@@ -0,0 +1,79 @@
+module Ninsho
+  module Controllers
+    module Helpers
+      extend ActiveSupport::Concern
+
+  RESOURCE_NAME = Ninsho.resource_name.singularize
+  PARENT_RESOURCE_NAME = Ninsho.parent_resource_name.to_s.downcase
+
+  def store_location
+    session[:return_to] = request.fullpath
+  end
+
+  def clear_return_to
+    session[:return_to] = nil 
+  end
+
+  def redirect_back_or(default)
+    redirect_to(session[:return_to] || default )
+    clear_return_to 
+  end
+
+  def after_sign_in_path_for
+    redirect_back_or redirect_to_root
+  end
+
+  def sign_out
+    session["#{PARENT_RESOURCE_NAME}_id".to_sym] = nil 
+  end
+
+  def sign_in_and_redirect(parent_id, path=nil)
+    session["#{PARENT_RESOURCE_NAME}_id".to_sym] = parent_id
+    redirect_to path
+  end
+
+  def sign_in(parent_id)
+    session["#{PARENT_RESOURCE_NAME}_id".to_sym] = parent_id
+  end
+
+  class_eval <<-METHODS, __FILE__, __LINE__ + 1
+    def current_#{PARENT_RESOURCE_NAME}
+      @current_#{PARENT_RESOURCE_NAME} ||= #{Ninsho.parent_resource_name}.find(session[:#{PARENT_RESOURCE_NAME}_id]) if session[:#{PARENT_RESOURCE_NAME}_id] 
+    end
+
+    def #{PARENT_RESOURCE_NAME}_signed_in?
+      current_#{PARENT_RESOURCE_NAME}.present? 
+    end
+
+    def authenticate_#{PARENT_RESOURCE_NAME}!
+      deny_access unless #{PARENT_RESOURCE_NAME}_signed_in?
+    end
+
+  METHODS
+
+  define_method "link_#{RESOURCE_NAME}_with" do |provider|
+    link_to "Connect with #{provider.to_s.capitalize}", "auth/#{provider.to_s}"
+  end
+
+
+  # Method used by sessions controller to sign out a user. 
+  # You can overwrite it in your ApplicationController
+  #
+  # By default it is the root_path.
+  def redirect_on_sign_out_path
+    redirect_to_root
+  end
+
+  def redirect_on_sign_in_path
+    redirect_to_root
+  end
+  def redirect_to_root
+    redirect_to respond_to?(:root_path) ? root_path : "/"
+  end
+
+  def deny_access
+    redirect_to_root
+  end
+    end
+  end
+end

data/lib/ninsho/interface.rb

@@ -0,0 +1,29 @@
+require 'ninsho/authentication'
+
+module Ninsho
+  module Interface
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      
+      def belongs_to_ninsho(*args)
+        options = args.extract_options!
+        
+        associations = args.collect(&:to_s).collect(&:downcase)
+        association_keys = associations.collect { |association| "#{association}_id" } 
+
+        #Set the belongs_to association by ActiveRecord
+        associations.each do |associated_model|
+          belongs_to associated_model.to_sym
+          Ninsho.parent_resource_name = Ninsho.ref(associated_model.to_s.classify).get
+        end
+      end
+
+      def from_omniauth(omniauth = nil)
+        Ninsho::Authentication.new(omniauth)
+      end
+    end
+  end
+end

data/lib/ninsho/omniauth/config.rb

@@ -0,0 +1,44 @@
+module Ninsho
+  module OmniAuth
+    class StrategyNotFound < NameError
+      def initialize(strategy)
+        @strategy = strategy
+        super("Could not find a strategy with name `#{strategy}'." )
+      end
+    end
+
+    class Config
+      attr_accessor :strategy
+      attr_reader :args, :options, :provider, :strategy_name
+
+      def initialize(provider, args)
+        @provider       = provider
+        @args           = args
+        @options        = @args.last.is_a?(Hash) ? @args.last : {}
+        @strategy       = nil
+        @strategy_name  = options[:name] || @provider
+        @strategy_class = options.delete(:strategy_class)
+      end
+
+      def strategy_class
+        @strategy_class ||= find_strategy || autoload_strategy
+      end
+
+      def find_strategy
+        ::OmniAuth.strategies.find do |strategy_class|
+          strategy_class.to_s =~ /#{::OmniAuth::Utils.camelize(strategy_name)}$/ ||
+          strategy_class.default_options[:name] == strategy_name
+        end
+      end
+
+      def autoload_strategy
+        name = ::OmniAuth::Utils.camelize(provider.to_s)
+        if ::OmniAuth::Strategies.const_defined?(name)
+          ::OmniAuth::Strategies.const_get(name)
+        else
+          raise StrategyNotFound, name
+        end
+      end
+    end
+  end
+end

data/lib/ninsho/omniauth.rb

@@ -0,0 +1,17 @@
+begin
+  require "omniauth"
+  require 'omniauth/version'
+rescue LoadError
+  warn "Could not load 'omniauth'. Please ensure you have the omniauth gem >= 1.0.0 installed and listed in your Gemfile."
+  raise
+end
+
+unless OmniAuth::VERSION =~ /^1\./
+  raise "You are using an old OmniAuth version, please ensure you have 1.0.0.pr2 version or later installed."
+end
+
+module Ninsho 
+  module OmniAuth
+    autoload :Config, "ninsho/omniauth/config"
+  end
+end

data/lib/ninsho/orm/active_record.rb

@@ -0,0 +1 @@
+require 'orm_adapter/adapters/active_record'

data/lib/ninsho/rails/routes.rb

@@ -0,0 +1,41 @@
+
+module ActionDispatch::Routing
+  
+
+  class Mapper
+    #Includes the ninsho_on method for routes. This method is responsible
+    # for creating all the routes needed.
+    #
+    # == Example
+    #
+    # Assuming you have an authentications model on your application,
+    # your routes should look like:
+    #
+    #   ninsho_on :authentications
+    #   
+    #   This method will generate something like:
+    #
+    #   Session routes
+    #   new_authentication_session_path GET /sign_in { controller: 'ninsho/sessions', action: 'new' }
+    #       authentication_session_path POST /authentication/:provider/callback { controller: 'ninsho/sessions', action: 'create' }
+    #   destroy_authentication_session_path DELETE /sign_out { controller: 'ninsho/sessions', action: 'destroy' }
+    #
+
+     def ninsho_on(resources_name)
+       drawer = Ninsho::RoutesDrawer.new resources_name
+       Ninsho.resource_class = drawer.to
+       Ninsho.resource_name = drawer.resource
+       ninsho_session(drawer.singular_name)
+     end
+
+     protected
+
+     def ninsho_session(name) #:nodoc:
+       resource :session, :only => [], :controller => 'ninsho/sessions', :path => "" do
+       get :new, :path => 'sign_in', as: "new_#{name}"
+       match :create, path: "auth/:provider/callback", as: "#{name}"
+       delete :destroy, path: 'sign_out', as: "destroy_#{name}"
+     end
+     end
+  end
+end

data/lib/ninsho/rails.rb

@@ -0,0 +1,22 @@
+require 'ninsho/rails/routes'
+
+module Ninsho
+  class Engine < ::Rails::Engine
+    config.ninsho = Ninsho
+
+    # Force routes to be loaded if we are doing any eager load.
+    config.before_eager_load { |app| app.reload_routes! }
+
+    ActiveSupport.on_load(:action_controller) do
+      include Ninsho::Controllers::Helpers 
+    end
+
+    initializer "ninsho.omniauth" do |app|
+      Ninsho.omniauth_configs.each do |provider, config|
+        app.middleware.use config.strategy_class, *config.args do |strategy|
+          config.strategy = strategy
+        end
+      end
+    end
+  end
+end

data/lib/ninsho/railtie.rb

@@ -0,0 +1,7 @@
+module Ninsho
+  class Railtie < Rails::Railtie
+    ActiveSupport.on_load :active_record do
+      ActiveRecord::Base.send :include, Ninsho::Interface
+    end
+  end
+end

data/lib/ninsho/routes_drawer.rb

@@ -0,0 +1,20 @@
+module Ninsho
+  # Responsible for handling ninsho mappings and routes configuration
+  # The required value in ninsho_on is actually not used internally, but it's
+  # inflected to find all other values.
+  #
+  class RoutesDrawer #:nodoc:
+    attr_reader :singular_name, :klass, :resource
+
+    def initialize(name)
+      @resource = name.to_s
+      @singular_name = name.to_s.singularize
+      @klass = Ninsho.ref(@singular_name.classify)
+    end
+
+    # Gives the class the mapping points to.
+    def to
+      @klass.get
+    end
+  end
+end

data/lib/ninsho/version.rb

@@ -0,0 +1,3 @@
+module Ninsho
+  VERSION = "0.0.1"
+end

data/lib/ninsho.rb

@@ -0,0 +1,68 @@
+require 'rails'
+require "ninsho/version"
+require 'orm_adapter'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/dependencies'
+
+module Ninsho
+
+  autoload :OmniAuth, 'ninsho/omniauth'
+
+  module Controllers
+    autoload :Helpers, 'ninsho/controllers/helpers'
+  end
+
+  mattr_accessor :parent_controller
+  @@parent_controller = "ApplicationController"
+
+  mattr_accessor :resource_class
+  @@resource_class = ""
+
+  mattr_accessor :resource_name
+  @@resource_name = ""
+
+  mattr_reader :providers
+  @@providers = []
+
+  mattr_accessor :parent_resource_name
+  @@parent_resource_name = '' 
+
+
+  mattr_reader :omniauth_configs
+  @@omniauth_configs = ActiveSupport::OrderedHash.new
+  
+  def self.setup
+    yield self
+  end
+
+  class Getter
+    def initialize name
+      @name = name
+    end
+
+    def get
+      ActiveSupport::Dependencies.constantize(@name)
+    end
+  end
+
+  def self.ref(arg)
+    if defined?(ActiveSupport::Dependencies::ClassCache)
+      ActiveSupport::Dependencies::reference(arg)
+      Getter.new(arg)
+    else
+      ActiveSupport::Dependencies.ref(arg)
+    end
+  end
+
+  def self.omniauth(provider, *args)
+    config = Ninsho::OmniAuth::Config.new(provider, args)
+    @@providers << config.strategy_name.to_sym
+    @@omniauth_configs[config.strategy_name.to_sym] = config
+  end
+
+end
+
+require 'ninsho/routes_drawer'
+require 'ninsho/rails'
+require 'ninsho/interface'
+require 'ninsho/railtie'

data/ninsho.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ninsho/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ninsho"
+  gem.version       = Ninsho::VERSION
+  gem.platform      = Gem::Platform::RUBY
+  gem.authors       = ["Abraham Kuri Vargas"]
+  gem.email         = ["abraham.kuri@gmail.com"]
+  gem.description   = %q{Easy authentication with many providers}
+  gem.summary       = %q{Easy authentication with many providers}
+  gem.homepage      = ""
+
+  gem.rubyforge_project = "ninsho"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency("orm_adapter", "~> 0.1")
+  gem.add_dependency "railties", "~> 3.1"
+  gem.add_dependency "activerecord", ">= 3.0"
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: ninsho
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Abraham Kuri Vargas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: orm_adapter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Easy authentication with many providers
+email:
+- abraham.kuri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/controllers/ninsho/sessions_controller.rb
+- app/controllers/ninsho_controller.rb
+- app/helpers/ninsho_helper.rb
+- app/views/ninsho/sessions/new.html.erb
+- config/locales/en.yml
+- lib/generators/active_record/ninsho_generator.rb
+- lib/generators/active_record/templates/existing_migration.rb
+- lib/generators/active_record/templates/migration.rb
+- lib/generators/ninsho/install_generator.rb
+- lib/generators/ninsho/ninsho_generator.rb
+- lib/generators/ninsho/orm_helpers.rb
+- lib/generators/ninsho/views_generator.rb
+- lib/generators/templates/README
+- lib/generators/templates/ninsho.rb
+- lib/ninsho.rb
+- lib/ninsho/authentication.rb
+- lib/ninsho/controllers/helpers.rb
+- lib/ninsho/interface.rb
+- lib/ninsho/omniauth.rb
+- lib/ninsho/omniauth/config.rb
+- lib/ninsho/orm/active_record.rb
+- lib/ninsho/rails.rb
+- lib/ninsho/rails/routes.rb
+- lib/ninsho/railtie.rb
+- lib/ninsho/routes_drawer.rb
+- lib/ninsho/version.rb
+- ninsho.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ninsho
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Easy authentication with many providers
+test_files: []