orcid 0.0.4 → 0.1.0

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - "2.0.0"
+
+env:
+  global:
+  - NOKOGIRI_USE_SYSTEM_LIBRARIES=true
+
+script: 'rake spec:travis'
+
+bundler_args: --without headless debug
+
+before_install:
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in orcid.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/README.md

@@ -1,23 +1,124 @@
 # Orcid [![Version](https://badge.fury.io/rb/orcid.png)](http://badge.fury.io/rb/orcid) [![Build Status](https://travis-ci.org/jeremyf/orcid.png?branch=master)](https://travis-ci.org/jeremyf/orcid)
 
+A [Rails Engine](https://guides.rubyonrails.org/engines.html) for integrating with [Orcid](https://orcid.org).
 
-A Rails Engine for integrating with Orcid
+To fully interact with the Orcid remote services, you will need to [register your ORCID application profile](#registering-for-an-orcid-application-profile).
+
+* [Installation](#installation)
+* [Using the Orcid widget in your application](#using-the-orcid-widget-in-your-application)
+* [Registering for an ORCID application profile](#registering-for-an-orcid-application-profile)
+* [Setting up your own ORCIDs in the ORCID Development Sandbox](#setting-up-your-own-orcids-in-the-orcid-development-sandbox)
+* [Running the tests](#running-the-tests)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'orcid'
+```ruby
+gem 'orcid'
+```
 
 And then execute:
 
-    $ bundle
+```console
+$ bundle
+```
+
+If bundle fails, you may need to [install Qt](https://github.com/thoughtbot/capybara-webkit/wiki/Installing-Qt-and-compiling-capybara-webkit).
+
+And then install by running the following:
+
+```console
+$ rails generate orcid:install
+```
+
+*Note: It will prompt you for your Orcid application secrets.*
+
+You may find it helpful to review the help text, as there are a few options for the generator.
+
+```console
+$ rails generate orcid:install -h
+```
+
+## Using the Orcid widget in your application
+
+In order to facilitate integration of this ORCID gem into your application, a widget has been provided to offer these functions:
+
+1. Enter a known ORCID and connect to the ORCID repository.
+1. Look up the ORCID of the current user of your application.
+1. Create an ORCID to be associated with the current user of your application.
+
+The widget is contained in the partial `app/views/orcid/profile_connections/_orcid_connector.html.erb`.
+
+An example use of the partial is shown below.
+
+```ruby
+# The `if defined?(Orcid)` could be viewed as a courtesy.
+# Don't attempt to render this partial if the Orcid gem is not being used.
+if defined?(Orcid)
+  <%= render partial: 'orcid/profile_connections/orcid_connector', locals: {default_search_text: current_user.name } %>
+end
+```
+
+## Registering for an ORCID application profile
+
+Your application which will interface with ORCID must be registered with ORCID.  Note that you will want to register your production
+application separately from the development sandbox.
+
+1. Go to http://support.orcid.org/knowledgebase/articles/116739-register-a-client-application
+1. Read the information on the entire page, in particular, the 'Filling in the client application form' and 'About Redirect URIs' sections.
+1. Click on 'register a client application', http://orcid.org/organizations/integrators/create-client-application
+1. There you will be given a choice of registering for the Development Sandbox or the Production Registry.
+1. Fill in the other information as appropriate for your organization.  If you are doing development, select Development Sandbox.
+1. For the URL of the home page of your application, you must use an https:// URL.  If you are going to be doing development work locally
+on your own machine where your application's server will run, enter https://localhost:3000 for the URL of your home page (or as appropriate
+to your local development environment).  See **NOTE: Application home page URL** below.
+1. You must enter at least one Redirect URI, which should be https://localhost:3000/users/auth/orcid/callback
+1. Another suggested Redirect URI is https://developers.google.com/oauthplayground
+
+Within a day or so, you will receive an email with an attached xml file containing the client-id and client-secret which must be used in the application.yml
+file discussed below.
+
+### NOTE: Application home page URL
+You must enter the same URL for the application home page on the form as you would enter into your browser.  For example, if you specify "https://localhost:3000" on
+the ORCID registration form, then you MUST invoke your application via the browser with "https://localhost:3000" in order for all of the ORCID functionality to work.
+
+For development work in particular, there are multiple ways to specify the local machine: 127.0.0.1, ::1, 192.168.1.1, and localhost.  It is strongly recommended that you use 'localhost'
+in the ORCID form's URL for your application and when invoking your application from the browser rather than using any IP address for your local machine.
+
+## Setting up your own ORCIDs in the ORCID Development Sandbox
+
+[Read more about the ORCID Sandbox](http://support.orcid.org/knowledgebase/articles/166623-about-the-orcid-sandbox).
+
+1. Register two ORCID users: https://sandbox-1.orcid.org/register (make sure to use <blah>@mailinator.com as your email)
+Save the email addresses, orcid ids, and passwords for editing the application.yml later.
+1. Go to mailinator (http://mailinator.com/) and claim 1 ORCID by clicking the verify link in the email.
+1. Go to the ORCID sandbox https://sandbox.orcid.org, log in and click on *Account Settings* (https://sandbox.orcid.org/account).  On the Account Settings page,
+click on Email and select the little icon with the group of heads to make your Primary Email publicly accessible.
+
+## Setting up the config/application.yml file
+Customize the sample application.yml file by first copying it to config/application.yml and opening it for editing.
+
+```console
+$ cp config/application.yml.sample config/application.yml
+```
+
+## Running the tests
+
+Run `rake` to generate the dummy app and run the offline tests.
+
+To run the online tests, you'll need ORCID application credentials:
 
-And then install:
+1. Register for an ORCID app. See **Registering for an ORCID application profile** above.  (This may take several days to complete.)
+1. Register two ORCID users in the ORCID Development Sandbox.  See **Setting up your own ORCIDs in the ORCID Development Sandbox** above.
+1. Update the application.yml with your information.  See **Setting up the config/application.yml file** above.
 
-    $ rails generate orcid:install
+Run the online tests with
 
+```console
+$ rake spec:online
+```
 
 ## TODO Items
 
-* When searching for your profile, expose Name and associated DOI as query parameters.
+* When searching for your profile, expose Name and associated DOI as query parameters.

data/Rakefile

@@ -8,7 +8,7 @@ Bundler::GemHelper.install_tasks
 
 
 begin
-  APP_RAKEFILE = File.expand_path("../spec/internal/Rakefile", __FILE__)
+  APP_RAKEFILE = File.expand_path('../spec/internal/Rakefile', __FILE__)
   load 'rails/tasks/engine.rake'
 rescue LoadError
   puts "Unable to load all app tasks for #{APP_RAKEFILE}"
@@ -18,30 +18,38 @@ require 'engine_cart/rake_task'
 require 'rspec/core/rake_task'
 
 namespace :spec do
-  RSpec::Core::RakeTask.new(:all) do |t|
+  RSpec::Core::RakeTask.new(:all) do
     ENV['COVERAGE'] = 'true'
   end
   desc 'Only run specs that do not require net connect'
   RSpec::Core::RakeTask.new(:offline) do |t|
-    t.rspec_opts = "--tag ~requires_net_connect"
+    t.rspec_opts = '--tag ~requires_net_connect'
   end
 
   desc 'Only run specs that require net connect'
   RSpec::Core::RakeTask.new(:online) do |t|
-    t.rspec_opts = "--tag requires_net_connect"
+    t.rspec_opts = '--tag requires_net_connect'
   end
 
   desc 'Run the Travis CI specs'
   task :travis do
     ENV['RAILS_ENV'] = 'test'
-    ENV['SPEC_OPTS'] = "--profile 20"
+    ENV['SPEC_OPTS'] = '--profile 20'
+    ENV['ORCID_APP_ID'] = 'bleck'
+    ENV['ORCID_APP_SECRET'] = 'bleck'
     Rake::Task['engine_cart:clean'].invoke
     Rake::Task['engine_cart:generate'].invoke
     Rake::Task['spec:offline'].invoke
   end
 end
-Rake::Task["default"].clear rescue nil
-Rake::Task["spec"].clear
 
-task :spec => 'spec:offline'
-task :default => :spec
+begin
+  Rake::Task['default'].clear
+rescue RuntimeError
+  # This isn't a big deal if we don't have a default
+end
+
+Rake::Task['spec'].clear
+
+task spec: 'spec:offline'
+task default: 'spec:travis'

data/app/controllers/orcid/application_controller.rb

@@ -1,14 +1,23 @@
 module Orcid
-  class ApplicationController < ActionController::Base
+  # The foundation for Orcid controllers. A few helpful accessors.
+  class ApplicationController < Orcid.parent_controller.constantize
     private
-    def redirecting_because_user_already_has_a_connected_orcid_profile
-      if orcid_profile = Orcid.profile_for(current_user)
-        flash[:notice] = I18n.t("orcid.requests.messages.previously_connected_profile", orcid_profile_id: orcid_profile.orcid_profile_id)
+
+    def redirecting_because_user_has_connected_orcid_profile
+      if orcid_profile
+        flash[:notice] = I18n.t(
+          'orcid.requests.messages.previously_connected_profile',
+          orcid_profile_id: orcid_profile.orcid_profile_id
+        )
         redirect_to main_app.root_path
         return true
       else
         return false
       end
     end
+
+    def orcid_profile
+      @orcid_profile ||= Orcid.profile_for(current_user)
+    end
   end
 end

data/app/controllers/orcid/profile_connections_controller.rb

@@ -1,23 +1,26 @@
 module Orcid
+  # Responsible for negotiating a user request Profile Creation.
   class ProfileConnectionsController < Orcid::ApplicationController
     respond_to :html
     before_filter :authenticate_user!
 
     def index
-      render text: 'Not yet implemented!'
+      redirecting_because_user_does_not_have_a_connected_orcid_profile ||
+        redirecting_because_user_must_verify_their_connected_profile ||
+        redirecting_because_user_has_verified_their_connected_profile
     end
 
     def new
-      return false if redirecting_because_user_already_has_a_connected_orcid_profile
+      return false if redirecting_because_user_has_connected_orcid_profile
       assign_attributes(new_profile_connection)
-      respond_with(new_profile_connection)
+      respond_with(orcid, new_profile_connection)
     end
 
     def create
-      return false if redirecting_because_user_already_has_a_connected_orcid_profile
+      return false if redirecting_because_user_has_connected_orcid_profile
       assign_attributes(new_profile_connection)
       create_profile_connection(new_profile_connection)
-      respond_with(new_profile_connection)
+      respond_with(orcid, new_profile_connection)
     end
 
     protected
@@ -39,8 +42,33 @@ module Orcid
     end
 
     def new_profile_connection
-      @profile_connection ||= Orcid::ProfileConnection.new(params[:profile_connection])
+      @profile_connection ||= begin
+        Orcid::ProfileConnection.new(params[:profile_connection])
+      end
     end
 
+    def redirecting_because_user_does_not_have_a_connected_orcid_profile
+      return false if orcid_profile
+      flash[:notice] = I18n.t(
+        'orcid.connections.messages.profile_connection_not_found'
+      )
+      redirect_to orcid.new_profile_connection_path
+    end
+
+    def redirecting_because_user_must_verify_their_connected_profile
+      return false unless orcid_profile
+      return false if orcid_profile.verified_authentication?
+
+      redirect_to user_omniauth_authorize_url('orcid')
+    end
+
+    def redirecting_because_user_has_verified_their_connected_profile
+      orcid_profile = Orcid.profile_for(current_user)
+      notice = I18n.t(
+        'orcid.connections.messages.verified_profile_connection_exists',
+        orcid_profile_id: orcid_profile.orcid_profile_id
+      )
+      redirect_to('/', flash: { notice: notice })
+    end
   end
 end

data/app/controllers/orcid/profile_requests_controller.rb

@@ -1,4 +1,5 @@
 module Orcid
+  # Responsible for helping a user request a new Orcid Profile.
   class ProfileRequestsController < Orcid::ApplicationController
     respond_to :html
     before_filter :authenticate_user!
@@ -7,40 +8,40 @@ module Orcid
     helper_method :profile_request
 
     def show
-      return false if redirecting_because_user_already_has_a_connected_orcid_profile
+      return false if redirecting_because_user_has_connected_orcid_profile
       return false if redirecting_because_no_profile_request_was_found
-      respond_with(existing_profile_request)
+      respond_with(orcid, existing_profile_request)
     end
 
     def new
-      return false if redirecting_because_user_already_has_a_connected_orcid_profile
+      return false if redirecting_because_user_has_connected_orcid_profile
       return false if redirecting_because_user_has_existing_profile_request
       assign_attributes(new_profile_request)
-      respond_with(new_profile_request)
+      respond_with(orcid, new_profile_request)
     end
 
     def create
-      return false if redirecting_because_user_already_has_a_connected_orcid_profile
+      return false if redirecting_because_user_has_connected_orcid_profile
       return false if redirecting_because_user_has_existing_profile_request
       assign_attributes(new_profile_request)
       create_profile_request(new_profile_request)
-      respond_with(new_profile_request)
+      respond_with(orcid, new_profile_request)
     end
 
     protected
 
     def redirecting_because_no_profile_request_was_found
       return false if existing_profile_request
-      flash[:notice] = I18n.t("orcid.requests.messages.existing_request_not_found")
-      redirect_to new_profile_request_path
-      true
+      flash[:notice] = I18n.t(
+        'orcid.requests.messages.existing_request_not_found'
+      )
+      redirect_to orcid.new_profile_request_path
     end
 
     def redirecting_because_user_has_existing_profile_request
-      return false if ! existing_profile_request
-      flash[:notice] = I18n.t("orcid.requests.messages.existing_request")
-      redirect_to profile_request_path
-      true
+      return false unless existing_profile_request
+      flash[:notice] = I18n.t('orcid.requests.messages.existing_request')
+      redirect_to orcid.profile_request_path
     end
 
     def existing_profile_request
@@ -60,8 +61,10 @@ module Orcid
     end
 
     def profile_request_params
-      return {} unless params.has_key?(:profile_request)
-      params[:profile_request].permit(:given_names, :family_name, :primary_email, :primary_email_confirmation)
+      return {} unless params.key?(:profile_request)
+      params[:profile_request].permit(
+        :given_names, :family_name, :primary_email, :primary_email_confirmation
+      )
     end
   end
 end

data/app/models/orcid/profile.rb

@@ -1,16 +1,27 @@
 module Orcid
+  # Provides a container around an Orcid Profile and its relation to the Orcid
+  # Works.
   class Profile
-
-    attr_reader :orcid_profile_id, :mapper, :remote_service, :xml_renderer, :xml_parser
+    attr_reader(
+      :orcid_profile_id, :mapper, :remote_service, :xml_renderer, :xml_parser
+    )
     private :mapper
     def initialize(orcid_profile_id, config = {})
       @orcid_profile_id = orcid_profile_id
       @mapper = config.fetch(:mapper) { Orcid.mapper }
-      @remote_service = config.fetch(:remote_service) { Orcid::Remote::WorkService }
+      @remote_service = config.fetch(:remote_service) do
+        Orcid::Remote::WorkService
+      end
       @xml_renderer = config.fetch(:xml_renderer) { Orcid::Work::XmlRenderer }
       @xml_parser = config.fetch(:xml_parser) { Orcid::Work::XmlParser }
     end
 
+    # Answers the question: Has the user been authenticated via the ORCID
+    # system.
+    def verified_authentication?
+      Orcid.authenticated_orcid?(orcid_profile_id)
+    end
+
     def remote_works(options = {})
       @remote_works = nil if options.fetch(:force, false)
       @remote_works ||= begin
@@ -35,10 +46,9 @@ module Orcid
 
     # Note: We can handle
     def normalize_work(*works)
-      Array(works).flatten.compact.collect do |work|
+      Array.wrap(works).map do |work|
         mapper.map(work, target: 'orcid/work')
       end
     end
-
   end
 end

data/app/models/orcid/profile_connection.rb

@@ -6,7 +6,7 @@ module Orcid
     include ActiveModel::Validations
     extend ActiveModel::Naming
 
-    self.class_attribute :available_query_attribute_names
+    class_attribute :available_query_attribute_names
     self.available_query_attribute_names = [:email, :text]
 
     available_query_attribute_names.each do |attribute_name|
@@ -19,27 +19,30 @@ module Orcid
     validates :user, presence: true
     validates :orcid_profile_id, presence: true
 
-
-    def save(config = {})
-      persister = config.fetch(:persister) { Orcid.method(:connect_user_and_orcid_profile) }
+    def save(collaborators = {})
+      persister = collaborators.fetch(:persister) do
+        Orcid.method(:connect_user_and_orcid_profile)
+      end
       valid? ? persister.call(user, orcid_profile_id) : false
     end
 
-    def persisted?; false; end
+    def persisted?
+      false
+    end
 
-    attr_writer :profile_lookup_service
-    def profile_lookup_service
-      @profile_lookup_service ||= default_profile_lookup_service
+    attr_writer :profile_query_service
+    def profile_query_service
+      @profile_query_service ||= default_profile_query_service
     end
-    private :profile_lookup_service
+    private :profile_query_service
 
-    def default_profile_lookup_service
-      ProfileLookupRunner.new {|on|
-        on.found {|results| self.orcid_profile_candidates = results }
+    def default_profile_query_service
+      Remote::ProfileQueryService.new do |on|
+        on.found { |results| self.orcid_profile_candidates = results }
         on.not_found { self.orcid_profile_candidates = [] }
-      }
+      end
     end
-    private :default_profile_lookup_service
+    private :default_profile_query_service
 
     def with_orcid_profile_candidates
       yield(orcid_profile_candidates) if query_requested?
@@ -52,22 +55,19 @@ module Orcid
     end
 
     def lookup_profile_candidates
-      if query_requested?
-        profile_lookup_service.call(query_attributes)
-      end
+      profile_query_service.call(query_attributes) if query_requested?
     end
     private :lookup_profile_candidates
 
     def query_requested?
-      !!available_query_attribute_names.detect { |attribute_name|
+      available_query_attribute_names.any? do |attribute_name|
         attributes[attribute_name].present?
-      }
+      end
     end
     private :query_requested?
 
     def query_attributes
       attributes.slice(*available_query_attribute_names)
     end
-
   end
 end