roboneuro 0.1.1

data/lib/whedon/author.rb

@@ -0,0 +1,81 @@
+module Whedon
+  class Author
+    require 'nameable'
+
+    attr_accessor :name, :affiliation, :orcid
+
+    AUTHOR_FOOTNOTE_REGEX = /^[^\^]*/
+
+    # Initialized with authors & affiliations block in the YAML header from
+    # a JOSS paper e.g. http://joss.theoj.org/about#paper_structure
+    #
+    def initialize(name, orcid, index, affiliations_yaml)
+      name = strip_footnotes(name)
+      @parsed_name = Nameable::Latin.new.parse(name)
+      @name = @parsed_name.to_nameable
+      @orcid = orcid
+      @affiliation = build_affiliation_string(index, affiliations_yaml)
+    end
+
+    def to_h
+      {
+        :given_name => given_name,
+        :middle_name => @parsed_name.middle,
+        :last_name => last_name,
+        :orcid => orcid,
+        :affiliation => affiliation.strip
+      }
+    end
+
+    # Input: Arfon Smith^[Corresponding author: arfon@example.com]
+    # Output: Arfon Smith
+    def strip_footnotes(name)
+      name[AUTHOR_FOOTNOTE_REGEX]
+    end
+
+    # Use the Nameable gem to return last name
+    def last_name
+      @parsed_name.last
+    end
+
+    # Use the Nameable gem to return first name
+    def given_name
+      @parsed_name.first
+    end
+
+    def initials
+      [@parsed_name.first, @parsed_name.middle].compact.map {|v| v[0]}.zip(['.', '.', '.']).map(&:join) * ' '
+    end
+
+    # Takes the author affiliation index and a hash of all affiliations and
+    # associates them. Then builds (and assigns) the author affiliation string.
+    def build_affiliation_string(index, affiliations_yaml)
+      # Some people have two affiliations, if this is the case then we need
+      # to parse each one and build the affiliation string.
+      author_affiliations = []
+
+      return nil if index.nil? # Some authors don't have an affiliation
+
+      affiliations = if index.to_s.include?(',')
+        index.split(',').map { |a| a.strip }
+      else
+        [ index.to_s ]
+      end
+
+      # We need to turn all of the affiliation YAML keys into strings
+      # So that mixed integer and string affiliations work
+      affiliations_yaml = affiliations_yaml.inject({}) {|hash, (key, val)| hash.merge(key.to_s => val) }
+
+      # Raise if we can't parse the string, might be because of this bug :-(
+      # https://bugs.ruby-lang.org/issues/12451
+      affiliations.each do |a|
+        raise "Problem with affiliations for #{self.name}, perhaps the \
+affiliations index need quoting?" unless affiliations_yaml.has_key?(a)
+
+        author_affiliations << affiliations_yaml[a]
+      end
+
+      return author_affiliations.join(', ')
+    end
+  end
+end

data/lib/whedon/bibtex_parser.rb

@@ -0,0 +1,103 @@
+# Whedon::Bibtex is used to generate the citation string used in the Crossref
+# metadata. It uses the bibtex RubyGem.
+
+require 'bibtex'
+require 'nokogiri'
+require 'uri'
+
+# => bib = Whedon::BibtexParser.new('paper.bib').generate_citations
+module Whedon
+  class BibtexParser
+    # Initialize the Bibtex generator
+    # Takes a path to bibtex file
+    def initialize(bib_file)
+      @bib_file = bib_file
+      @ref_count = 1
+      @citation_string = ""
+    end
+
+    def bibtex_keys
+      entries = BibTeX.open(@bib_file, :filter => :latex)
+
+      keys = []
+      entries.each do |entry|
+        next if entry.comment?
+        next if entry.preamble?
+
+        keys << "@#{entry.key}"
+      end
+
+      return keys
+    end
+
+    # Generates the <citations></citations> XML block for Crossref
+    # Returns an XML fragment <citations></citations> with or
+    # without citations within
+    # TODO: should probably use Ruby builder templates here
+    def generate_citations(citations=nil)
+      entries = BibTeX.open(@bib_file, :filter => :latex)
+
+      if entries.empty?
+        @citation_string = ""
+      else
+        entries.each do |entry|
+          next if entry.comment?
+          next if entry.preamble?
+
+          if citations
+            next unless citations.include?("@#{entry.key}")
+          end
+          @citation_string << make_citation(entry)
+          @ref_count += 1
+        end
+      end
+
+      # This Nokogiri step is simply to pretty-print the XML of the citations
+      doc = Nokogiri::XML("<citation_list>#{@citation_string}</citation_list>")
+      return doc.root.to_xml
+    end
+
+    # Chooses what sort of citation to make based upon whether there is a DOI
+    # present in the bibtex entry
+    def make_citation(entry)
+      if entry.has_field?('doi') && !entry.doi.empty?
+        return doi_citation(entry)
+      else
+        return general_citation(entry)
+      end
+    end
+
+    # Returns a simple <citation> XML snippet with the DOI
+    def doi_citation(entry)
+      # Crossref DOIs need to be strings like 10.21105/joss.01461 rather
+      # than https://doi.org/10.21105/joss.01461
+      bare_doi = entry.doi.to_s[/\b(10[.][0-9]{4,}(?:[.][0-9]+)*\/(?:(?!["&\'<>])\S)+)\b/]
+
+      # Check for shortDOI formatted DOIs http://shortdoi.org
+      if bare_doi.nil?
+        bare_doi = entry.doi.to_s[/\b(10\/[a-bA-z0-9]+)\b/]
+      end
+
+      # Sometimes there are weird characters in the DOI. This escapes
+      escaped_doi = bare_doi.encode(:xml => :text)
+      "<citation key=\"ref#{@ref_count}\"><doi>#{escaped_doi}</doi></citation>"
+    end
+
+    # Returns a more complex <citation> XML snippet with keys for each of the
+    # bibtex fields
+    def general_citation(entry)
+      citation = "<citation key=\"ref#{@ref_count}\"><unstructured_citation>"
+      values = []
+      entry.each_pair do |name, value|
+        # Ultimately we should call entry.to_citeproce here to parse this properly.
+        # https://github.com/inukshuk/bibtex-ruby/pull/139/files
+        value = value.gsub('\urlhttp', 'http')
+        values << value.encode(:xml => :text)
+      end
+      citation << values.join(', ')
+      citation << "</unstructured_citation></citation>"
+
+      return citation
+    end
+  end
+end

data/lib/whedon/compilers.rb

@@ -0,0 +1,379 @@
+# This module has methods to compile PDFs and Crossref XML depending upon
+# the content type of the paper (Markdown or LaTeX)
+module Compilers
+  require 'date'
+  require 'yaml'
+
+  # Generate the paper PDF
+  # Optionally pass in a custom branch name as first param
+  def generate_pdf(custom_branch=nil, draft=true, paper_issue=nil, paper_volume=nil, paper_year=nil)
+    if paper.latex_source?
+      pdf_from_latex(custom_branch, draft, paper_issue, paper_volume, paper_year)
+    elsif paper.markdown_source?
+      pdf_from_markdown(custom_branch, draft, paper_issue, paper_volume, paper_year)
+    end
+  end
+
+  def generate_crossref(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    if paper.latex_source?
+      crossref_from_latex(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    elsif paper.markdown_source?
+      crossref_from_markdown(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    end
+  end
+
+  def generate_jats(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    if paper.latex_source?
+      jats_from_latex(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    elsif paper.markdown_source?
+      jats_from_markdown(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    end
+  end
+
+  def pdf_from_latex(custom_branch=nil, draft=true, paper_issue=nil, paper_volume=nil, paper_year=nil)
+    # Optionally pass a custom branch name
+    `cd #{paper.directory} && git checkout #{custom_branch} --quiet` if custom_branch
+
+    metadata = YAML.load_file("#{paper.directory}/paper.yml")
+
+    for k in ["title", "authors", "affiliations", "keywords"]
+      raise "Key #{k} not present in metadata" unless metadata.keys().include?(k)
+    end
+
+    # Remove everything that shouldn't be there before processing
+
+    `cd #{paper.directory} && rm -f *.aux \
+    && rm -f *.blg && rm -f *.fls && rm -f *.log\
+    && rm -f *.fdb_latexmk`
+
+    open("#{paper.directory}/header.tex", 'w') do |f|
+      f << "% **************GENERATED FILE, DO NOT EDIT**************\n\n"
+      f << "\\title{#{metadata["title"]}}\n\n"
+      for auth in metadata["authors"]
+        f << "\\author[#{auth["affiliation"]}]{#{auth["name"]}}\n"
+      end
+      for aff in metadata["affiliations"]
+        f << "\\affil[#{aff["index"]}]{#{aff["name"]}}\n"
+      end
+      f << "\n\\keywords{"
+      for i in 0...metadata["keywords"].length-1
+        f << "#{metadata["keywords"][i]}, "
+      end
+      f << metadata["keywords"].last
+      f << "}\n"
+      
+      # draft mode by default.
+      if draft
+        f << "\\usepackage{draftwatermark}\n\n"
+      end
+    end
+
+    `cd #{paper.directory} && latexmk -f -bibtex -pdf paper.tex`
+
+    if File.exists?("#{paper.directory}/paper.pdf")
+      `mv #{paper.directory}/paper.pdf #{paper.directory}/#{paper.filename_doi}.pdf`
+      puts "#{paper.directory}/#{paper.filename_doi}.pdf"
+    else
+      abort("Looks like we failed to compile the PDF")
+    end
+  end
+
+  def generate_issue(date)
+    parsed = Date.parse(date)
+    return 1 + ((parsed.year * 12 + parsed.month) - (Time.parse(ENV['JOURNAL_LAUNCH_DATE']).year * 12 + Time.parse(ENV['JOURNAL_LAUNCH_DATE']).month))
+  end
+
+  def generate_volume(date)
+    parsed = Date.parse(date)
+    return parsed.year - (Date.parse(ENV['JOURNAL_LAUNCH_DATE']).year - 1)
+  end
+
+  def generate_year(date)
+    parsed = Date.parse(date)
+    return parsed.year
+  end
+
+  def generate_month(date)
+    parsed = Date.parse(date)
+    return parsed.month
+  end
+
+  def generate_day(date)
+    parsed = Date.parse(date)
+    return parsed.day
+  end
+
+  def pdf_from_markdown(custom_branch=nil, draft=true, paper_issue=nil, paper_volume=nil, paper_year=nil)
+    latex_template_path = "#{Whedon.resources}/#{ENV['JOURNAL_ALIAS']}/latex.template"
+    csl_file = "#{Whedon.resources}/#{ENV['JOURNAL_ALIAS']}/apa.csl"
+
+    url = "#{ENV['JOURNAL_URL']}/papers/lookup/#{@review_issue_id}"
+    response = RestClient.get(url)
+    parsed = JSON.parse(response)
+    submitted = parsed['submitted']
+    published = parsed['accepted']
+
+    # TODO - remove this once JOSE has their editors hooked up in the system
+    if ENV['JOURNAL_ALIAS'] == "joss" && !paper.editor.nil?
+      editor_lookup_url = "#{ENV['JOURNAL_URL']}/editors/lookup/#{paper.editor}"
+      response = RestClient.get(editor_lookup_url)
+      parsed = JSON.parse(response)
+      editor_name = parsed['name']
+      editor_url = parsed['url']
+    else
+      editor_name = "Pending Editor"
+      editor_url = "http://example.com"
+    end
+
+    # If we have already published the paper then overwrite the year, volume, issue
+    if published
+      paper_year = generate_year(published)
+      paper_issue = generate_issue(published)
+      paper_volume = generate_volume(published)
+    else
+      published = Time.now.strftime('%d %B %Y')
+      paper_year ||= @current_year
+      paper_issue ||= @current_issue
+      paper_volume ||= @current_volume
+    end
+
+    # Optionally pass a custom branch name
+    `cd #{paper.directory} && git checkout #{custom_branch} --quiet` if custom_branch
+
+    metadata = {
+      "repository" => repository_address,
+      "archive_doi" => archive_doi,
+      "paper_url" => paper.pdf_url,
+      "journal_name" => ENV['JOURNAL_NAME'],
+      "review_issue_url" => paper.review_issue_url,
+      "issue" => paper_issue,
+      "volume" => paper_volume,
+      "page" => paper.review_issue_id,
+      "logo_path" => "#{Whedon.resources}/#{ENV['JOURNAL_ALIAS']}/logo.png",
+      "aas_logo_path" => "#{Whedon.resources}/#{ENV['JOURNAL_ALIAS']}/aas-logo.png",
+      "year" => paper_year,
+      "submitted" => submitted,
+      "published" => published,
+      "formatted_doi" => paper.formatted_doi,
+      "citation_author" => paper.citation_author,
+      "editor_name" => editor_name,
+      "reviewers" => paper.reviewers_without_handles,
+      "link-citations" => true
+    }
+
+    metadata.merge!({"draft" => true}) if draft
+
+    File.open("#{paper.directory}/markdown-metadata.yaml", 'w') { |file| file.write(metadata.to_yaml) }
+
+    `cd #{paper.directory} && pandoc \
+    -V repository="#{repository_address}" \
+    -V archive_doi="#{archive_doi}" \
+    -V review_issue_url="#{paper.review_issue_url}" \
+    -V editor_url="#{editor_url}" \
+    -V graphics="true" \
+    -o #{paper.filename_doi}.pdf -V geometry:margin=1in \
+    --pdf-engine=xelatex \
+    --citeproc #{File.basename(paper.paper_path)} \
+    --from markdown+autolink_bare_uris \
+    --csl=#{csl_file} \
+    --template #{latex_template_path} \
+    --metadata-file=markdown-metadata.yaml`
+
+    if File.exists?("#{paper.directory}/#{paper.filename_doi}.pdf")
+      puts "#{paper.directory}/#{paper.filename_doi}.pdf"
+    else
+      abort("Looks like we failed to compile the PDF")
+    end
+  end
+
+  def crossref_from_latex(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    cross_ref_template_path = "#{Whedon.resources}/crossref.template"
+    bibtex = Whedon::BibtexParser.new(paper.bibtex_path)
+
+    # Pass the citations that are actually in the paper to the CrossRef
+    # citations generator.
+
+    citations_in_paper = File.read(paper.paper_path).scan(/(?<=\\cite\{)\w+/)
+    # FIXME
+    # Because of the way citations are handled in Pandoc, we need to prepend and @
+    # to the front of each of the citation strings.
+    citations_in_paper = citations_in_paper.map {|c| c.prepend("@")}
+
+    citations = bibtex.generate_citations(citations_in_paper)
+    authors = paper.crossref_authors
+    # TODO fix this when we update the DOI URLs
+    # crossref_doi = archive_doi.gsub("http://dx.doi.org/", '')
+
+    paper_day ||= Time.now.strftime('%d')
+    paper_month ||= Time.now.strftime('%m')
+    paper_year ||= @current_year
+    paper_issue ||= @current_issue
+    paper_volume ||= @current_volume
+
+    `cd #{paper.directory} && pandoc \
+    -V timestamp=#{Time.now.strftime('%Y%m%d%H%M%S')} \
+    -V doi_batch_id=#{generate_doi_batch_id} \
+    -V formatted_doi=#{paper.formatted_doi} \
+    -V archive_doi=#{archive_doi} \
+    -V review_issue_url=#{paper.review_issue_url} \
+    -V paper_url=#{paper.pdf_url} \
+    -V joss_resource_url=#{paper.joss_resource_url} \
+    -V journal_alias=#{ENV['JOURNAL_ALIAS']} \
+    -V journal_abbrev_title=#{ENV['JOURNAL_ALIAS'].upcase} \
+    -V journal_url=#{ENV['JOURNAL_URL']} \
+    -V journal_name='#{ENV['JOURNAL_NAME']}' \
+    -V journal_issn=#{ENV['JOURNAL_ISSN']} \
+    -V citations='#{citations}' \
+    -V authors='#{authors}' \
+    -V month=#{paper_month} \
+    -V day=#{paper_day} \
+    -V year=#{paper_year} \
+    -V issue=#{paper_issue} \
+    -V volume=#{paper_volume} \
+    -V page=#{paper.review_issue_id} \
+    -V title='#{paper.plain_title}' \
+    -f markdown #{File.basename(paper.paper_path)} -o #{paper.filename_doi}.crossref.xml \
+    --template #{cross_ref_template_path}`
+
+    if File.exists?("#{paper.directory}/#{paper.filename_doi}.crossref.xml")
+      "#{paper.directory}/#{paper.filename_doi}.crossref.xml"
+    else
+      abort("Looks like we failed to compile the Crossref XML")
+    end
+  end
+
+  def crossref_from_markdown(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    cross_ref_template_path = "#{Whedon.resources}/crossref.template"
+    bibtex = Whedon::BibtexParser.new(paper.bibtex_path)
+
+    # Pass the citations that are actually in the paper to the CrossRef
+    # citations generator.
+
+    citations_in_paper = File.read(paper.paper_path).scan(/@[\w|\-|:|_|\/|\+]+/)
+    citations = bibtex.generate_citations(citations_in_paper)
+    authors = paper.crossref_authors
+    # TODO fix this when we update the DOI URLs
+    # crossref_doi = archive_doi.gsub("http://dx.doi.org/", '')
+
+    url = "#{ENV['JOURNAL_URL']}/papers/lookup/#{@review_issue_id}"
+    response = RestClient.get(url)
+    parsed = JSON.parse(response)
+    submitted = parsed['submitted']
+    published = parsed['accepted']
+
+    # If we have already published the paper then overwrite the year, volume, issue
+    if published
+      paper_day = generate_day(published)
+      paper_month = generate_month(published)
+      paper_year = generate_year(published)
+      paper_issue = generate_issue(published)
+      paper_volume = generate_volume(published)
+    else
+      paper_issue ||= @current_issue
+      paper_volume ||= @current_volume
+      paper_day ||= Time.now.strftime('%d')
+      paper_month ||= Time.now.strftime('%m')
+      paper_year ||= Time.now.strftime('%Y')
+    end
+
+    metadata = {
+      "timestamp" => Time.now.strftime('%Y%m%d%H%M%S'),
+      "doi_batch_id" => generate_doi_batch_id,
+      "formatted_doi" => paper.formatted_doi,
+      "archive_doi" => archive_doi,
+      "review_issue_url" => paper.review_issue_url,
+      "paper_url" => paper.pdf_url,
+      "joss_resource_url" => paper.joss_resource_url,
+      "journal_alias" => ENV['JOURNAL_ALIAS'],
+      "journal_abbrev_title" => ENV['JOURNAL_ALIAS'].upcase,
+      "journal_url" => ENV['JOURNAL_URL'],
+      "journal_name" => ENV['JOURNAL_NAME'],
+      "journal_issn"=> ENV['JOURNAL_ISSN'],
+      "month" => paper_month,
+      "day" => paper_day,
+      "year" => paper_year,
+      "issue" => paper_issue,
+      "volume" => paper_volume,
+      "page" => paper.review_issue_id,
+      "title" => paper.plain_title,
+      "crossref_authors" => authors,
+      "citations" => citations
+    }
+
+    File.open("#{paper.directory}/crossref-metadata.yaml", 'w') { |file| file.write(metadata.to_yaml) }
+
+    `cd #{paper.directory} && pandoc \
+    -V title="#{paper.plain_title}" \
+    -f markdown #{File.basename(paper.paper_path)} -o #{paper.filename_doi}.crossref.xml \
+    --template #{cross_ref_template_path} \
+    --metadata-file=crossref-metadata.yaml`
+
+    if File.exists?("#{paper.directory}/#{paper.filename_doi}.crossref.xml")
+      doc = Nokogiri::XML(File.open("#{paper.directory}/#{paper.filename_doi}.crossref.xml", "r"), &:noblanks)
+      File.open("#{paper.directory}/#{paper.filename_doi}.crossref.xml", 'w') {|f| f.write(doc.to_xml(:indent => 2))}
+      "#{paper.directory}/#{paper.filename_doi}.crossref.xml"
+    else
+      abort("Looks like we failed to compile the Crossref XML")
+    end
+  end
+
+  def jats_from_latex(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    "JATS from LaTeX"
+  end
+
+  def jats_from_markdown(paper_issue=nil, paper_volume=nil, paper_year=nil, paper_month=nil, paper_day=nil)
+    latex_template_path = "#{Whedon.resources}/latex.template"
+    jats_template_path = "#{Whedon.resources}/jats.template"
+    csl_file = "#{Whedon.resources}/jats.csl"
+
+
+    url = "#{ENV['JOURNAL_URL']}/papers/lookup/#{@review_issue_id}"
+    response = RestClient.get(url)
+    parsed = JSON.parse(response)
+    submitted = parsed['submitted']
+    published = parsed['accepted']
+
+    # If we have already published the paper then overwrite the year, volume, issue
+    if published
+      paper_day = Date.parse(published).strftime('%d')
+      paper_year = generate_year(published)
+      paper_issue = generate_issue(published)
+      paper_volume = generate_volume(published)
+    else
+      paper_day ||= Time.now.strftime('%d')
+      paper_month ||= Time.now.strftime('%m')
+      paper_year ||= Time.now.strftime('%Y')
+    end
+
+    # TODO: may eventually want to swap out the latex template
+    `cd #{paper.directory} && pandoc \
+    -V repository="#{repository_address}" \
+    -V archive_doi="#{archive_doi}" \
+    -V paper_url="#{paper.pdf_url}" \
+    -V journal_name='#{ENV['JOURNAL_NAME']}' \
+    -V journal_issn=#{ENV['JOURNAL_ISSN']} \
+    -V journal_abbrev_title=#{ENV['JOURNAL_ALIAS']} \
+    -V graphics="true" \
+    -V issue="#{paper_issue}" \
+    -V volume="#{paper_volume}" \
+    -V page="#{paper.review_issue_id}" \
+    -V logo_path="#{Whedon.resources}/#{ENV['JOURNAL_ALIAS']}-logo.png" \
+    -V month=#{paper_month} \
+    -V day=#{paper_day} \
+    -V year="#{paper_year}" \
+    -V jats_authors='#{paper.jats_authors}' \
+    -V jats_affiliations='#{paper.jats_affiliations}' \
+    -t jats \
+    -s \
+    --citeproc \
+    -o #{paper.filename_doi}.jats.xml  \
+    #{File.basename(paper.paper_path)} \
+    --template #{jats_template_path}`
+
+    if File.exists?("#{paper.directory}/#{paper.filename_doi}.jats.xml")
+      "#{paper.directory}/#{paper.filename_doi}.jats.xml"
+    else
+      abort("Looks like we failed to compile the JATS XML")
+    end
+  end
+end

data/lib/whedon/github.rb

@@ -0,0 +1,12 @@
+# How we connect to GitHub.
+
+module GitHub
+  # Authenticated Octokit
+  # TODO remove license preview media type when this ships
+  MEDIA_TYPE = "application/vnd.github.drax-preview+json"
+
+  def client
+    @client ||= Octokit::Client.new(:access_token => ENV['GH_TOKEN'],
+                                    :default_media_type => MEDIA_TYPE)
+  end
+end

data/lib/whedon/orcid_validator.rb

@@ -0,0 +1,83 @@
+class String
+  def numeric?
+    Float(self) != nil rescue false
+  end
+end
+
+module Whedon
+  class OrcidValidator
+    attr_reader :orcid
+
+    def initialize(orcid)
+      @orcid = orcid.strip
+    end
+
+    # Returns true or false
+    def validate
+      return false unless check_structure
+      return false unless check_length
+      return false unless check_chars
+
+      if checksum_char == "X" || checksum_char == "x"
+        return checksum == 10
+      else
+        return checksum == checksum_char.to_i
+      end
+    end
+
+    def packed_orcid
+      orcid.gsub('-', '')
+    end
+
+    # Returns the last character of the string
+    def checksum_char
+      packed_orcid[-1]
+    end
+
+    def first_11
+      packed_orcid.chop
+    end
+
+    def check_structure
+      groups = orcid.split('-')
+      if groups.size == 4
+        return true
+      else
+        warn("ORCID looks malformed") and return false
+      end
+    end
+
+    def check_length
+      if packed_orcid.length == 16
+        return true
+      else
+        warn("ORCID looks to be the wrong length") and return false
+      end
+    end
+
+    def check_chars
+      valid = true
+      first_11.each_char do |c|
+        if !c.numeric?
+          warn("Invalid ORDIC digit (#{c})")
+          valid = false
+        end
+      end
+
+      return valid
+    end
+
+    # https://support.orcid.org/knowledgebase/articles/116780-structure-of-the-orcid-identifier
+    def checksum
+      total = 0
+      first_11.each_char do |c|
+        total = (total + c.to_i) * 2
+      end
+
+      remainder = total % 11
+      result = (12 - remainder) % 11
+
+      return result
+    end
+  end
+end