neo4j-core 4.0.2 → 4.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bfca28f803d39a083c8ef36ef73f69e720831c5
-  data.tar.gz: 1675ae950c4b9bd41a81ac3c0c56cf7ec69cbef3
+  metadata.gz: fc288b3293def30d9acf103f70ca43e2d1cfebc9
+  data.tar.gz: 73225366c230a39f0dff61dd9e6497229251c478
 SHA512:
-  metadata.gz: 3a800675d859b17567d45d0ff130eb8120ed9c7a28aeaada979c98a4fd0713b94d003814d9ca003c4e9da56a3e125af30f06248285f50f7992008ed412943e96
-  data.tar.gz: 9968cd19aa2c193095b5cf3e653833bb1bed56e0ebd2129ddc3aa7598bd207bf9f1057ef366cfd1ef37a3d07f24d75ad318e2b208a9eae00cb93d447e00e9fe2
+  metadata.gz: 8a8ad456a8528cf852f3c8ca451c3853bcd264f182ddd2baf6361318ec8d04fb3a2351b5fd714cc9eba17be197cbc14119faa5021d973dfb2d18a3b7a1c5f054
+  data.tar.gz: 738ce2b663d3d5fb483ead05725c5bc1a624452bab4341cf3dd2987be0bfab131e4cd68b176c15a23cd148d6309ed253fc33dad51bc7cd22e77554bae2e549cd

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = '4.0.2'
+    VERSION = '4.0.3'
   end
 end

data/lib/neo4j-server.rb

@@ -4,7 +4,6 @@ require 'faraday_middleware'
 require 'neo4j-server/resource'
 require 'neo4j-server/cypher_node'
 require 'neo4j-server/cypher_label'
-require 'neo4j-server/cypher_authentication'
 require 'neo4j-server/cypher_session'
 require 'neo4j-server/cypher_node_uncommited'
 require 'neo4j-server/cypher_relationship'

data/lib/neo4j-server/cypher_session.rb

@@ -10,11 +10,10 @@ module Neo4j
       include Neo4j::Core::CypherTranslator
 
       alias_method :super_query, :query
-      attr_reader :connection, :auth
+      attr_reader :connection
 
-      def initialize(data_url, connection, auth_obj = nil)
+      def initialize(data_url, connection)
         @connection = connection
-        @auth = auth_obj if auth_obj
         Neo4j::Session.register(self)
         initialize_resource(data_url)
         Neo4j::Session._notify_listeners(:session_available, self)
@@ -47,17 +46,15 @@ module Neo4j
         extract_basic_auth(endpoint_url, params)
         connection = params[:connection] || create_connection(params)
         url = endpoint_url || 'http://localhost:7474'
-        auth_obj = CypherAuthentication.new(url, connection, params)
-        auth_obj.authenticate
         response = connection.get(url)
         fail "Server not available on #{url} (response code #{response.status})" unless response.status == 200
-        establish_session(response.body, connection, auth_obj)
+        establish_session(response.body, connection)
       end
 
-      def self.establish_session(root_data, connection, auth_obj)
+      def self.establish_session(root_data, connection)
         data_url = root_data['data']
         data_url << '/' unless data_url.nil? || data_url.end_with?('/')
-        CypherSession.new(data_url, connection, auth_obj)
+        CypherSession.new(data_url, connection)
       end
 
       def self.extract_basic_auth(url, params)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-core
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 4.0.3
 platform: ruby
 authors:
 - Andreas Ronge, Chris Grigg, Brian Underwood
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-01 00:00:00.000000000 Z
+date: 2015-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -240,7 +240,6 @@ files:
 - lib/neo4j-embedded/property.rb
 - lib/neo4j-embedded/to_java.rb
 - lib/neo4j-server.rb
-- lib/neo4j-server/cypher_authentication.rb
 - lib/neo4j-server/cypher_label.rb
 - lib/neo4j-server/cypher_node.rb
 - lib/neo4j-server/cypher_node_uncommited.rb
@@ -287,7 +286,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A basic library to work with the graph database Neo4j.

data/lib/neo4j-server/cypher_authentication.rb

@@ -1,125 +0,0 @@
-module Neo4j
-  module Server
-    # Neo4j 2.2 has an authentication layer. This class provides methods for interacting with it.
-    class CypherAuthentication
-      class InvalidPasswordError < RuntimeError; end
-      class PasswordChangeRequiredError < RuntimeError; end
-      class MissingCredentialsError < RuntimeError; end
-
-      attr_reader :connection, :url, :params, :token
-
-      # @param [String] url_string The server address with protocol and port.
-      # @param [Faraday::Connection] session_connection A Faraday::Connection object. This is either an existing object, likely the
-      # same object used by the server for data, or a new one created specifically for auth tasks.
-      # @param [Hash] params_hash Faraday connection options. In particularly, we're looking for basic_auth creds.
-      def initialize(url_string, session_connection = new_connection, params_hash = {})
-        @url = url_string
-        @connection = session_connection
-        @params = params_hash
-      end
-
-      # Set the username and password used to communicate with the server.
-      def basic_auth(username, password)
-        params[:basic_auth] ||= {}
-        params[:basic_auth][:username] = username
-        params[:basic_auth][:password] = password
-      end
-
-      # POSTs to the password change endpoint of the API. Does not invalidate tokens.
-      # @param [String] old_password The current password.
-      # @param [String] new_password The password you want to use.
-      # @return [Hash] The response from the server.
-      def change_password(old_password, new_password)
-        connection.post("#{url}/user/neo4j/password",  'password' => old_password, 'new_password' => new_password).body
-      end
-
-      # Uses the given username and password to obtain a token, then adds the token to the connection's parameters.
-      # @return [String] An access token provided by the server.
-      def authenticate
-        auth_response = auth_connection("#{url}/authentication")
-        auth_hash = if auth_response.status == 404 || auth_response.body.empty?
-                      nil
-                    elsif auth_response.body.is_a?(String)
-                      JSON.parse(auth_response.body)['errors'][0]['code'] == 'Neo.ClientError.Security.AuthorizationFailed' ? auth_attempt : nil
-                    else
-                      auth_response
-                    end
-        return nil if auth_hash.nil?
-        add_auth_headers(token_or_error(auth_hash))
-      end
-
-      # Invalidates the existing token, which will invalidate all conncetions using this token, applies for a new token, adds this into
-      # the connection headers.
-      # @param [String] password The current server password.
-      def reauthenticate(password)
-        invalidate_token(password)
-        add_auth_headers(token_or_error(auth_attempt))
-      end
-
-      # Requests a token from the authentication endpoint using the given username and password.
-      # @return [Faraday::Response] The server's response, to be interpreted.
-      def auth_attempt
-        begin
-          user = params[:basic_auth][:username]
-          pass = params[:basic_auth][:password]
-        rescue NoMethodError
-          raise MissingCredentialsError, 'Neo4j authentication is enabled, username/password are required but missing'
-        end
-        connection.post("#{url}/authentication",  'username' => user, 'password' => pass)
-      end
-
-      # Takes a response object from the server and returns a token or fails with an error.
-      # TODO: more error states!
-      # @param [Farday::Response] auth_response The response after attempting authentication
-      # @return [String] An authentication token.
-      def token_or_error(auth_response)
-        begin
-          fail PasswordChangeRequiredError, "Server requires a password change, please visit #{url}" if auth_response.body['password_change_required']
-          fail InvalidPasswordError, "Neo4j server responded with: #{auth_response.body['errors'][0]['message']}" if auth_response.status.to_i == 422
-        rescue NoMethodError
-          raise 'Unexpected auth response, please open an issue at https://github.com/neo4jrb/neo4j-core/issues'
-        end
-        auth_response.body['authorization_token']
-      end
-
-      # Invalidates tokens as described at http://neo4j.com/docs/snapshot/rest-api-security.html#rest-api-invalidating-the-authorization-token
-      # @param [String] current_password The current password used to connect to the database
-      def invalidate_token(current_password)
-        connection.post("#{url}/user/neo4j/authorization_token",  'password' => current_password).body
-      end
-
-      # Stores an authentication token in the properly-formatted header.
-      # This does not do any checking that what it has been given is a token. Whatever param is given will be base64 encoded and used as the header.
-      # @param [String] token The authentication token provided by the database.
-      def add_auth_headers(token)
-        @token = token
-        connection.headers['Authorization'] = "Basic realm=\"Neo4j\" #{token_hash(token)}"
-      end
-
-      private
-
-      # Makes testing easier, we can stub this method to simulate different responses
-      def auth_connection(url)
-        connection.get(url)
-      end
-
-      def self.new_connection
-        conn = Faraday.new do |b|
-          b.request :json
-          b.response :json, content_type: 'application/json'
-          b.use Faraday::Adapter::NetHttpPersistent
-        end
-        conn.headers = {'Content-Type' => 'application/json'}
-        conn
-      end
-
-      def new_connection
-        self.class.new_connection
-      end
-
-      def token_hash(token)
-        ::Base64.strict_encode64(":#{token}")
-      end
-    end
-  end
-end