surbase 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d03849b3405fe0e36d1ed421b04d2a0b62a9bcd
+  data.tar.gz: 1eb7503667a3af9c7a12f5684ac0eaf2f37f95be
+SHA512:
+  metadata.gz: a4b51063f2652c11d14ae68242626677d8c605cf10a0442ed9517c2eb3eed8fda1b1c19f094d8ecfc02cb69c3dae0a4d0144a722fe6b44dc7f10fd8583de0426
+  data.tar.gz: a2a3b25ceb9f98d9195dad797a2d219a4bf69da998392a0200e704248a3745716977fe58e5cd687d0b8d8a69c1a2c6025ef384c139a623af0816842fa09c5eae

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 surbase.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 liveralmask
+
+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,70 @@
+# Surbase
+
+Base system for web services.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'surbase'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install surbase
+
+## Usage
+
+### 1. Add Gemfile
+
+    gem "surbase"
+    gem "omniauth"
+    gem "omniauth-twitter"  # Optional
+    gem "omniauth-facebook" # Optional
+    gem "omniauth-github"   # Optional
+
+### 2. Bundle install
+
+    bundle install
+
+### 3. Install custom generator
+
+    rails generate surbase:install
+
+### 4. Edit config/surbase_secrets.rb
+
+    vi config/surbase_secrets.rb
+
+### 5. Edit config/initializers/surbase.rb
+
+    vi config/initializers/surbase.rb
+
+### 6. Add config/routes.rb
+
+    get "login/:provider"         => "accounts#login"
+    get "auth/:provider/callback" => "accounts#auth_callback"
+
+### 7. Migrate database
+    
+    rake db:migrate
+
+### 8. Start server
+
+    rails server
+
+### 9. Access URL
+
+    http://localhost:3000/login/twitter
+    http://localhost:3000/login/facebook
+    http://localhost:3000/login/github
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/surbase/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/generators/surbase/install/install_generator.rb

@@ -0,0 +1,70 @@
+require "rails"
+require "surbase"
+
+module Surbase
+  class InstallGenerator < ::Rails::Generators::Base
+    def generate
+      file_path = "app/controllers/accounts_controller.rb"
+      if ! File.exists?( file_path )
+        Command.execute( "rails generate controller accounts" ).output
+        
+        open( file_path, "wb" ){|f|
+          f.puts <<EOS
+class AccountsController < ApplicationController
+  include Surbase::AccountsController
+  
+protected
+  def result_api( status )
+    cookie( :account_info, status.values, 30.days.from_now ) if status.values.key?( :account_id )
+    
+    redirect_to "/"
+  end
+end
+EOS
+        }
+      end
+      
+      file_path = "app/models/account.rb"
+      Command.execute( "rails generate model account provider_id:string login_key:string" ).output if ! File.exists?( file_path )
+      
+      file_path = "app/models/provider_account.rb"
+      Command.execute( "rails generate model provider_account account_id:integer name:string icon:string encrypted_access_token:string" ).output if ! File.exists?( file_path )
+      
+      file_path = "config/initializers/surbase.rb"
+      if ! File.exists?( file_path )
+        open( file_path, "wb" ){|f|
+          f.puts <<EOS
+Surbase::Config.setup do
+  prefix ""
+  
+#  provider :twitter
+#  provider :facebook
+#  provider :github
+end
+EOS
+        }
+      end
+      
+      file_path = "config/surbase_secrets.rb"
+      if ! File.exists?( file_path )
+        open( file_path, "wb" ){|f|
+          f.puts <<EOS
+Surbase::Secrets.setup do
+  set( :CIPHER_NAME, "AES-256-CBC" )
+  
+#  set( :TWITTER_KEY,     "" )
+#  set( :TWITTER_SECRET,  "" )
+  
+#  set( :FACEBOOK_KEY,    "" )
+#  set( :FACEBOOK_SECRET, "" )
+  
+#  set( :GITHUB_KEY,      "" )
+#  set( :GITHUB_SECRET,   "" )
+end
+EOS
+        }
+        Command.execute( %Q(echo "\n#{file_path}" >> .gitignore) )
+      end
+    end
+  end
+end

data/lib/surbase.rb

@@ -0,0 +1,137 @@
+require "surbase/version"
+require "surbase/controller"
+
+require "open3"
+require "base64"
+
+module Surbase
+  class Command
+    def self.execute( info )
+      Command.new.execute( info )
+    end
+    
+    attr_accessor   :info, :out, :err, :status
+    
+    def execute( info )
+      if ! info.instance_of?( Hash )
+        info = {
+          :cmd => info
+        }
+      else
+        return nil if ! info.key?( :cmd )
+      end
+      
+      @out, @err, status = Open3.capture3( info[ :cmd ], { :stdin_data => info[ :stdin_data ] } )
+      @status = status.exitstatus
+      @info = info
+      self
+    end
+    
+    def output
+      puts @info[ :cmd ]
+      puts @out if ! @out.empty?
+      $stderr.puts @err if ! @err.empty?
+    end
+  end
+  
+  class Status
+    Success         = "0"
+    Unknown         = "-1"
+    ModelSaveError  = "-100"
+    
+    @@status = {
+        Success         => "Success",
+        Unknown         => "Unknown Error",
+        ModelSaveError  => "Model Save Error",
+    }
+    
+    def self.msg( code )
+      @@status.key?( code ) ? @@status[ code ] : "Unknown Code=#{code}"
+    end
+    
+    def self.set( code, msg )
+      @@status[ code ] = msg
+      Status.new( code )
+    end
+    
+    attr_accessor   :code, :values
+    
+    def initialize( code = Unknown, values = {} )
+      @code   = code
+      @values = values
+    end
+    
+    def msg
+      Status.msg( @code )
+    end
+  end
+  
+  class Cipher
+    def initialize( name )
+      @cipher = OpenSSL::Cipher.new( name )
+    end
+    
+    def encode( value )
+      Base64.urlsafe_encode64( value )
+    end
+    
+    def decode( encoded_value )
+      Base64.urlsafe_decode64( encoded_value )
+    end
+    
+    def encrypt( data, pass )
+      @cipher.encrypt
+      @cipher.pkcs5_keyivgen( pass )
+      encode( @cipher.update( data ) + @cipher.final )
+    end
+    
+    def decrypt( data, pass )
+      @cipher.decrypt
+      @cipher.pkcs5_keyivgen( pass )
+      @cipher.update( decode( data ) ) + @cipher.final
+    end
+  end
+  
+  class Secrets
+    def self.set( key, value )
+      ENV[ key.to_s ] = value.to_s
+    end
+    
+    def self.get( key )
+      ENV[ key.to_s ]
+    end
+    
+    def self.setup( &block )
+      module_eval( &block )
+    end
+  end
+  
+  class Config
+    @@prefix = ""
+    @@providers = []
+    
+    def self.prefix( prefix )
+      @@prefix = prefix
+    end
+    
+    def self.setup( &block )
+      require "#{Rails.root}/config/surbase_secrets.rb"
+      
+      module_eval( &block )
+      
+      Rails.application.config.middleware.use OmniAuth::Builder do
+        @@providers.each{|provider|
+          provider provider[ :provider ], provider[ :key ], provider[ :secret ]
+        }
+      end
+    end
+    
+    def self.provider( provider )
+      @@providers.push({
+        :provider => provider,
+        :key      => Secrets.get( "#{@@prefix}#{provider.upcase}_KEY" ),
+        :secret   => Secrets.get( "#{@@prefix}#{provider.upcase}_SECRET" ),
+      })
+    end
+  end
+end

data/lib/surbase/controller.rb

@@ -0,0 +1,128 @@
+require "surbase/model"
+
+module Surbase
+  module Controller
+    def initialize
+      super
+      
+      @cipher = Cipher.new( Secrets.get( :CIPHER_NAME ) )
+    end
+    
+  protected
+    def result_hash( status )
+      {
+        :status => {
+          :code     => status.code,
+          :msg      => status.msg,
+          :values   => status.values,
+        }
+      }
+    end
+    
+    def result_api( status )
+      render :json => result_hash( status )
+    end
+    
+    def cookie( key, value, expires )
+      cookies[ key ] = { :value => value, :expires => expires }
+    end
+    
+    def to_json( object )
+      JSON.generate( object )
+    end
+    
+    def from_json( json )
+      JSON.parse( json )
+    end
+    
+    def create_key( salt )
+      Digest::SHA512::hexdigest( salt )
+    end
+    
+    def create_key_random
+      now = Time.now.to_i
+      create_key( [
+        now,
+        rand( now ),
+        rand( now ),
+        rand( now )
+      ].join( "_" ) )
+    end
+    
+    def encrypt_json( access_token, pass )
+      @cipher.encrypt( to_json( access_token ), pass )
+    end
+    
+    def decrypt_json( encrypted_access_token, pass )
+      from_json( @cipher.decrypt( encrypted_access_token, pass ) )
+    end
+    
+    def error_status( code, exception )
+      status = Status.new( code, [ exception.message ] )
+      status.values.concat( exception.backtrace ) if ! Rails.env.production?
+      status
+    end
+  end
+  
+  module AccountsController
+    include Controller
+    
+    def login
+      redirect_to "/auth/#{params[ :provider ]}"
+    end
+    
+    def auth_callback
+      auth = request.env[ "omniauth.auth" ]
+      result_api( login_callback({
+        :auth         => auth,
+        :provider     => auth[ "provider" ],
+        :uid          => auth[ "uid" ],
+        :provider_id  => %Q(#{auth[ "provider" ]}\t#{auth[ "uid" ]}),
+        :name         => auth[ "info" ][ "name" ],
+        :icon         => auth[ "info" ][ "image" ],
+        :access_token => {
+          :token      => auth[ "credentials" ][ "token" ],
+          :secret     => auth[ "credentials" ][ "secret" ],
+        },
+        :login_key    => create_key_random
+      }) )
+    end
+    
+  protected
+    def login_callback( info )
+      status = Status.new
+      
+      account = nil
+      ActiveRecord::Base.transaction do
+        account_data = {
+          :provider_id => info[ :provider_id ],
+          :login_key   => info[ :login_key ],
+        }
+        account = Model.load( ::Account, [ "provider_id=?", account_data[ :provider_id ] ], account_data )
+        account.save!
+        
+        provider_account_data = {
+          :account_id             => account.id,
+          :name                   => info[ :name ],
+          :icon                   => info[ :icon ],
+          :encrypted_access_token => encrypt_json( info[ :access_token ], info[ :login_key ] ),
+        }
+        provider_account = Model.load( ::ProviderAccount, [ "account_id=?", account.id ], provider_account_data )
+        provider_account.save!
+      end
+        status.code = Status::Success
+        status.values = {
+          :provider_info => {
+            :provider => info[ :provider ],
+            :name     => info[ :name ],
+            :icon     => info[ :icon ],
+          },
+          :account_id => @cipher.encrypt( @cipher.encode( account.id.to_s ), info[ :login_key ] ),
+          :login_key  => info[ :login_key ],
+        }
+        status
+      rescue => e
+        error_status( Status::ModelSaveError, e )
+    end
+  end
+end