RubyGems - sq_auth - Versions diffs - 0.0.18 - Mend

sq_auth 0.0.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

data/.gitignore +5 -0
data/.rspec +1 -0
data/Gemfile +4 -0
data/Rakefile +7 -0
data/examples/client.rb +23 -0
data/examples/server.rb +37 -0
data/lib/sq_auth/sq_auth_access.rb +103 -0
data/lib/sq_auth/sq_auth_client.rb +72 -0
data/lib/sq_auth/sq_auth_helpers/sq_auth_helpers_dsl.rb +61 -0
data/lib/sq_auth/sq_auth_helpers/sq_auth_helpers_rails.rb +39 -0
data/lib/sq_auth/sq_auth_helpers/sq_auth_helpers_sinatra.rb +25 -0
data/lib/sq_auth/sq_auth_integration/sq_auth_action_controller.rb +16 -0
data/lib/sq_auth/sq_auth_integration/sq_auth_integration.rb +23 -0
data/lib/sq_auth/sq_auth_integration/sq_auth_rack.rb +89 -0
data/lib/sq_auth/sq_auth_integration/sq_auth_rack_protection.rb +28 -0
data/lib/sq_auth/sq_auth_integration/sq_auth_sinatra.rb +36 -0
data/lib/sq_auth/sq_auth_request.rb +88 -0
data/lib/sq_auth/sq_auth_server_interface/basic_server.rb +40 -0
data/lib/sq_auth/sq_auth_sessions.rb +16 -0
data/lib/sq_auth/sq_auth_user/basic_user.rb +10 -0
data/lib/sq_auth/sq_auth_user/rack_user.rb +11 -0
data/lib/sq_auth/sq_auth_utils.rb +12 -0
data/lib/sq_auth/version.rb +3 -0
data/lib/sq_auth.rb +68 -0
data/spec/lib/sq_auth/sq_auth_client_spec.rb +30 -0
data/spec/lib/sq_auth/sq_auth_request_spec.rb +40 -0
data/spec/lib/sq_auth/sq_auth_server_interface/basic_server_spec.rb +24 -0
data/spec/lib/sq_auth/sq_auth_sessions_spec.rb +3 -0
data/spec/lib/sq_auth/sq_auth_user/basic_user_spec.rb +5 -0
data/spec/lib/sq_auth_spec.rb +5 -0
data/spec/spec_helper.rb +1 -0
data/sq_auth.gemspec +24 -0
metadata +125 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.*.sw*

data/.rspec ADDED Viewed

	@@ -0,0 +1 @@
1	+ --color

data/Gemfile ADDED Viewed

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

data/Rakefile ADDED Viewed

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+task :default => :spec
+task :test => :spec

data/examples/client.rb ADDED Viewed

@@ -0,0 +1,23 @@
+require 'sinatra'
+require 'sq_auth'
+enable :sessions
+set :port, 7842
+SqAuth.connect(host: "localhost", port: 3000) do |d|
+  d.project_name = "Project"
+end
+get ["admin"], "/something" do
+  <<-EOF
+    Logined to something with params #{params}
+    <br>
+    #{SqAuth.with_sq_auth("admin::super", "Project"){"You can't see it"}}
+    <br>
+    #{access_for("admin"){"You can see it"}}
+  EOF
+end
+get "/abc" do
+  params.to_s
+end

data/examples/server.rb ADDED Viewed

@@ -0,0 +1,37 @@
+require 'sinatra'
+require 'json'
+require 'net/http'
+require 'uri'
+set :port, 7843
+get "/health" do
+  "OK"
+end
+post "/check_role" do
+  unless params[:role][/admin/]
+    {:role_exist => true}.to_json
+  else
+    {:role_exist => false}.to_json
+  end
+end
+get "/login" do
+  uri = URI::parse(params[:callback])
+  new_uri = URI::HTTP.build(host: uri.host, port: uri.port, path: "/save_session")
+  <<-EOF
+  <body>
+    <a href='#{params[:callback]}'>Back</a>
+    <form action="#{new_uri}" method="post">
+      <input type="text" name="sqauthsession" value="mydata" />
+      <input style="display:none" type="text" name="callback" value="#{params[:callback]}" />
+      <input type="submit" />
+    </form>
+  </body>
+  EOF
+end
+get "/push_session" do
+  push_session_to_client params[:client]
+end

data/lib/sq_auth/sq_auth_access.rb ADDED Viewed

@@ -0,0 +1,103 @@
+module SqAuth
+  class SqAuthAccess
+    DEFAULT_ACCESS_PATH = "/access_partial"
+    DEFAULT_DRAW_PROC = Proc.new {|uri, callback, role, project, session| SqAuthUtils::default_draw_template(uri, callback, role, project, session)}
+    DEFAULT_DATA_PROC = Proc.new { "Forbidden" }
+    DEFAULT_OPTIONS = {project: "Project", https: true}
+    attr_accessor :login_path, :callback, :project_name, :gateway_ip
+    def initialize options={}
+      @options = options
+      @data_proc = DEFAULT_DATA_PROC
+      @draw_proc = DEFAULT_DRAW_PROC
+      @login_path = DEFAULT_ACCESS_PATH
+      @gateway_ip = nil
+    end
+    def connect options = {}
+      options = DEFAULT_OPTIONS.merge(options)
+      @project_name = options[:project]
+      @gateway_ip = options[:gateway_ip]
+      yield self if block_given?
+      SqAuthIntegration.alter_environment options
+      @session_provider = SqAuthClient.new options
+    end
+    def draw_when_not_logged_in &block
+      @draw_proc = block
+    end
+    def data_when_not_logged_in &block
+      @data_proc = Proc.new {|*args| block.call(*args)}
+    end
+    def get_not_logged_in_proc type = nil
+      if type == true || type.nil?
+        @draw_proc
+      else
+        @data_proc
+      end
+    end
+    def check_session_provider
+      raise "Authentication service not specified" unless @session_provider
+    #  raise "Authentication service unavailable" unless @session_provider.available?
+    end
+    def api_filter(roles, project = @project_name, when_ok, when_no_role, options)
+      check_session_provider
+      not_logged_in_proc = get_not_logged_in_proc(options[:draw])
+      if sq_auth_filter(roles, project, options)
+        when_ok.call
+      else
+        when_no_role.(not_logged_in_proc.(login_to, callback, roles, project, @session_provider.session_for_current_user))
+      end
+    end
+    def sq_auth_filter(roles, project = @project_name, options = {})
+      @session_provider.session_for_current_user && @session_provider.role_exist_for_current_user?(roles, project)
+    end
+    def when_not_authenticated(roles, project, options = {})
+      not_logged_in_proc = get_not_logged_in_proc(options[:draw])
+      not_logged_in_proc.call(login_to, callback, roles, project, @session_provider.session_for_current_user)
+    end
+    def draw_when_not_authenticated(roles, project = @project_name)
+      when_not_authenticated(roles, project, {:draw => true})
+    end
+    def message_when_not_authenticated(roles = [], project = @project_name)
+      when_not_authenticated(roles, project, {:draw => false})
+    end
+    def with_sq_auth(roles, project = @project_name, options = {}, &block)
+      check_session_provider
+      binded_self = options[:binding].is_a?(Binding) ? eval("self", options[:binding]) : self
+      if sq_auth_filter(roles, project, options)
+        binded_self.instance_eval(&block) if block_given?
+      else
+        when_not_authenticated(roles, project, options)
+      end
+    end
+    def save_session_for_current_user sqauthsession
+      @session_provider.create_session_for_current_user sqauthsession
+    end
+    def current_user_ip= ip
+      if @gateway_ip
+        @session_provider.user.user_ip = @gateway_ip
+      else
+        @session_provider.user.user_ip = ip
+      end
+      p @session_provider.user.user_ip
+    end
+    def login_to
+      uri = @session_provider.auth_server_uri
+      uri.path = "#@login_path"
+      uri.to_s
+    end
+  end
+end

data/lib/sq_auth/sq_auth_client.rb ADDED Viewed

@@ -0,0 +1,72 @@
+module SqAuth
+  class SqAuthClient
+    def initialize options = {}
+      @https = !!options[:https]
+      @host = options[:host] || "localhost"
+      @port = (options[:port] || (@https ? 443 : 80)).to_i
+      @username = options[:username]
+      @password = options[:password]
+      @server = options[:server_type] || SqAuth::SqAuthServer::BasicServer
+      @user = options[:user_type] || SqAuth::SqAuthUser::BasicUser.new
+      @sessions = SqAuth::SqAuthSessions.new
+    end
+    def create_session_for_current_user session
+      create_session current_user, session
+    end
+    def session_for_current_user
+      session_for current_user
+    end
+    def check_connection
+      send_request :check_connection
+    end
+    def available?
+      response = check_connection
+      response.is_a?(Hash) && response[:status] == "200"
+    end
+    def role_exist_for_current_user? role, project
+      role_exist? current_user, role, project
+    end
+    def user
+      @user
+    end
+    def current_user
+      @user.current_user
+    end
+    def create_session user, session
+      @sessions[user] = session
+    end
+    def session_for user
+      p @sessions
+      @sessions[user]
+    end
+    def role_exist? user, roles, project
+      request_hash = {sqauthsession: session_for(user), roles: [*roles], auth_name: project, ip: user[:ip]}
+      response = send_request :check_role, request_hash
+      response.is_a?(Hash) && response[:data].is_a?(Hash) && (response[:data]["role_exist"] == true)
+    end
+    def send_request request_name, params = nil
+      @server.send(request_name, params, host_options)
+    end
+    def host_options
+      {host: @host, port: @port, username: @username, password: @password, https: @https}
+    end
+    def auth_server_uri
+      uri_builder = (@https ? URI::HTTPS : URI::HTTP)
+      uri_builder.build(host: @host, port: @port)
+    end
+  end
+end

data/lib/sq_auth/sq_auth_helpers/sq_auth_helpers_dsl.rb ADDED Viewed

@@ -0,0 +1,61 @@
+module SqAuth
+  module SqAuthHelpers
+    module DSL
+      def sq_auth_access &block
+        self.instance_eval &block
+      end
+      def access_actions *actions, &block
+        @sq_auth_actions_only = *actions
+        yield block if block_given?
+        @sq_auth_actions_only = nil
+      end
+      def access_action *action, &block
+        access_actions [*action], &block
+      end
+      def draw_for *roles, &block
+        access_for([*roles], &block)
+      end
+    end
+    module SinatraDSL
+      def show_to *roles
+        create_filter [*roles]
+      end
+      def execute_for *roles
+        create_filter [*roles], {draw: false}
+      end
+    end
+    module RailsDSL
+      def access_actions_except *actions, &block
+        @sq_auth_actions_except = *actions
+        yield block if block_given?
+        @sq_auth_actions_except = nil
+      end
+      def access_action_except *action, &block
+        access_actions_except [*action], &block
+      end
+      def method_missing m, *args, &block
+        begin
+          super
+        rescue NoMethodError
+          if m[/^show_.+_to$/]
+            format = m.to_s.scan(/^show_(.+)_to$/).flatten.first
+            create_filter args, {:format_type => format}
+          else
+            raise NoMethodError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_helpers/sq_auth_helpers_rails.rb ADDED Viewed

@@ -0,0 +1,39 @@
+module SqAuth
+  module SqAuthHelpers
+    module ActionController
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      module ClassMethods
+        include SqAuth::SqAuthHelpers::DSL
+        include SqAuth::SqAuthHelpers::RailsDSL
+        def create_filter roles, options = {}
+          filter_options = {}
+          filter_options[:only] = @sq_auth_actions_only
+          filter_options[:except] = @sq_auth_actions_except
+          before_filter(filter_options) do |controller|
+            format_type = options[:format_type]
+            format_condition = (format_type == "all") || (format_type.nil?) || (controller.request.format.send("#{format_type}?".to_sym))
+            if format_condition
+              error_proc = nil
+              api_options = {}
+              if format_type == "json"
+                error_proc = Proc.new do |message|
+                  render json: message
+                end
+                api_options[:draw] = false
+              else
+                error_proc = Proc.new do |message|
+                  render text: message
+                end
+                api_options[:draw] = true
+              end
+              SqAuth.api_filter(roles, Proc.new {}, error_proc, api_options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_helpers/sq_auth_helpers_sinatra.rb ADDED Viewed

@@ -0,0 +1,25 @@
+module SqAuth
+  module SqAuthHelpers
+    module Sinatra
+      include SqAuth::SqAuthHelpers::SinatraDSL
+      include SqAuth::SqAuthHelpers::DSL
+      def create_filter roles, options = {}
+        action = nil
+        action = [*@sq_auth_actions_only].flatten.first if @sq_auth_actions_only
+        if !roles.empty?
+          ok_proc = Proc.new {}
+          error_proc = Proc.new do |message|
+            throw(:halt, [401, message])
+          end
+          before(action) do
+            SqAuth.api_filter(roles, ok_proc, error_proc, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_integration/sq_auth_action_controller.rb ADDED Viewed

@@ -0,0 +1,16 @@
+module SqAuth
+  module SqAuthIntegration
+    module SqAuthActionController
+      def self.check_environment
+        defined?(ActionController::Base)
+      end
+      def self.alter_environment options={}
+        ActionController::Base.instance_eval do
+          include SqAuth::SqAuthHelpers::ActionController
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_integration/sq_auth_integration.rb ADDED Viewed

@@ -0,0 +1,23 @@
+module SqAuth
+  module SqAuthIntegration
+    def self.alter_environment options = {}
+      @already_altered ||= []
+      alter_modules = SqAuth::SqAuthIntegration.constants.map do |const|
+        alter_module = nil
+        check_module = SqAuth::SqAuthIntegration.const_get(const)
+        if check_module.kind_of?(Module) && check_module.respond_to?(:alter_environment) && check_module.respond_to?(:check_environment)
+          alter_module = check_module
+        end
+        alter_module
+      end.compact
+      alter_modules.each do |m|
+        unless @already_altered.include? m
+          if m.check_environment
+            @already_altered << m
+            m.alter_environment options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_integration/sq_auth_rack.rb ADDED Viewed

@@ -0,0 +1,89 @@
+module SqAuth
+  module SqAuthIntegration
+    module SqAuthRack
+      def self.check_environment
+        defined?(Rack)
+      end
+      def self.alter_environment options={}
+        if defined?(Rails)
+          Rails.application.class.instance_eval do
+            config.middleware.use Rack::Session::Cookie, :expire_after => 2592000
+            config.middleware.use SqAuth::SqAuthIntegration::SqAuthRack::Middleware
+          end
+        else
+          use Rack::Session::Cookie, :expire_after => 2592000
+          use SqAuth::SqAuthIntegration::SqAuthRack::Middleware
+        end
+      end
+      class Middleware
+        attr_accessor :app, :env
+        def call(env)
+          req = Rack::Request.new(env)
+          SqAuth.access.callback = callback_uri(env)
+          SqAuth.access.current_user_ip = env["HTTP_X_FORWARDED_FOR"] || env["REMOTE_ADDR"]
+          SqAuth.access.save_session_for_current_user (env["rack.session"]||{})[:sqauthsession]
+          form_hash = req.params||{}
+          if auth_request?(env, form_hash)
+            redirect_to_callback(env, form_hash)
+          else
+            pass_through env
+          end
+        end
+        def auth_request? env, form_hash
+          env["REQUEST_METHOD"] == "POST" && form_hash.keys.include?("sqauthsession") && form_hash.keys.include?("callback")
+        end
+        def redirect_to_callback env, form_hash
+          env["rack.session"][:sqauthsession] = form_hash["sqauthsession"] if env["rack.session"]
+          SqAuth.access.save_session_for_current_user form_hash["sqauthsession"]
+          [302, {'Location' => form_hash["callback"]}, ['Authenticated']]
+        end
+        def callback_uri env
+          if URI.parse(env["REQUEST_URI"]).host
+            env["REQUEST_URI"]
+          else
+            uri_type = URI.const_get(env["HTTP_X_URL_SCHEME"].upcase) rescue nil
+            uri_type ||= URI.const_get(env["rack.url_scheme"].upcase) rescue nil
+            uri_type ||= URI::HTTP
+            if env["HTTP_HOST"].is_a? String
+              host, port = env["HTTP_HOST"].split(":")
+            end
+            host ||= env["SERVER_NAME"]
+            port ||= env["SERVER_PORT"]
+            path = env["REQUEST_PATH"].to_s
+            if path.empty?
+              path = URI::parse(env["PATH_INFO"]).path rescue ""
+            end
+            if path.empty?
+              path = URI::parse(env["REQUEST_URI"]).path
+            end
+            query = env["QUERY_STRING"]
+            if port
+              uri = uri_type.build(host: host, port: port.to_i, path: path, query: query)
+            else
+              uri = uri_type.build(host: host, path: path, query: query)
+            end
+            uri.to_s
+          end
+        rescue Exception => ex
+          p ex.message
+          return ""
+        end
+        def pass_through env
+          status, headers, response = app.call(env)
+          [status, headers, response]
+        end
+        def initialize(app)
+          @app = app
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_integration/sq_auth_rack_protection.rb ADDED Viewed

@@ -0,0 +1,28 @@
+module SqAuth
+  module SqAuthIntegration
+    module SqAuthRackProtection
+      def self.check_environment
+        defined?(Rack::Protection::RemoteToken)
+      end
+      def self.alter_environment options={}
+        # Sorry, Konstantin
+        except_host = options[:host]
+        Rack::Protection::RemoteToken.class_exec(except_host) do |except|
+          const_set("HOST", except)
+          alias :old_accepts? :accepts?
+          def accepts?(env)
+            form_hash = env["rack.request.form_hash"]||{}
+            if referrer(env) == HOST && env["REQUEST_METHOD"] == "POST" && form_hash.keys.include?("sqauthsession")
+              true
+            else
+              old_accepts?(env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_integration/sq_auth_sinatra.rb ADDED Viewed

@@ -0,0 +1,36 @@
+module SqAuth
+  module SqAuthIntegration
+    module SqAuthSinatra
+      def self.check_environment
+        defined?(Sinatra)
+      end
+      def self.alter_environment options={}
+        Sinatra.register SqAuth::SqAuthHelpers::Sinatra
+        Sinatra::Base.instance_eval do
+          alias :old_get :get
+          def get(*args, &block)
+            roles = []
+            if args[0].is_a?(Array)
+              roles << args[0]
+              args.shift
+            end
+            roles.flatten!
+            if !roles.empty?
+              ok_proc = Proc.new {}
+              error_proc = Proc.new do |message|
+                throw(:halt, [401, message])
+              end
+              before(*args) do
+                SqAuth.api_filter(roles, ok_proc, error_proc)
+              end
+            end
+            old_get(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_request.rb ADDED Viewed

@@ -0,0 +1,88 @@
+module SqAuth
+  class SqAuthRequest
+    def self.hash_to_query hash
+      query = ""
+      encode_chars = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+      if hash.is_a? Hash
+        query = hash.map do |param_name, param_value|
+          if param_value.is_a? Array
+            param_value.map do |v|
+              "#{param_name}[]=#{URI::encode(v.to_s, encode_chars)}"
+            end.join("&")
+          else
+            "#{param_name}=#{URI::encode(param_value.to_s, encode_chars)}"
+          end
+        end.join("&")
+      end
+      query
+    end
+    def self.parse_response response = nil
+      data = nil
+      if response.is_a? Net::HTTPResponse
+        data = {}
+        data[:status] = response.code
+        data[:message] = response.message
+        if response.is_a? Net::HTTPOK
+          data[:data] = begin
+            JSON::load(response.body)
+          rescue JSON::ParserError
+            response.body
+          end
+        end
+      end
+      data
+    end
+    def initialize options
+      @host = options[:host] || raise("Host not specified")
+      @port = options[:port] || 80
+      @username = options[:username]
+      @password = options[:password]
+      path = options[:path]
+      absolute_path = "/"
+      if path.is_a? Symbol
+        absolute_path << path.to_s
+      elsif path.is_a? String
+        absolute_path << path
+      end
+      @path = absolute_path
+      method = options[:method] || :get
+      @https = !!options[:https]
+      @method = ::Net::HTTP.const_get(method.to_s.capitalize)
+      @uri_builder = @https ? URI::HTTPS : URI::HTTP
+    end
+    def setup_query query_hash
+      @query = SqAuthRequest.hash_to_query(query_hash)
+      @uri = @uri_builder.build(host: @host, port: @port, path: @path, query: (@method == Net::HTTP::Get)? @query: nil)
+      @http = Net::HTTP.new(@uri.host, @uri.port)
+      @http.use_ssl = @https
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @https
+    end
+    def request query = {}
+      setup_query(query)
+      response = get_response
+      SqAuthRequest.parse_response response
+    end
+    def get_response
+      request = @method.new(@uri.request_uri)
+      if @username && @password
+        request.basic_auth @username, @password
+      end
+      send_data(request)
+    end
+    def send_data request
+      if @method == Net::HTTP::Post
+        request.body = @query
+        request.content_length = request.body.bytesize
+      end
+      @http.request(request) rescue nil
+    end
+  end
+end

data/lib/sq_auth/sq_auth_server_interface/basic_server.rb ADDED Viewed

@@ -0,0 +1,40 @@
+module SqAuth
+  module SqAuthServer
+    class BasicServer
+      SERVER_INTERFACE = {
+        check_connection: {path: "health", method: :get},
+        check_role: {path: "check_role", method: :post}
+      }
+      def self.init_request specification, host_options = {}
+        options = {}
+        options[:host] = host_options[:host]
+        options[:port] = host_options[:port]
+        options[:username] = host_options[:username]
+        options[:password] = host_options[:password]
+        options[:https] = host_options[:https]
+        options[:path] = specification[:path]
+        options[:method] = specification[:method]
+        SqAuthRequest.new options
+      end
+      def self.sq_auth_host host_options
+        {host: host_options[:host], port: host_options[:port]}
+      end
+      def self.use_interface interface, query, host_options = {}
+        interface[:requests] ||= {}
+        interface[:requests][sq_auth_host(host_options)] ||= init_request(interface, host_options)
+        interface[:requests][sq_auth_host(host_options)].request query
+      end
+      def self.method_missing m, *args, &block
+        if SERVER_INTERFACE[m]
+          use_interface(SERVER_INTERFACE[m], *args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_sessions.rb ADDED Viewed

@@ -0,0 +1,16 @@
+module SqAuth
+  class SqAuthSessions
+    def initialize
+      @sessions = {}
+    end
+    def [] key
+      @sessions[key]
+    end
+    def []= key, value
+      @sessions[key] = value
+    end
+  end
+end

data/lib/sq_auth/sq_auth_user/basic_user.rb ADDED Viewed

@@ -0,0 +1,10 @@
+module SqAuth
+  module SqAuthUser
+    class BasicUser
+      attr_accessor :user_name, :user_ip
+      def current_user
+        {name: (user_name || "Anonymous"), ip: (user_ip || "127.0.0.1")}
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_user/rack_user.rb ADDED Viewed

@@ -0,0 +1,11 @@
+module SqAuth
+  module SqAuthUser
+    class RackUser < BasicUser
+      attr_accessor :user_ip, :user_name
+      def current_user
+        {name: (user_name || "Anonymous"), ip: (user_ip || "127.0.0.1")}
+      end
+    end
+  end
+end

data/lib/sq_auth/sq_auth_utils.rb ADDED Viewed

@@ -0,0 +1,12 @@
+module SqAuth
+  module SqAuthUtils
+    def self.default_draw_template uri, callback, role, project, session
+      <<-EOF
+        <div class="sq_auth_not_logged_in">
+          <iframe src='#{uri}?#{SqAuth::SqAuthRequest.hash_to_query({callback: callback, roles: [*role], auth_name: project, sqauthsession: session})}'>
+          </iframe>
+        </div>
+      EOF
+    end
+   end
+end

data/lib/sq_auth/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module SqAuth
+  VERSION = "0.0.18"
+end

data/lib/sq_auth.rb ADDED Viewed

@@ -0,0 +1,68 @@
+# external dependencies
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'openssl'
+require 'json'
+require 'digest'
+# internal dependencies
+require "sq_auth/version"
+require "sq_auth/sq_auth_access"
+require "sq_auth/sq_auth_client"
+require "sq_auth/sq_auth_request"
+require "sq_auth/sq_auth_sessions"
+require "sq_auth/sq_auth_utils"
+require "sq_auth/sq_auth_server_interface/basic_server"
+require "sq_auth/sq_auth_user/basic_user"
+require "sq_auth/sq_auth_user/rack_user"
+require "sq_auth/sq_auth_integration/sq_auth_integration"
+require "sq_auth/sq_auth_integration/sq_auth_rack"
+require "sq_auth/sq_auth_integration/sq_auth_rack_protection"
+require "sq_auth/sq_auth_integration/sq_auth_sinatra"
+require "sq_auth/sq_auth_integration/sq_auth_action_controller"
+require "sq_auth/sq_auth_helpers/sq_auth_helpers_dsl"
+require "sq_auth/sq_auth_helpers/sq_auth_helpers_rails"
+require "sq_auth/sq_auth_helpers/sq_auth_helpers_sinatra"
+module SqAuth
+  @session_access = SqAuth::SqAuthAccess.new
+  def self.connect(*args, &block)
+    @session_access.connect(*args, &block)
+  end
+  def self.access
+    @session_access
+  end
+  def self.with_sq_auth(*args, &block)
+    @session_access.with_sq_auth(*args, &block)
+  end
+  def self.api_filter(roles, ok_proc, error_proc, options = {})
+    @session_access.api_filter(roles, SqAuth.access.project_name, ok_proc, error_proc, options)
+  end
+  def self.included(base)
+    base.send :include, InstanceMethods
+  end # self.included
+  module InstanceMethods
+    def access_for(*roles, &block)
+      SqAuth.with_sq_auth([*roles], SqAuth.access.project_name, {:binding => binding}, &block)
+    end
+    alias :draw_for :access_for
+    def accessed_by?(*roles)
+      SqAuth.access.sq_auth_filter([*roles])
+    end
+    def not_accessible_message
+      SqAuth.access.message_when_not_authenticated
+    end
+    def not_accessible_link(*roles)
+      SqAuth.access.draw_when_not_authenticated(roles)
+    end
+  end
+end
+include SqAuth

data/spec/lib/sq_auth/sq_auth_client_spec.rb ADDED Viewed

@@ -0,0 +1,30 @@
+require File.expand_path('spec/spec_helper')
+describe SqAuth::SqAuthClient do
+  let(:client) {SqAuth::SqAuthClient.new}
+  let(:user1) { {name: "user1", ip: "234.24.23.1" } }
+  let(:user2) { {name: "user2", ip: "234.24.23.2" } }
+  let(:user3) { {name: "user3", ip: "234.24.23.3" } }
+  it "saves user session" do
+    SqAuth::SqAuthUser::BasicUser.stub(:current_user).and_return(user1)
+    client.create_session_for_current_user(Digest::MD5.digest(user1.to_s)).should_not == nil
+  end
+  it "checks for existance of user session" do
+    client.session_for(user2).should == nil
+    SqAuth::SqAuthUser::BasicUser.stub(:current_user).and_return(user3)
+    user3_session = client.create_session_for_current_user(Digest::MD5.digest(user3.to_s))
+    client.session_for_current_user.should == user3_session
+  end
+  it "sends check request to auth server" do
+    client.stub(:send_request).with(:check_connection).and_return("ok")
+    client.check_connection.should_not == nil
+  end
+  it "checks for role for sessioned user" do
+    client.stub(:send_request).with(:check_role, {sqauthsession: client.session_for_current_user, roles: ["role"], auth_name: "project", ip: "127.0.0.1"}).and_return("ok")
+    client.role_exist_for_current_user?("role", "project").should_not == nil
+  end
+end

data/spec/lib/sq_auth/sq_auth_request_spec.rb ADDED Viewed

@@ -0,0 +1,40 @@
+require File.expand_path('spec/spec_helper')
+describe SqAuth::SqAuthRequest do
+  it 'convert hashes to http query strings' do
+    query_hash1 = {a: 1, b: "Hello", c: [123, "A B C", "+++"]}
+    query_string1 = "a=1&b=Hello&c[]=123&c[]=A%20B%20C&c[]=%2B%2B%2B"
+    SqAuth::SqAuthRequest.hash_to_query(query_hash1).should == query_string1
+    SqAuth::SqAuthRequest.hash_to_query({}).should == ""
+    SqAuth::SqAuthRequest.hash_to_query(nil).should == ""
+    SqAuth::SqAuthRequest.hash_to_query([1,2,3,4]).should == ""
+  end
+  it 'parse http responses' do
+    example_ok = Net::HTTPOK.new(1.1, '200', 'Ok')
+    example_ok.stub(:body).and_return("{\"a\": 1}")
+    SqAuth::SqAuthRequest.parse_response(example_ok).should == {status: "200", message: "Ok", data: {"a" => 1}}
+    example_error = Net::HTTPNotFound.new(1.1, '404', 'Page not found')
+    SqAuth::SqAuthRequest.parse_response(example_error).should == {status: "404", message: "Page not found"}
+    example_ok_with_not_json_body = Net::HTTPOK.new(1.1, '200', 'Ok')
+    example_ok.stub(:body).and_return("<title>Test</title><body>Body of the page</body>")
+    SqAuth::SqAuthRequest.parse_response(example_ok).should == {status: "200", message: "Ok", data: "<title>Test</title><body>Body of the page</body>"}
+  end
+  it 'should not fail if host unreachable' do
+    request = SqAuth::SqAuthRequest.new(host: "fake", path: "health", method: "get")
+    lambda {request.request({a: 1, b: 2})}.should_not raise_error
+  end
+  it 'send request to sq_auth server and parses response' do
+    request = SqAuth::SqAuthRequest.new(host: "localhost", path: "", method: "get")
+    example_ok = Net::HTTPOK.new(1.1, '200', 'Ok')
+    example_ok.stub(:body).and_return("{\"a\": 1}")
+    request.stub(:send_data).with(kind_of(Net::HTTP::Get)).and_return(example_ok)
+    request.request({}).should == {status: "200", message: "Ok", data: {"a" => 1}}
+  end
+end

data/spec/lib/sq_auth/sq_auth_server_interface/basic_server_spec.rb ADDED Viewed

@@ -0,0 +1,24 @@
+require File.expand_path('spec/spec_helper')
+describe SqAuth::SqAuthServer::BasicServer do
+  it 'should create request to custom sq_auth server once per server and send data to server by created request' do
+    host_options = {host: "localhost", port: 80}
+    interface = SqAuth::SqAuthServer::BasicServer::SERVER_INTERFACE[:check_connection]
+    mock_req = SqAuth::SqAuthRequest.new(host_options.merge({method: :get, path: "health"}))
+    # should create 2 requests: localhost/check_connection and localhost/check_role
+    SqAuth::SqAuthRequest.should_receive(:new).exactly(2).and_return(mock_req)
+    to_return = {status: "200", message: "Ok", data: {"a" => 1}}
+    # should send data 3 times by 2 request requests: localhost/check_connection, localhost/check_connection, and localhost/check_role
+    mock_req.should_receive(:request).exactly(3).and_return(to_return)
+    SqAuth::SqAuthServer::BasicServer.check_connection({}, host_options)[:data].should == {"a" => 1}
+    SqAuth::SqAuthServer::BasicServer.check_connection({}, host_options)[:data].should == {"a" => 1}
+    SqAuth::SqAuthServer::BasicServer.check_role({}, host_options)[:data].should == {"a" => 1}
+    SqAuth::SqAuthServer::BasicServer::SERVER_INTERFACE[:check_connection][:requests][host_options].should be_a_kind_of SqAuth::SqAuthRequest
+    SqAuth::SqAuthServer::BasicServer::SERVER_INTERFACE[:check_role][:requests][host_options].should be_a_kind_of SqAuth::SqAuthRequest
+  end
+end

data/spec/lib/sq_auth/sq_auth_sessions_spec.rb ADDED Viewed

@@ -0,0 +1,3 @@
+describe SqAuth::SqAuthSessions do
+end

data/spec/lib/sq_auth/sq_auth_user/basic_user_spec.rb ADDED Viewed

@@ -0,0 +1,5 @@
+require File.expand_path('spec/spec_helper')
+describe SqAuth::SqAuthUser::BasicUser do
+end

data/spec/lib/sq_auth_spec.rb ADDED Viewed

@@ -0,0 +1,5 @@
+require 'spec_helper'
+describe SqAuth do
+end

data/spec/spec_helper.rb ADDED Viewed

	@@ -0,0 +1 @@
1	+ require 'sq_auth'

data/sq_auth.gemspec ADDED Viewed

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sq_auth/version"
+Gem::Specification.new do |s|
+  s.name        = "sq_auth"
+  s.version     = SqAuth::VERSION
+  s.authors     = ["Leonid Krinitsyn"]
+  s.email       = ["leonidkrn@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{SQ sevices authentication gem}
+  s.description = %q{SQ sevices authentication gem}
+  s.rubyforge_project = "sq_auth"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'sinatra'
+end

metadata ADDED Viewed

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: sq_auth
+version: !ruby/object:Gem::Version
+  version: 0.0.18
+  prerelease:
+platform: ruby
+authors:
+- Leonid Krinitsyn
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-04-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: SQ sevices authentication gem
+email:
+- leonidkrn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- examples/client.rb
+- examples/server.rb
+- lib/sq_auth.rb
+- lib/sq_auth/sq_auth_access.rb
+- lib/sq_auth/sq_auth_client.rb
+- lib/sq_auth/sq_auth_helpers/sq_auth_helpers_dsl.rb
+- lib/sq_auth/sq_auth_helpers/sq_auth_helpers_rails.rb
+- lib/sq_auth/sq_auth_helpers/sq_auth_helpers_sinatra.rb
+- lib/sq_auth/sq_auth_integration/sq_auth_action_controller.rb
+- lib/sq_auth/sq_auth_integration/sq_auth_integration.rb
+- lib/sq_auth/sq_auth_integration/sq_auth_rack.rb
+- lib/sq_auth/sq_auth_integration/sq_auth_rack_protection.rb
+- lib/sq_auth/sq_auth_integration/sq_auth_sinatra.rb
+- lib/sq_auth/sq_auth_request.rb
+- lib/sq_auth/sq_auth_server_interface/basic_server.rb
+- lib/sq_auth/sq_auth_sessions.rb
+- lib/sq_auth/sq_auth_user/basic_user.rb
+- lib/sq_auth/sq_auth_user/rack_user.rb
+- lib/sq_auth/sq_auth_utils.rb
+- lib/sq_auth/version.rb
+- spec/lib/sq_auth/sq_auth_client_spec.rb
+- spec/lib/sq_auth/sq_auth_request_spec.rb
+- spec/lib/sq_auth/sq_auth_server_interface/basic_server_spec.rb
+- spec/lib/sq_auth/sq_auth_sessions_spec.rb
+- spec/lib/sq_auth/sq_auth_user/basic_user_spec.rb
+- spec/lib/sq_auth_spec.rb
+- spec/spec_helper.rb
+- sq_auth.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: sq_auth
+rubygems_version: 1.8.18
+signing_key:
+specification_version: 3
+summary: SQ sevices authentication gem
+test_files: []