lotus-auth0 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 393b6026dcc47cf6506f8f188c20950e00f06f80
+  data.tar.gz: fa22122c30c19d5c990d920d90ab2387b7d2523f
+SHA512:
+  metadata.gz: 3b03145ac650298cf217ff1e1b9faa86ac1255f9d94b920b77f8227e67f48fecff82bf54a198bf44c9a2b7b390507485000580f82747f90ee395e3f40ca8287d
+  data.tar.gz: 5b3989e0da8cdffc14c146324d0836e4e6a6e33fc0f5d95ed6c6811a6f536c361e2ca53ed6deeeaecab43f6a310bc34677d8827dcfaf821da45a72769dd64b91

data/lib/lotus/auth0/version.rb

@@ -0,0 +1,5 @@
+module Lotus
+  module Auth0
+    VERSION = '0.0.2'
+  end
+end

data/lib/lotus/model/adapters/auth0/collection.rb

@@ -0,0 +1,114 @@
+require 'forwardable'
+require 'lotus/utils/kernel'
+
+module Lotus
+  module Model
+    module Adapters
+      module Auth0
+        class Collection
+          attr_reader :client
+
+          InvalidCollectionName = Class.new(StandardError)
+
+          def initialize(_mapped_collection, _name, _identity)
+            raise InvalidCollectionName unless allowed_collection_names.include?(_name.to_s)
+
+            @client_token  = ENV['AUTH0_TOKEN']
+            @client_domain = ENV['AUTH0_DOMAIN']
+
+            @client = Auth0Client.new(
+              api_version: 2,
+              token: @client_token,
+              domain: @client_domain
+            )
+
+            @mapped_collection = _mapped_collection
+            @name = _name
+            @identity = _identity
+          end
+
+          def search(query, options = {})
+            results = case @name
+            when :users
+              # def users( per_page: nil, page: nil, include_totals: nil, sort: nil, connection: nil, fields: nil, q: nil )
+              @client.users(q: query.to_s, page: options[:offset], per_page: options[:limit])
+            when :connections
+              results = @client.connections
+              query.conditions.each do |condition|
+                case condition.type
+                when :where
+                  results.reject! { |result| result[condition.key.to_s] != condition.value }
+                  results
+                when :or
+                  raise "#{@name} does not support this query condition"
+                end
+              end
+              results
+            else
+              raise NotImplementedError, 'This collection can not be searched'
+            end
+            results
+          end
+
+          def insert(entity)
+            inserted_entity  = case @name
+            when :users
+              entity.delete(:identities)
+              @client.create_user(entity[:name], entity)
+            when :connections
+              @client.create_connection(entity)
+            end
+
+            inserted_entity
+          end
+
+          def update(entity)
+            updated_entities  = case @name
+            when :users
+              # We can't modify these
+              entity.delete(:identities)
+              entity.delete(:name)
+
+              id = entity.delete(identity)
+              @client.patch_user(id, entity)
+            end
+
+            updated_entities
+          end
+
+          def delete(entity)
+            deleted_entity  = case @name
+            when :users
+              id = entity.delete(identity)
+              @client.delete_user(id)
+            when :connections
+              id = entity.delete(identity)
+              @client.delete_connection(id)
+            end
+          end
+
+          def truncate
+            case @name
+            when :users
+              @client.delete_users
+            when :connections
+              @client.connections.each do |connection|
+                @client.delete_connection(connection['id'])
+              end
+            end
+          end
+
+          private
+
+          def allowed_collection_names
+            %w(users connections)
+          end
+
+          def identity
+            @mapped_collection.identity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/adapters/auth0/command.rb

@@ -0,0 +1,57 @@
+require 'forwardable'
+require 'lotus/utils/kernel'
+
+module Lotus
+  module Model
+    module Adapters
+      module Auth0
+        class Command
+          def initialize(_collection, _mapped_collection)
+            @collection         = _collection
+            @mapped_collection  = _mapped_collection
+          end
+
+          def create(entity)
+            serialized_entity            = _serialize(entity)
+            created_entity               = @collection.insert(serialized_entity)
+            # oh no
+            # @todo deep_symbolize_keys!
+            created_entity               = eval(created_entity.to_s.gsub(/\"(\w+)\"(?==>)/, ':\1'))
+            _deserialize(created_entity)
+          end
+
+          def update(entity)
+            serialized_entity            = _serialize(entity)
+            updated_entity               = @collection.update(serialized_entity)
+            updated_entity               = eval(updated_entity.to_s.gsub(/\"(\w+)\"(?==>)/, ':\1'))
+            _deserialize(updated_entity)
+          end
+
+          def delete(entity)
+            serialized_entity            = _serialize(entity)
+            @collection.delete(serialized_entity)
+          end
+
+          def truncate
+            @collection.truncate
+          end
+
+          private
+
+          def _serialize(entity)
+            @mapped_collection.serialize(entity)
+          end
+
+          def _deserialize(entity)
+            @mapped_collection.deserialize([entity]).first
+          end
+
+          def _identity
+            @mapped_collection.identity
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/lotus/model/adapters/auth0/lucene_query.rb

@@ -0,0 +1,90 @@
+require 'forwardable'
+require 'lotus/utils/kernel'
+
+module Lotus
+  module Model
+    module Adapters
+      module Auth0
+        class LuceneQuery
+          class Where
+            attr_accessor :condition
+
+            def initialize(_condition)
+              @condition = _condition
+            end
+
+            def key
+              condition.keys.first
+            end
+
+            def value
+              condition.values.first
+            end
+
+            def type
+              :where
+            end
+
+            def to_s
+              "#{key}:#{value}"
+            end
+          end
+
+          class Or
+            attr_accessor :condition
+
+            def initialize(_condition)
+              @condition = _condition
+            end
+
+            def to_s
+              "#{condition.keys.first}:#{condition.values.first}"
+            end
+          end
+
+          def initialize(_conditions)
+            @conditions = _conditions
+          end
+
+          def to_s
+            previous_condition = nil
+            result             = ''
+
+            conditions.each do |condition|
+              case previous_condition
+              when Where
+                if condition.is_a?(Or)
+                  result = "(#{result}) OR #{condition}"
+                else
+                  result = "#{result} AND #{condition}"
+                end
+              when Or
+                lhs, rhs = result.split('OR')
+                result = [lhs, "(#{[condition, rhs].join(' AND ')})"].join(' OR ')
+              else
+                result = condition.to_s
+              end
+
+              previous_condition = condition
+            end
+
+            result
+          end
+
+          def conditions
+            (@conditions || []).collect do |condition_type, condition|
+              raise ArgumentError, 'condition is invalid' if condition.keys.count > 1 || condition.values.count > 1
+
+              case condition_type
+              when :where, :and
+                Where.new(condition)
+              when :or
+                Or.new(condition)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/adapters/auth0/query.rb

@@ -0,0 +1,82 @@
+require 'uri'
+require 'lotus/utils/kernel'
+
+module Lotus
+  module Model
+    module Adapters
+      module Auth0
+        class Query
+          attr_reader :conditions
+
+          def initialize(collection, mapped_collection, context = nil, &block)
+            @collection, @mapped_collection, @context = collection, mapped_collection, context
+
+            @conditions = []
+            @limit = nil
+            @sort_order = nil
+            @sort_key = nil
+            @offset = nil
+
+            instance_eval(&block) if block_given?
+          end
+
+          def all
+            _deserialize(run)
+          end
+
+          def limit(limit)
+            @limit = limit
+            all
+          end
+
+          def sort(*args)
+            if args[-1].is_a?(Array)
+              @sort_order = args.pop
+            end
+            raise ArgumentError, 'you can only sort on one key' unless args.count == 1
+            @sort_key = args.first
+          end
+
+          def offset(num)
+            @offset = num
+          end
+
+          def where(condition = nil, &block)
+            _push_to_conditions(:where, condition || blk)
+            self
+          end
+          alias :and :where
+
+          def or(condition = nil, &block)
+            _push_to_conditions(:or, condition || blk)
+            self
+          end
+
+          private
+
+          def run
+            @collection.search(
+              LuceneQuery.new(conditions), {
+                offset: @offset,
+                limit:  @limit,
+                sort_order: @sort_order,
+                sort_key: @sort_key
+              })
+          end
+
+          def _push_to_conditions(type, condition)
+            raise ArgumentError.new('You need to specify a condition.') if condition.nil?
+
+            conditions.push([type, condition])
+          end
+
+          def _deserialize(entity)
+            entity = [entity] unless entity.is_a?(Array)
+            entity = eval(entity.to_s.gsub(/\"(\w+)\"(?==>)/, ':\1'))
+            @mapped_collection.deserialize(entity)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/adapters/auth0_adapter.rb

@@ -0,0 +1,65 @@
+require 'lotus/model/adapters/abstract'
+require 'lotus/model/adapters/implementation'
+
+require 'lotus/model/adapters/auth0/query'
+require 'lotus/model/adapters/auth0/collection'
+require 'lotus/model/adapters/auth0/command'
+require 'lotus/model/adapters/auth0/lucene_query'
+
+require 'auth0'
+
+module Lotus
+  module Model
+    module Adapters
+      class Auth0Adapter < Abstract
+        include Implementation
+
+        def initialize(mapper, uri = nil)
+          super
+
+          @collections = {}
+        end
+
+        def create(collection, entity)
+          command(collection).create(entity)
+        end
+
+        def update(collection, entity)
+          command(collection).update(entity)
+        end
+
+        def delete(collection, entity)
+          command(collection).delete(entity)
+        end
+
+        def clear(collection)
+          command(collection).truncate
+        end
+
+        def command(collection)
+          Auth0::Command.new(_collection(collection),
+                             _mapped_collection(collection))
+        end
+
+        def query(collection, context = nil, &blk)
+          Auth0::Query.new(_collection(collection),
+                           _mapped_collection(collection), &blk)
+        end
+
+        private
+
+        def _collection(name)
+          @collections[name] ||= Auth0::Collection.new(
+            _mapped_collection(name),
+            name,
+            _identity(name),
+          )
+        end
+
+        def _identity(_name)
+          _mapped_collection(_name).identity
+        end
+      end
+    end
+  end
+end

data/lib/lotus-auth0.rb

@@ -0,0 +1,10 @@
+require 'lotus/model'
+require 'lotus/entity'
+
+require 'lotus/auth0/version'
+require 'lotus/model/adapters/auth0_adapter'
+
+module Lotus
+  module Auth0
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: lotus-auth0
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Taylor Finnell
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: auth0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Auth0 integration for the Lotus framework
+email:
+- tmfinnell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lotus-auth0.rb
+- lib/lotus/auth0/version.rb
+- lib/lotus/model/adapters/auth0/collection.rb
+- lib/lotus/model/adapters/auth0/command.rb
+- lib/lotus/model/adapters/auth0/lucene_query.rb
+- lib/lotus/model/adapters/auth0/query.rb
+- lib/lotus/model/adapters/auth0_adapter.rb
+homepage: https://github.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Auth0 integration for the Lotus framework
+test_files: []
+has_rdoc: